Initial commit

Assets/Procedural Worlds/Gaia/Scripts/Unity/Terrain Tools/Erosion/IBrushUIGroup.cs

@@ -0,0 +1,69 @@
+
+using System.Text;
+using UnityEngine;
+using UnityEngine.Experimental.TerrainAPI;
+
+namespace Gaia
+{
+    public delegate void ResetBrush();
+	public interface IBrushUIGroup {
+		/// <summary>
+		/// The normalized size of the brush.
+		/// </summary>
+		float brushSize { get; }
+		
+		/// <summary>
+		/// The rotation of the brush (in degrees).
+		/// </summary>
+		float brushRotation { get; }
+		
+		/// <summary>
+		/// The normalized strength of the brush when applied.
+		/// </summary>
+		float brushStrength { get; }
+		
+		/// <summary>
+		/// The spacing used when applying certain brushes.
+		/// </summary>
+		float brushSpacing { get;  }
+
+
+        string validationMessage { get; set; }
+        /// <summary>
+        /// Are we allowed to paint with this brush?
+        /// </summary>
+        bool allowPaint { get; }
+		
+		bool InvertStrength { get; }
+		bool isInUse { get; }
+
+        //FilterStackView brushMaskFilterStackView { get; }
+        //FilterStack brushMaskFilterStack { get; }
+
+
+        Terrain terrainUnderCursor { get; }
+		bool isRaycastHitUnderCursorValid { get; }
+		RaycastHit raycastHitUnderCursor { get; }
+
+		//void OnInspectorGUI(Terrain terrain, IOnInspectorGUI editContext);
+		//void OnEnterToolMode();
+		//void OnExitToolMode();
+		//void OnPaint(Terrain terrain, IOnPaint editContext);
+		//void OnSceneGUI2D(Terrain terrain, IOnSceneGUI editContext);
+  //      void OnSceneGUI(Terrain terrain, IOnSceneGUI editContext);
+		//void AppendBrushInfo(Terrain terrain, IOnSceneGUI editContext, StringBuilder builder);
+        //RenderTexture GetBrushMask(FilterContext fc, RenderTexture heightContext);
+
+        /// <summary>
+        /// Scatters the brush around the specified UV on the specified terrain. If the scattered UV leaves
+        /// the current terrain then the terrain AND UV are modified for the terrain the UV is now over.
+        /// </summary>
+        /// <param name="terrain">The terrain the scattered UV co-ordinate is actually on.</param>
+        /// <param name="uv">The UV co-ordinate passed in transformed into the UV co-ordinate relative to the scattered terrain.</param>
+        /// <returns>"true" if we scattered to a terrain, "false" if we fell off ALL terrains.</returns>
+        bool ScatterBrushStamp(ref Terrain terrain, ref Vector2 uv);
+		
+		//bool ModifierActive(BrushModifierKey k);
+
+	}
+}

Assets/Procedural Worlds/Gaia/Scripts/Unity/Terrain Tools/Erosion/IBrushUIGroup.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6df698f1e9a4fad4b81a0debb01615ff
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Procedural Worlds/Gaia/Scripts/Unity/Terrain Tools/Erosion/TerrainToolGUIHelper.cs

@@ -0,0 +1,768 @@
+#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

Assets/Procedural Worlds/Gaia/Scripts/Unity/Terrain Tools/Erosion/TerrainToolGUIHelper.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 288487cb63c6bd143aa83198cef71a57
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Procedural Worlds/Gaia/Scripts/Unity/Terrain Tools/Erosion/TerrainToolUtility.cs

@@ -0,0 +1,31 @@
+using UnityEngine;
+
+namespace Gaia {
+
+    #region Utility
+    public static class TerrainToolsUtility {
+
+        //assume this a 1D texture that has already been created
+        public static Vector2 AnimationCurveToRenderTexture(AnimationCurve curve, ref Texture2D tex) {
+
+            tex.wrapMode = TextureWrapMode.Clamp;
+            tex.filterMode = FilterMode.Bilinear;
+
+            float val = curve.Evaluate(0.0f);
+            Vector2 range = new Vector2(val, val);
+
+            Color[] pixels = new Color[tex.width];
+            for (int i = 1; i < tex.width; i++) {
+                float pct = (float)i / (float)tex.width;
+                pixels[i].r = curve.Evaluate(pct);
+                range[0] = Mathf.Min(range[0], pixels[i].r);
+                range[1] = Mathf.Max(range[1], pixels[i].r);
+            }
+            tex.SetPixels(pixels);
+            tex.Apply();
+
+            return range;
+        }
+    }
+    #endregion
+}

Assets/Procedural Worlds/Gaia/Scripts/Unity/Terrain Tools/Erosion/TerrainToolUtility.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: efccdd846892bd64594f3deedfcf5443
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: