768 lines
26 KiB
C#
768 lines
26 KiB
C#
#if UNITY_EDITOR
|
|
using System;
|
|
using UnityEngine;
|
|
using UnityEditor;
|
|
using UnityEngine.Rendering;
|
|
|
|
using UnityEditor.Experimental.TerrainAPI;
|
|
|
|
|
|
namespace Gaia
|
|
{
|
|
|
|
public interface IFloatMinMaxSlider {
|
|
float value { get; set; }
|
|
float minValue { get; set; }
|
|
float maxValue { get; set; }
|
|
|
|
void DrawInspectorGUI();
|
|
}
|
|
|
|
[Serializable]
|
|
public class TerrainFloatMinMaxValue : IFloatMinMaxSlider {
|
|
[SerializeField]
|
|
private bool m_Expanded = false;
|
|
[SerializeField]
|
|
private float m_Value = 0.0f;
|
|
[SerializeField]
|
|
private float m_MinValue = 0.0f;
|
|
[SerializeField]
|
|
private float m_MaxValue = 1.0f;
|
|
[SerializeField]
|
|
private float m_MouseSensitivity = 1.0f;
|
|
[SerializeField]
|
|
private bool m_WrapValue = false;
|
|
|
|
private bool m_EditRange = true;
|
|
private readonly bool m_EditSensitivity = true;
|
|
|
|
private readonly GUIContent m_Label;
|
|
|
|
public float value
|
|
{
|
|
get => m_Value;
|
|
set
|
|
{
|
|
if(m_WrapValue)
|
|
{
|
|
float difference = m_MaxValue - m_MinValue;
|
|
|
|
while(value < m_MinValue)
|
|
{
|
|
value += difference;
|
|
}
|
|
|
|
while(value > m_MaxValue)
|
|
{
|
|
value -= difference;
|
|
}
|
|
|
|
m_Value = value;
|
|
}
|
|
else
|
|
{
|
|
m_Value = Mathf.Clamp(value, m_MinValue, m_MaxValue);
|
|
}
|
|
}
|
|
}
|
|
|
|
public float minValue {
|
|
get => m_MinValue;
|
|
set => m_MinValue = value;
|
|
}
|
|
public float maxValue {
|
|
get => m_MaxValue;
|
|
set => m_MaxValue = value;
|
|
}
|
|
public float mouseSensitivity {
|
|
get => m_MouseSensitivity;
|
|
set => m_MouseSensitivity = value;
|
|
}
|
|
|
|
public bool wrapValue
|
|
{
|
|
get => m_WrapValue;
|
|
set => m_WrapValue = value;
|
|
}
|
|
|
|
public TerrainFloatMinMaxValue(GUIContent label, float value, float minValue, float maxValue, bool editRange = true) {
|
|
m_Expanded = false;
|
|
m_Value = value;
|
|
m_MinValue = minValue;
|
|
m_MaxValue = maxValue;
|
|
m_EditRange = editRange;
|
|
m_EditSensitivity = false;
|
|
m_Label = label;
|
|
}
|
|
|
|
public TerrainFloatMinMaxValue(GUIContent label, float value, float minValue, float maxValue, bool editRange, float mouseSensitivity) : this(label, value, minValue, maxValue, editRange) {
|
|
m_MouseSensitivity = mouseSensitivity;
|
|
m_EditSensitivity = true;
|
|
}
|
|
|
|
public void DrawInspectorGUI() {
|
|
float fieldWidth = EditorGUIUtility.fieldWidth;
|
|
float indentOffset = EditorGUI.indentLevel * 15f;
|
|
Rect totalRect = GUILayoutUtility.GetRect(1, EditorGUIUtility.singleLineHeight);
|
|
Rect labelRect = new Rect(totalRect.x, totalRect.y, EditorGUIUtility.labelWidth - indentOffset, totalRect.height);
|
|
|
|
Rect foldoutRect = new Rect(labelRect.xMax - 8, labelRect.y, 8, totalRect.height);
|
|
Rect sliderRect = new Rect(foldoutRect.xMax, labelRect.y, totalRect.width - labelRect.width, totalRect.height);
|
|
int rectHeight = 1;
|
|
|
|
EditorGUI.PrefixLabel(labelRect, m_Label);
|
|
m_Value = EditorGUI.Slider(sliderRect, m_Value, minValue, maxValue);
|
|
if (m_EditRange)
|
|
{
|
|
m_Expanded = EditorGUI.Foldout(foldoutRect, m_Expanded, GUIContent.none);
|
|
if (m_Expanded)
|
|
{
|
|
if (m_EditRange)
|
|
{
|
|
totalRect = GUILayoutUtility.GetRect(1, EditorGUIUtility.singleLineHeight);
|
|
Rect rangeLabelRect = new Rect(sliderRect.x, sliderRect.yMax, sliderRect.width / 2, totalRect.height);
|
|
Rect minRect = new Rect(totalRect.xMax - 2 * fieldWidth + indentOffset, totalRect.y, fieldWidth, totalRect.height);
|
|
Rect maxRect = new Rect(totalRect.xMax - fieldWidth, totalRect.y, fieldWidth, totalRect.height);
|
|
|
|
EditorGUI.PrefixLabel(rangeLabelRect, new GUIContent("Range:"));
|
|
m_MinValue = EditorGUI.FloatField(minRect, m_MinValue);
|
|
m_MaxValue = EditorGUI.FloatField(maxRect, m_MaxValue);
|
|
}
|
|
|
|
if (m_EditSensitivity)
|
|
{
|
|
totalRect = GUILayoutUtility.GetRect(1, EditorGUIUtility.singleLineHeight);
|
|
Rect sensitivityLabelRect = new Rect(sliderRect.x, totalRect.y, sliderRect.width / 2, totalRect.height);
|
|
Rect sensitivityValueRect = new Rect(totalRect.xMax - fieldWidth, totalRect.y, fieldWidth, totalRect.height);
|
|
|
|
EditorGUI.PrefixLabel(sensitivityLabelRect, new GUIContent("Mouse Sensitivity:"));
|
|
m_MouseSensitivity = EditorGUI.FloatField(sensitivityValueRect, m_MouseSensitivity);
|
|
}
|
|
}
|
|
}
|
|
GUILayoutUtility.GetRect(1, rectHeight);
|
|
}
|
|
}
|
|
|
|
public interface IIntMinMaxSlider {
|
|
int value { get; set; }
|
|
int minValue { get; set; }
|
|
int maxValue { get; set; }
|
|
|
|
void DrawInspectorGUI();
|
|
}
|
|
|
|
[Serializable]
|
|
public class TerrainIntMinMaxValue : IIntMinMaxSlider {
|
|
[SerializeField]
|
|
private bool m_Expanded = false;
|
|
[SerializeField]
|
|
private int m_Value = 0;
|
|
[SerializeField]
|
|
private int m_MinValue = 0;
|
|
[SerializeField]
|
|
private int m_MaxValue = 10;
|
|
|
|
private GUIContent m_Label;
|
|
|
|
public int value {
|
|
get => m_Value;
|
|
set => m_Value = Mathf.Clamp(value, m_MinValue, m_MaxValue);
|
|
}
|
|
public int minValue {
|
|
get => m_MinValue;
|
|
set => m_MinValue = value;
|
|
}
|
|
public int maxValue {
|
|
get => m_MaxValue;
|
|
set => m_MaxValue = value;
|
|
}
|
|
public GUIContent label {
|
|
get => m_Label;
|
|
set => m_Label = value;
|
|
}
|
|
|
|
public TerrainIntMinMaxValue(GUIContent label, int value, int minValue, int maxValue) {
|
|
m_Expanded = false;
|
|
m_Value = value;
|
|
m_MinValue = minValue;
|
|
m_MaxValue = maxValue;
|
|
m_Label = label;
|
|
}
|
|
|
|
public void DrawInspectorGUI() {
|
|
float fieldWidth = EditorGUIUtility.fieldWidth;
|
|
float indentOffset = EditorGUI.indentLevel * 15f;
|
|
Rect totalRect = GUILayoutUtility.GetRect(1, EditorGUIUtility.singleLineHeight);
|
|
Rect labelRect = new Rect(totalRect.x, totalRect.y, EditorGUIUtility.labelWidth - indentOffset, totalRect.height);
|
|
|
|
Rect foldoutRect = new Rect(labelRect.xMax - 8, labelRect.y, 8, totalRect.height);
|
|
Rect sliderRect = new Rect(foldoutRect.xMax, labelRect.y, totalRect.width - labelRect.width, totalRect.height);
|
|
|
|
EditorGUI.PrefixLabel(labelRect, m_Label);
|
|
m_Value = EditorGUI.IntSlider(sliderRect, m_Value, minValue, maxValue);
|
|
|
|
m_Expanded = EditorGUI.Foldout(foldoutRect, m_Expanded, new GUIContent());
|
|
if (m_Expanded) {
|
|
totalRect = GUILayoutUtility.GetRect(1, EditorGUIUtility.singleLineHeight);
|
|
Rect rangeLabelRect = new Rect(sliderRect.x, sliderRect.yMax, sliderRect.width / 2, totalRect.height);
|
|
Rect minRect = new Rect(totalRect.xMax - 2 * fieldWidth + indentOffset, totalRect.y, fieldWidth, totalRect.height);
|
|
Rect maxRect = new Rect(totalRect.xMax - fieldWidth, totalRect.y, fieldWidth, totalRect.height);
|
|
|
|
EditorGUI.PrefixLabel(rangeLabelRect, new GUIContent("Range:"));
|
|
m_MinValue = EditorGUI.IntField(minRect, m_MinValue);
|
|
m_MaxValue = EditorGUI.IntField(maxRect, m_MaxValue);
|
|
}
|
|
GUILayoutUtility.GetRect(1, 2);
|
|
}
|
|
}
|
|
|
|
public static class TerrainToolGUIHelper
|
|
{
|
|
public static GUILayoutOption dontExpandWidth = GUILayout.ExpandWidth(false);
|
|
|
|
public static GUIStyle buttonActiveStyle = null;
|
|
public static GUIStyle buttonNormalStyle = null;
|
|
public static GUIStyle toolbarNormalStyle = null;
|
|
public static GUIStyle toolbarActiveStyle = null;
|
|
public static GUIStyle leftToolbarStyle = null;
|
|
public static GUIStyle midToolbarStyle = null;
|
|
public static GUIStyle midToolbarActiveStyle = null;
|
|
public static GUIStyle rightToolbarStyle = null;
|
|
|
|
static TerrainToolGUIHelper() {
|
|
buttonNormalStyle = new GUIStyle("Button");
|
|
buttonActiveStyle = new GUIStyle("Button");
|
|
buttonActiveStyle.normal.background = buttonNormalStyle.active.background;
|
|
|
|
toolbarNormalStyle = new GUIStyle("ToolbarButton");
|
|
toolbarActiveStyle = new GUIStyle("ToolbarButton");
|
|
toolbarActiveStyle.normal.background = toolbarNormalStyle.hover.background;
|
|
leftToolbarStyle = new GUIStyle("CommandLeft");
|
|
midToolbarStyle = new GUIStyle("CommandMid");
|
|
midToolbarActiveStyle = new GUIStyle("CommandMid");
|
|
midToolbarActiveStyle.normal.background = midToolbarStyle.active.background;
|
|
rightToolbarStyle = new GUIStyle("CommandRight");
|
|
}
|
|
|
|
public static GUIStyle GetButtonToggleStyle(bool isToggled)
|
|
{
|
|
return isToggled ? buttonActiveStyle : buttonNormalStyle;
|
|
}
|
|
|
|
public static GUIStyle GetToolbarToggleStyle(bool isToggled)
|
|
{
|
|
return isToggled ? toolbarActiveStyle : toolbarNormalStyle;
|
|
}
|
|
|
|
public static bool DrawToggleHeaderFoldout(GUIContent title, bool state, ref bool enabled)
|
|
{
|
|
var backgroundRect = GUILayoutUtility.GetRect(1f, 17f);
|
|
|
|
var labelRect = backgroundRect;
|
|
labelRect.xMin += 32f;
|
|
labelRect.xMax -= 20f;
|
|
|
|
var foldoutRect = backgroundRect;
|
|
foldoutRect.xMin += 13f;
|
|
foldoutRect.y += 1f;
|
|
foldoutRect.width = 13f;
|
|
foldoutRect.height = 13f;
|
|
|
|
var toggleRect = foldoutRect;
|
|
toggleRect.x = foldoutRect.xMax + 4f;
|
|
|
|
// Background rect should be full-width
|
|
backgroundRect.xMin = 16f * EditorGUI.indentLevel;
|
|
backgroundRect.xMin = 0;
|
|
|
|
backgroundRect.width += 4f;
|
|
|
|
// Background
|
|
float backgroundTint = EditorGUIUtility.isProSkin ? 0.1f : 1f;
|
|
EditorGUI.DrawRect(backgroundRect, new Color(backgroundTint, backgroundTint, backgroundTint, 0.2f));
|
|
|
|
// Title
|
|
EditorGUI.LabelField(labelRect, title, EditorStyles.boldLabel);
|
|
|
|
// Active checkbox
|
|
state = GUI.Toggle(foldoutRect, state, GUIContent.none, EditorStyles.foldout);
|
|
|
|
// Enabled toggle
|
|
enabled = GUI.Toggle(toggleRect, enabled, GUIContent.none, EditorStyles.toggle);
|
|
|
|
var e = Event.current;
|
|
|
|
if (e.type == EventType.MouseDown && e.button == 0)
|
|
{
|
|
if (toggleRect.Contains(e.mousePosition))
|
|
{
|
|
enabled = !enabled;
|
|
e.Use();
|
|
}
|
|
else if (backgroundRect.Contains(e.mousePosition))
|
|
{
|
|
state = !state;
|
|
e.Use();
|
|
}
|
|
}
|
|
|
|
return state;
|
|
}
|
|
|
|
public static bool DrawToggleHeaderFoldout(GUIContent title, bool state, ref bool enabled, float padding)
|
|
{
|
|
var backgroundRect = GUILayoutUtility.GetRect(1f, 17f);
|
|
|
|
var labelRect = backgroundRect;
|
|
labelRect.xMin += 32f;
|
|
labelRect.xMax -= 20f;
|
|
|
|
var foldoutRect = backgroundRect;
|
|
foldoutRect.xMin += padding;
|
|
foldoutRect.y += 1f;
|
|
foldoutRect.width = 13f;
|
|
foldoutRect.height = 13f;
|
|
|
|
var toggleRect = foldoutRect;
|
|
toggleRect.x = foldoutRect.xMax + 4f;
|
|
|
|
// Background rect should be full-width
|
|
backgroundRect.xMin = padding;
|
|
backgroundRect.xMin = 0;
|
|
|
|
backgroundRect.width += 4f;
|
|
|
|
// Background
|
|
float backgroundTint = EditorGUIUtility.isProSkin ? 0.1f : 1f;
|
|
EditorGUI.DrawRect(backgroundRect, new Color(backgroundTint, backgroundTint, backgroundTint, 0.2f));
|
|
|
|
// Title
|
|
EditorGUI.LabelField(labelRect, title, EditorStyles.boldLabel);
|
|
|
|
// Active checkbox
|
|
state = GUI.Toggle(foldoutRect, state, GUIContent.none, EditorStyles.foldout);
|
|
|
|
// Enabled toggle
|
|
enabled = GUI.Toggle(toggleRect, enabled, GUIContent.none, EditorStyles.toggle);
|
|
|
|
var e = Event.current;
|
|
|
|
if (e.type == EventType.MouseDown && e.button == 0)
|
|
{
|
|
if (toggleRect.Contains(e.mousePosition))
|
|
{
|
|
enabled = !enabled;
|
|
e.Use();
|
|
}
|
|
else if (backgroundRect.Contains(e.mousePosition))
|
|
{
|
|
state = !state;
|
|
e.Use();
|
|
}
|
|
}
|
|
|
|
return state;
|
|
}
|
|
|
|
public static bool DrawHeaderFoldout(GUIContent title, bool state)
|
|
{
|
|
var backgroundRect = GUILayoutUtility.GetRect(1f, 17f);
|
|
|
|
var labelRect = backgroundRect;
|
|
labelRect.xMin += 16f;
|
|
labelRect.xMax -= 20f;
|
|
|
|
var foldoutRect = backgroundRect;
|
|
foldoutRect.y += 1f;
|
|
foldoutRect.width = 13f;
|
|
foldoutRect.height = 13f;
|
|
|
|
|
|
// Background rect should be full-width
|
|
backgroundRect.xMin = 0;
|
|
backgroundRect.width += 4f;
|
|
|
|
// Background
|
|
float backgroundTint = EditorGUIUtility.isProSkin ? 0.1f : 1f;
|
|
EditorGUI.DrawRect(backgroundRect, new Color(backgroundTint, backgroundTint, backgroundTint, 0.2f));
|
|
|
|
// Title
|
|
EditorGUI.LabelField(labelRect, title, EditorStyles.boldLabel);
|
|
|
|
// Active checkbox
|
|
state = GUI.Toggle(foldoutRect, state, GUIContent.none, EditorStyles.foldout);
|
|
|
|
var e = Event.current;
|
|
|
|
if (e.type == EventType.MouseDown && backgroundRect.Contains(e.mousePosition) && e.button == 0)
|
|
{
|
|
state = !state;
|
|
e.Use();
|
|
}
|
|
|
|
return state;
|
|
}
|
|
|
|
#if GAIA_PRO_PRESENT
|
|
public static bool DrawHeaderFoldoutForErosion(GUIContent title, bool state, ResetTool resetMethod)
|
|
{
|
|
var backgroundRect = GUILayoutUtility.GetRect(1f, 17f);
|
|
|
|
var labelRect = backgroundRect;
|
|
labelRect.xMin += 16f;
|
|
labelRect.xMax -= 20f;
|
|
|
|
var foldoutRect = backgroundRect;
|
|
foldoutRect.y += 1f;
|
|
foldoutRect.width = 13f;
|
|
foldoutRect.height = 13f;
|
|
|
|
|
|
// Background rect should be full-width
|
|
backgroundRect.xMin = 0;
|
|
backgroundRect.width += 4f;
|
|
|
|
var gearIconRect = new Rect();
|
|
gearIconRect.y = backgroundRect.y;
|
|
gearIconRect.x = backgroundRect.width - 30f;
|
|
gearIconRect.width = 16f;
|
|
gearIconRect.height = 16f;
|
|
|
|
// Background
|
|
float backgroundTint = EditorGUIUtility.isProSkin ? 0.1f : 1f;
|
|
EditorGUI.DrawRect(backgroundRect, new Color(backgroundTint, backgroundTint, backgroundTint, 0.2f));
|
|
|
|
// Title
|
|
EditorGUI.LabelField(labelRect, title, EditorStyles.boldLabel);
|
|
|
|
// Active checkbox
|
|
state = GUI.Toggle(foldoutRect, state, GUIContent.none, EditorStyles.foldout);
|
|
|
|
bool reset = false;
|
|
//icon
|
|
reset = GUI.Toggle(gearIconRect, reset, EditorGUIUtility.IconContent("_Popup"), EditorStyles.label);
|
|
|
|
var e = Event.current;
|
|
|
|
if (reset)
|
|
{
|
|
GenericMenu menu = new GenericMenu();
|
|
menu.AddItem(new GUIContent("Reset"), false, () => { resetMethod(); });
|
|
menu.ShowAsContext();
|
|
e.Use();
|
|
}
|
|
else if (e.type == EventType.MouseDown && backgroundRect.Contains(e.mousePosition) && e.button == 0)
|
|
{
|
|
state = !state;
|
|
e.Use();
|
|
}
|
|
|
|
if (e.type == EventType.MouseDown && backgroundRect.Contains(e.mousePosition) && e.button == 1)
|
|
{
|
|
GenericMenu menu = new GenericMenu();
|
|
menu.AddItem(new GUIContent("Reset"), false, () => { resetMethod(); });
|
|
menu.ShowAsContext();
|
|
e.Use();
|
|
}
|
|
|
|
return state;
|
|
}
|
|
#endif
|
|
public static bool DrawHeaderFoldoutForBrush(GUIContent title, bool state, ResetBrush resetMethod)
|
|
{
|
|
var backgroundRect = GUILayoutUtility.GetRect(1f, 17f);
|
|
|
|
var labelRect = backgroundRect;
|
|
labelRect.xMin += 16f;
|
|
labelRect.xMax -= 20f;
|
|
|
|
var foldoutRect = backgroundRect;
|
|
foldoutRect.y += 1f;
|
|
foldoutRect.width = 13f;
|
|
foldoutRect.height = 13f;
|
|
|
|
|
|
// Background rect should be full-width
|
|
backgroundRect.xMin = 0;
|
|
backgroundRect.width += 4f;
|
|
|
|
var gearIconRect = new Rect();
|
|
gearIconRect.y = backgroundRect.y;
|
|
gearIconRect.x = backgroundRect.width - 30f;
|
|
gearIconRect.width = 16f;
|
|
gearIconRect.height = 16f;
|
|
|
|
// Background
|
|
float backgroundTint = EditorGUIUtility.isProSkin ? 0.1f : 1f;
|
|
EditorGUI.DrawRect(backgroundRect, new Color(backgroundTint, backgroundTint, backgroundTint, 0.2f));
|
|
|
|
// Title
|
|
EditorGUI.LabelField(labelRect, title, EditorStyles.boldLabel);
|
|
|
|
// Active checkbox
|
|
state = GUI.Toggle(foldoutRect, state, GUIContent.none, EditorStyles.foldout);
|
|
|
|
bool reset = false;
|
|
//icon
|
|
reset = GUI.Toggle(gearIconRect, reset, EditorGUIUtility.IconContent("_Popup"), EditorStyles.label);
|
|
|
|
var e = Event.current;
|
|
|
|
if (reset)
|
|
{
|
|
GenericMenu menu = new GenericMenu();
|
|
menu.AddItem(new GUIContent("Reset"), false, () => { resetMethod(); });
|
|
menu.ShowAsContext();
|
|
e.Use();
|
|
}
|
|
else if (e.type == EventType.MouseDown && backgroundRect.Contains(e.mousePosition) && e.button == 0)
|
|
{
|
|
state = !state;
|
|
e.Use();
|
|
}
|
|
|
|
if (e.type == EventType.MouseDown && backgroundRect.Contains(e.mousePosition) && e.button == 1)
|
|
{
|
|
GenericMenu menu = new GenericMenu();
|
|
menu.AddItem(new GUIContent("Reset"), false, () => { resetMethod(); });
|
|
menu.ShowAsContext();
|
|
e.Use();
|
|
}
|
|
|
|
return state;
|
|
}
|
|
|
|
public static bool DrawToggleFoldout(SerializedProperty prop, GUIContent title, Action func, bool toggled)
|
|
{
|
|
bool state = prop.isExpanded;
|
|
state = DrawToggleHeaderFoldout(title, state, ref toggled);
|
|
|
|
if (state)
|
|
{
|
|
EditorGUI.indentLevel++;
|
|
if (func != null)
|
|
{
|
|
func();
|
|
}
|
|
--EditorGUI.indentLevel;
|
|
}
|
|
|
|
prop.isExpanded = state;
|
|
|
|
return toggled;
|
|
}
|
|
|
|
public static bool DrawFoldout(bool expanded, GUIContent title, Action func)
|
|
{
|
|
bool state = expanded;
|
|
state = DrawHeaderFoldout(title, state);
|
|
|
|
if (state)
|
|
{
|
|
EditorGUI.indentLevel++;
|
|
if (func != null)
|
|
{
|
|
func();
|
|
}
|
|
EditorGUI.indentLevel--;
|
|
}
|
|
|
|
return state;
|
|
}
|
|
|
|
public static void DrawFoldout(SerializedProperty prop, GUIContent title, Action func)
|
|
{
|
|
prop.isExpanded = DrawFoldout(prop.isExpanded, title, func);
|
|
}
|
|
|
|
public static bool ToggleButton(GUIContent content, bool value, params GUILayoutOption[] options)
|
|
{
|
|
if (GUILayout.Button(content, GetButtonToggleStyle(value), options))
|
|
{
|
|
value = !value;
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
public static bool ToggleButton(Rect rect, GUIContent content, bool value)
|
|
{
|
|
if ( GUI.Button( rect, content, GetButtonToggleStyle( value ) ) )
|
|
{
|
|
value = !value;
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
private static Rect GetToolbarRect(GUIContent[] toolbarContent, params GUILayoutOption[] options)
|
|
{
|
|
Debug.Assert(toolbarContent.Length > 0);
|
|
|
|
Rect maxRect = EditorGUILayout.GetControlRect(false, 0f);
|
|
Rect totalRect = new Rect(maxRect.xMin, maxRect.yMin, 0f, 0f);
|
|
Vector2 buttonPos = new Vector2(maxRect.xMin, maxRect.yMin);
|
|
GUIStyle skin = GetToolbarToggleStyle(false);
|
|
//bool newLine = true;
|
|
int linecount = 1;
|
|
|
|
Vector2 buttonSize = skin.CalcSize(toolbarContent[0]);
|
|
|
|
|
|
for (int i = 0; i < toolbarContent.Length; ++i) {
|
|
buttonSize = skin.CalcSize(toolbarContent[i]);
|
|
|
|
if (buttonPos.x + buttonSize.x > maxRect.xMax) {
|
|
buttonPos.x = maxRect.xMin;
|
|
buttonPos.y += buttonSize.y;
|
|
linecount++;
|
|
} else {
|
|
totalRect.xMax = Mathf.Max(buttonPos.x + buttonSize.x, totalRect.xMax);
|
|
}
|
|
|
|
buttonPos.x += buttonSize.x;
|
|
}
|
|
|
|
totalRect.height = buttonSize.y * linecount;
|
|
|
|
return totalRect;
|
|
}
|
|
|
|
public static int HorizontalFlagToolbar(GUIContent[] toolbarContent, int[] enumValues, int selection, params GUILayoutOption[] options)
|
|
{
|
|
Rect toolbarRect = GetToolbarRect(toolbarContent, options);
|
|
|
|
// GUI.Box(totalRect, GUIContent.none);
|
|
|
|
GUILayoutUtility.GetRect(toolbarRect.width, toolbarRect.height / 4);
|
|
// GUI.Box(totalRect, GUIContent.none);
|
|
// Rect maxRect = EditorGUILayout.GetControlRect(false, totalRect.height);
|
|
|
|
Vector2 buttonPos = new Vector2(toolbarRect.xMin, toolbarRect.yMin);
|
|
|
|
for (int i = 0; i < toolbarContent.Length; ++i) {
|
|
int enumVal = enumValues[i];
|
|
bool wasActive = (selection & enumVal) == enumVal && enumVal != 0;
|
|
GUIStyle skin = GetToolbarToggleStyle(wasActive);
|
|
Vector2 buttonSize = skin.CalcSize(toolbarContent[i]);
|
|
|
|
if (buttonPos.x + buttonSize.x > toolbarRect.xMax) {
|
|
buttonPos.x = toolbarRect.xMin;
|
|
buttonPos.y += buttonSize.y;
|
|
}
|
|
|
|
Rect buttonRect = new Rect(buttonPos.x, buttonPos.y, buttonSize.x, buttonSize.y);
|
|
|
|
if (GUI.Button(buttonRect, toolbarContent[i], skin)) {
|
|
if (enumVal == 0) {
|
|
selection = enumVal;
|
|
} else if (enumVal == ~0) {
|
|
selection = wasActive ? ~enumVal : enumVal;
|
|
} else {
|
|
selection = wasActive ? (selection & ~enumVal) : (selection | enumVal);
|
|
}
|
|
}
|
|
|
|
buttonPos.x += buttonSize.x;
|
|
}
|
|
|
|
return selection;
|
|
}
|
|
|
|
// assumes that an enum value of 0 = None and ~0 = Everything
|
|
private static int OLDHorizontalFlagToolbar(GUIContent[] toolbarContent, int[] enumValues, int selection, params GUILayoutOption[] options)
|
|
{
|
|
// TODO(wyatt): Change to use EditorGUIUtility.GetFlowLayoutedRects instead of Begin/EndHorizontal
|
|
Rect widthRect = GUILayoutUtility.GetRect(Screen.width, 17f);
|
|
// GetToolbarRect(true, toolbarContent, options);
|
|
// GUI.Box(widthRect, GUIContent.none);
|
|
Vector2 currPos = widthRect.position;
|
|
Rect totalRect = widthRect;
|
|
bool newLine = true;
|
|
//int skinID = 0; // left = 0, 1 = mid, 2 = right
|
|
|
|
for (int i = 0; i < toolbarContent.Length; ++i) {
|
|
int enumVal = enumValues[i];
|
|
bool wasActive = (selection & enumVal) == enumVal && enumVal != 0;
|
|
GUIStyle skin = GetToolbarToggleStyle(wasActive);
|
|
Vector2 size = skin.CalcSize(toolbarContent[i]);
|
|
Rect buttonRect = new Rect(currPos.x, currPos.y, size.x, size.y);
|
|
|
|
currPos.x += size.x;
|
|
|
|
totalRect.yMax = Mathf.Max(currPos.y + size.y, totalRect.yMax);
|
|
|
|
if (currPos.x + size.x > widthRect.xMax) {
|
|
currPos.x = widthRect.xMin;
|
|
currPos.y += size.y;
|
|
newLine = true;
|
|
}
|
|
|
|
if (newLine) {
|
|
// reserve a rect for the line
|
|
Rect reservedRect = GUILayoutUtility.GetRect(widthRect.width, size.y);
|
|
// GUI.Box(reservedRect, GUIContent.none);
|
|
newLine = false;
|
|
}
|
|
|
|
if (GUI.Button(buttonRect, toolbarContent[i], skin)) {
|
|
if (enumVal == 0) {
|
|
selection = enumVal;
|
|
} else if (enumVal == ~0) {
|
|
selection = wasActive ? ~enumVal : enumVal;
|
|
} else {
|
|
selection = wasActive ? (selection & ~enumVal) : (selection | enumVal);
|
|
}
|
|
}
|
|
}
|
|
|
|
return selection;
|
|
}
|
|
|
|
public static int MinMaxSliderInt(GUIContent label, int value, ref int minValue, ref int maxValue) {
|
|
float fieldWidth = EditorGUIUtility.fieldWidth;
|
|
float indentOffset = EditorGUI.indentLevel * 15f;
|
|
Rect totalRect = GUILayoutUtility.GetRect(1, EditorGUIUtility.singleLineHeight);
|
|
Rect labelRect = new Rect(totalRect.x, totalRect.y, EditorGUIUtility.labelWidth - indentOffset, totalRect.height);
|
|
|
|
Rect sliderRect = new Rect(labelRect.xMax, labelRect.y, totalRect.width - labelRect.width - 2 * fieldWidth - 4, totalRect.height);
|
|
|
|
Rect minLabelRect = new Rect(sliderRect.xMax + 4 - indentOffset, labelRect.y, fieldWidth, totalRect.height);
|
|
Rect minRect = new Rect(minLabelRect.xMax, labelRect.y, fieldWidth / 2 + indentOffset, totalRect.height);
|
|
|
|
Rect maxRect = new Rect(minRect.xMax - indentOffset, sliderRect.y, fieldWidth / 2 + indentOffset, totalRect.height);
|
|
|
|
EditorGUI.PrefixLabel(labelRect, label);
|
|
value = EditorGUI.IntSlider(sliderRect, value, minValue, maxValue);
|
|
EditorGUI.PrefixLabel(minLabelRect, new GUIContent("Range:"));
|
|
minValue = EditorGUI.IntField(minRect, minValue);
|
|
maxValue = EditorGUI.IntField(maxRect, maxValue);
|
|
|
|
return value;
|
|
}
|
|
|
|
public static float MinMaxSlider(GUIContent label, float value, ref float minValue, ref float maxValue) {
|
|
float fieldWidth = EditorGUIUtility.fieldWidth;
|
|
float indentOffset = EditorGUI.indentLevel * 15f;
|
|
Rect totalRect = GUILayoutUtility.GetRect(1, EditorGUIUtility.singleLineHeight);
|
|
Rect labelRect = new Rect(totalRect.x, totalRect.y, EditorGUIUtility.labelWidth - indentOffset, totalRect.height);
|
|
|
|
Rect sliderRect = new Rect(labelRect.xMax, labelRect.y, totalRect.width - labelRect.width - 2 * fieldWidth - 4, totalRect.height);
|
|
|
|
Rect minLabelRect = new Rect(sliderRect.xMax + 4 - indentOffset, labelRect.y, fieldWidth, totalRect.height);
|
|
Rect minRect = new Rect(minLabelRect.xMax, labelRect.y, fieldWidth / 2 + indentOffset, totalRect.height);
|
|
|
|
Rect maxRect = new Rect(minRect.xMax - indentOffset, sliderRect.y, fieldWidth / 2 + indentOffset, totalRect.height);
|
|
|
|
EditorGUI.PrefixLabel(labelRect, label);
|
|
value = EditorGUI.Slider(sliderRect, value, minValue, maxValue);
|
|
EditorGUI.PrefixLabel(minLabelRect, new GUIContent("Range:"));
|
|
minValue = EditorGUI.FloatField(minRect, minValue);
|
|
maxValue = EditorGUI.FloatField(maxRect, maxValue);
|
|
|
|
return value;
|
|
}
|
|
}
|
|
}
|
|
#endif |