using UnityEngine;
namespace UnityEditor.TerrainTools
{
/// <summary>
/// Flags passed to NoiseSettingsGUI.OnGUI. Used to specify which portions of the Noise Settings GUI to draw.
/// </summary>
[System.Flags]
internal enum NoiseSettingsGUIFlags
{
Preview = (1 << 0),
Settings = (1 << 1),
All = ( ~0 ),
}
/// <summary>
/// Class used to draw the GUI for Noise Settings.
/// </summary>
internal class NoiseSettingsGUI
{
/// <summary>
/// The SerializedObject for the NoiseSettings that this NoiseSettingsGUI instance is currently rendering the GUI for.
/// </summary>
public SerializedObject serializedNoise;
public bool isScrollingPreview { get; private set; }
// noise settings properties
// noise settings properties
// noise settings properties
// coord space settings properties
private SerializedProperty transformSettings;
private SerializedProperty translation;
private SerializedProperty rotation;
private SerializedProperty scale;
private SerializedProperty flipScaleX;
private SerializedProperty flipScaleY;
private SerializedProperty flipScaleZ;
// domain settings properties
private SerializedProperty domainSettings;
private SerializedProperty noiseTypeName;
private SerializedProperty noiseTypeParams;
private SerializedProperty fractalTypeName;
private SerializedProperty fractalTypeParams;
// filter stack settings
// private SerializedProperty filterSettings;
// private FilterStackView m_filterStackView;
// private FilterStack m_filterStack;
// private SerializedObject m_serializedFilterStack;
// private bool m_showFilterStack;
/// <summary>
/// The current NoiseSettings object that is associated with this instance of NoiseSettingsGUI.
/// </summary>
public NoiseSettings target = null;
/// <summary>
/// Sets up this instance of NoiseSettingsGUI with the specified NoiseSettings object.
/// GUI will be drawn for this NoiseSettings instance.
/// </summary>
/// <param name="noiseSettings"> The NoiseSettings instance for which GUI will be drawn </param>
public void Init(NoiseSettings noiseSettings)
{
Init(new SerializedObject(noiseSettings));
}
/// <summary>
/// Sets up this instance of NoiseSettingsGUI with the specified SerializedObject containing an object reference
/// to a NoiseSettings instance. GUI will be drawn for this serialized NoiseSettings instance.
/// </summary>
/// <param name="serializedNoise"> A SerializedObject instance containing an object reference to a NoiseSettings object </param>
public void Init(SerializedObject serializedNoise)
{
this.serializedNoise = serializedNoise;
target = this.serializedNoise.targetObject as NoiseSettings;
// transform settings
transformSettings = this.serializedNoise.FindProperty("transformSettings");
translation = transformSettings.FindPropertyRelative("translation");
rotation = transformSettings.FindPropertyRelative("rotation");
scale = transformSettings.FindPropertyRelative("scale");
flipScaleX = transformSettings.FindPropertyRelative("flipScaleX");
flipScaleY = transformSettings.FindPropertyRelative("flipScaleY");
flipScaleZ = transformSettings.FindPropertyRelative("flipScaleZ");
// domain settings
domainSettings = this.serializedNoise.FindProperty("domainSettings");
noiseTypeName = domainSettings.FindPropertyRelative("noiseTypeName");
noiseTypeParams = domainSettings.FindPropertyRelative("noiseTypeParams");
fractalTypeName = domainSettings.FindPropertyRelative("fractalTypeName");
fractalTypeParams = domainSettings.FindPropertyRelative("fractalTypeParams");
// filter settings
// filterSettings = serializedNoise.FindProperty( "filterSettings" );
// m_filterStack = filterSettings.FindPropertyRelative( "filterStack" ).objectReferenceValue as FilterStack;
// m_serializedFilterStack = new SerializedObject( m_filterStack );
// m_filterStackView = new FilterStackView( new GUIContent( "Filters" ), m_serializedFilterStack, m_serializedFilterStack.targetObject as FilterStack );
}
/// <summary>
/// Renders the GUI for the NoiseSettings instance associated with this NoiseSettingsGUI instance.
/// </summary>
/// <param name="flags"> Flags specifying which portions of the GUI to draw </param>
public void OnGUI(NoiseSettingsGUIFlags flags = NoiseSettingsGUIFlags.All)
{
serializedNoise.Update();
if((flags & NoiseSettingsGUIFlags.Preview) != 0)
{
DrawPreviewTexture(256f, true);
}
if((flags & NoiseSettingsGUIFlags.Settings) != 0)
{
TerrainToolGUIHelper.DrawFoldout(transformSettings, Styles.transformSettings, TransformSettingsGUI);
TerrainToolGUIHelper.DrawFoldout(domainSettings, Styles.domainSettings, DomainSettingsGUI);
// TerrainToolGUIHelper.DrawFoldout(filterSettings, Styles.filterSettings, FilterSettingsGUI);
}
serializedNoise.ApplyModifiedProperties();
}
bool CheckVector3(System.Func<float, bool> validator, Vector3 value)
{
return validator(value.x) || validator(value.y) || validator(value.z);
}
private void TransformSettingsGUI()
{
Vector3 tv3 = translation.vector3Value;
Vector3 rv3 = rotation.vector3Value;
Vector3 sv3 = scale.vector3Value;
tv3 = EditorGUILayout.Vector3Field(translation.displayName, tv3);
rv3 = EditorGUILayout.Vector3Field(rotation.displayName, rv3);
sv3 = EditorGUILayout.Vector3Field(scale.displayName, sv3);
EditorGUILayout.BeginHorizontal();
{
EditorGUILayout.PrefixLabel(Styles.flipScale);
flipScaleX.boolValue = GUILayout.Toggle(flipScaleX.boolValue, Styles.flipScaleX, GUI.skin.button);
flipScaleY.boolValue = GUILayout.Toggle(flipScaleY.boolValue, Styles.flipScaleY, GUI.skin.button);
flipScaleZ.boolValue = GUILayout.Toggle(flipScaleZ.boolValue, Styles.flipScaleZ, GUI.skin.button);
}
EditorGUILayout.EndHorizontal();
// fix up transform values
// translation
if (!CheckVector3(float.IsNaN, tv3) && !CheckVector3(float.IsInfinity, tv3))
{
translation.vector3Value = tv3;
GUI.changed = true;
}
// rotation
if (!CheckVector3(float.IsNaN, rv3) && !CheckVector3(float.IsInfinity, rv3))
{
rotation.vector3Value = rv3;
GUI.changed = true;
}
// wrap rotation values
if (rotation.vector3Value.x < 0 || rotation.vector3Value.x > 360 ||
rotation.vector3Value.y < 0 || rotation.vector3Value.y > 360 ||
rotation.vector3Value.z < 0 || rotation.vector3Value.z > 360)
{
Vector3 value = rotation.vector3Value;
value.x = (360f + (value.x % 360f)) % 360f;
value.y = (360f + (value.y % 360f)) % 360f;
value.z = (360f + (value.z % 360f)) % 360f;
rotation.vector3Value = value;
GUI.changed = true;
}
// scale
if (!CheckVector3(float.IsNaN, sv3) && !CheckVector3(float.IsInfinity, sv3))
{
scale.vector3Value = sv3;
GUI.changed = true;
}
}
private void DomainSettingsGUI()
{
noiseTypeName.stringValue = NoiseLib.NoiseTypePopup(Styles.noiseType, noiseTypeName.stringValue);
INoiseType noiseType = NoiseLib.GetNoiseTypeInstance(noiseTypeName.stringValue);
noiseTypeParams.stringValue = noiseType?.DoGUI(noiseTypeParams.stringValue);
fractalTypeName.stringValue = NoiseLib.FractalTypePopup(Styles.fractalType, fractalTypeName.stringValue);
IFractalType fractalType = NoiseLib.GetFractalTypeInstance(fractalTypeName.stringValue);
fractalTypeParams.stringValue = fractalType?.DoGUI(fractalTypeParams.stringValue);
}
private void DoMinMaxSliderInt(GUIContent label, SerializedProperty prop, SerializedProperty minMaxProp)
{
int min = minMaxProp.vector2IntValue.x;
int max = minMaxProp.vector2IntValue.y;
prop.intValue = TerrainToolGUIHelper.MinMaxSliderInt(label, prop.intValue, ref min, ref max);
minMaxProp.vector2IntValue = new Vector2Int(min, max);
}
private void DoMinMaxSlider(GUIContent label, SerializedProperty prop, SerializedProperty minMaxProp)
{
float min = minMaxProp.vector2Value.x;
float max = minMaxProp.vector2Value.y;
prop.floatValue = TerrainToolGUIHelper.MinMaxSlider(label, prop.floatValue, ref min, ref max);
minMaxProp.vector2Value = new Vector2(min, max);
}
// private void FilterSettingsGUI()
// {
// m_filterStackView.OnGUI();
// }
private void HandlePreviewTextureInput(Rect previewRect, bool scrollLocked)
{
if(GUIUtility.hotControl != 0)
{
return;
}
Vector3 t = translation.vector3Value;
Vector3 r = rotation.vector3Value;
Vector3 s = scale.vector3Value;
EventType eventType = Event.current.type;
bool draggingPreview = Event.current.button == 0 &&
(eventType == EventType.MouseDown ||
eventType == EventType.MouseDrag);
Vector2 previewDims = new Vector2(previewRect.width, previewRect.height);
Vector2 abs = new Vector2(Mathf.Abs(s.x), Mathf.Abs(s.z));
isScrollingPreview = false;
if (!scrollLocked && Event.current.type == EventType.ScrollWheel)
{
abs += Vector2.one * .001f;
float scroll = Event.current.delta.y;
s.x += abs.x * scroll * .05f;
s.z += abs.y * scroll * .05f;
scale.vector3Value = s;
Event.current.Use();
isScrollingPreview = true;
}
else if (draggingPreview)
{
// change noise offset panning icon
Vector2 sign = new Vector2(-Mathf.Sign(s.x), Mathf.Sign(s.z));
Vector2 delta = Event.current.delta / previewDims * abs * sign;
Vector3 d3 = new Vector3(delta.x, 0, delta.y);
d3 = Quaternion.Euler( r ) * d3;
t += d3;
translation.vector3Value = t;
Event.current.Use();
}
}
/// <summary>
/// Renders an interactive Noise Preview along with tooltip icons and an optional Export button that opens a new ExportNoiseWindow.
/// A background image is also rendered behind the preview that takes up the entire width of the EditorWindow currently being drawn.
/// </summary>
/// <param name = "minSize"> Minimum size for the Preview </param>
/// <param name = "showExportButton"> Whether or not to render the Export button </param>
public void DrawPreviewTexture(float minSize, bool showExportButton = true, bool scrollLocked = false)
{
// Draw label with tooltip
GUILayout.Label( Styles.noisePreview );
float padding = 4f;
float iconWidth = 40f;
int size = (int)Mathf.Min(minSize, EditorGUIUtility.currentViewWidth);
Rect totalRect = GUILayoutUtility.GetRect(EditorGUIUtility.currentViewWidth, size + padding * 2); // extra pixels for highlight border
Color prev = GUI.color;
GUI.color = new Color(.15f, .15f, .15f, 1f);
GUI.DrawTexture(totalRect, Texture2D.whiteTexture, ScaleMode.StretchToFill, false);
GUI.color = Color.white;
// draw info icon
// if(totalRect.Contains(Event.current.mousePosition))
{
Rect infoIconRect = new Rect( totalRect.x + padding, totalRect.y + padding, iconWidth, iconWidth );
GUI.Label( infoIconRect, Styles.infoIcon );
// GUI.Label( infoIconRect, Styles.noiseTooltip );
}
// draw export button
float buttonWidth = GUI.skin.button.CalcSize(Styles.export).x;
float buttonHeight = EditorGUIUtility.singleLineHeight;
Rect exportRect = new Rect( totalRect.xMax - buttonWidth - padding, totalRect.yMax - buttonHeight - padding, buttonWidth, buttonHeight );
if(GUI.Button(exportRect, Styles.export))
{
serializedNoise.ApplyModifiedProperties();
serializedNoise.Update();
ExportNoiseWindow.ShowWindow( serializedNoise.targetObject as NoiseSettings );
}
float safeSpace = Mathf.Max( iconWidth * 2, buttonWidth * 2 ) + padding * 4;
float minWidth = Mathf.Min( size, totalRect.width - safeSpace );
Rect previewRect = new Rect(totalRect.x + totalRect.width / 2 - minWidth / 2, totalRect.y + totalRect.height / 2 - minWidth / 2, minWidth, minWidth);
EditorGUIUtility.AddCursorRect(previewRect, MouseCursor.Pan);
if (previewRect.Contains(Event.current.mousePosition))
{
serializedNoise.Update();
HandlePreviewTextureInput(previewRect, scrollLocked);
serializedNoise.ApplyModifiedProperties();
}
if ( Event.current.type == EventType.Repaint )
{
RenderTexture prevActive = RenderTexture.active;
// create preview RT here and keep until the next Repaint
var previewRT = RenderTexture.GetTemporary(512, 512, 0, NoiseUtils.previewFormat);
NoiseSettings noiseSettings = serializedNoise.targetObject as NoiseSettings;
RenderTexture tempRT = RenderTexture.GetTemporary(512, 512, 0, NoiseUtils.singleChannelFormat);
NoiseUtils.Blit2D(noiseSettings, tempRT);
NoiseUtils.BlitPreview2D(tempRT, previewRT);
RenderTexture.active = prevActive;
GUI.DrawTexture(previewRect, previewRT, ScaleMode.ScaleToFit, false);
RenderTexture.ReleaseTemporary(tempRT);
RenderTexture.ReleaseTemporary(previewRT);
}
GUI.color = prev;
}
public static class Styles
{
public static GUIContent noiseSettings = EditorGUIUtility.TrTextContent("Noise Settings:");
public static GUIContent randomize = EditorGUIUtility.TrTextContent("Randomize");
public static GUIContent reset = EditorGUIUtility.TrTextContent("Reset");
public static GUIContent flipScale = EditorGUIUtility.TrTextContent("Flip Scale", "Flips the scale of the Noise Domain Space");
public static GUIContent flipScaleX = EditorGUIUtility.TrTextContent("X", "Flips the scale of the Noise Domain Space along the X-axis");
public static GUIContent flipScaleY = EditorGUIUtility.TrTextContent("Y", "Flips the scale of the Noise Domain Space along the Y-axis");
public static GUIContent flipScaleZ = EditorGUIUtility.TrTextContent("Z", "Flips the scale of the Noise Domain Space along the Z-axis");
public static GUIContent noiseType = EditorGUIUtility.TrTextContent("Noise Type", "The type of Noise to be used");
public static GUIContent fractalType = EditorGUIUtility.TrTextContent("Fractal Type", "The type of Fractal to be used when generating Noise");
public static GUIContent noisePreview;
public static GUIContent noiseTooltip = EditorGUIUtility.TrTextContent("",
"Scroll Mouse Wheel:\nZooms the preview in and out and changes the noise scale\n\n" +
"Left-mouse Drag:\nPans the noise field and changes the noise translation\n\n" +
"Color Key:\nCyan = negative noise values\nGrayscale = values between 0 and 1\nBlack = values are 0\nRed = Values greater than 1. Used for debugging texture normalization");
public static GUIContent seed = EditorGUIUtility.TrTextContent("Seed");
public static GUIContent domainSettings = EditorGUIUtility.TrTextContent("Domain Settings", "Settings governing the Noise Domain. This is specific to each Noise Type and Fractal Type implementation");
public static GUIContent transformSettings = EditorGUIUtility.TrTextContent("Transform Settings", "Settings governing the transformations applied to positions in the Noise Domain Space");
// public static GUIContent filterSettings = EditorGUIUtility.TrTextContent("Filter Settings");
public static GUIContent ridgePower = EditorGUIUtility.TrTextContent("Ridge Power");
public static GUIContent billowPower = EditorGUIUtility.TrTextContent("Billow Power");
public static GUIContent voronoiPower = EditorGUIUtility.TrTextContent("Voronoi Power");
public static GUIContent power = EditorGUIUtility.TrTextContent("Power");
public static GUIContent export = EditorGUIUtility.TrTextContent("Export", "Open a window providing options for exporting Noise to Textures");
public static GUIContent infoIcon = new GUIContent("", EditorGUIUtility.FindTexture("console.infoicon"),
"Scroll Mouse Wheel:\nZooms the preview in and out and changes the noise scale\n\n" +
"Left-mouse Drag:\nPans the noise field and changes the noise translation\n\n" +
"Color Key:\nCyan = negative noise values\nGrayscale = values between 0 and 1\nBlack = values are 0\nRed = Values greater than 1. Used for debugging texture normalization");
static Styles()
{
noisePreview = EditorGUIUtility.TrTextContent("Noise Field Preview:");
// ,
// "Scroll Mouse Wheel:\nZooms the preview in and out and changes the noise scale\n\n" +
// "Left-mouse Drag:\nPans the noise field and changes the noise translation\n\n" +
// "Color Key:\nCyan = negative noise values\nGrayscale = values between 0 and 1\nBlack = values are 0\nRed = Values greater than 1. Used for debugging texture normalization");
// noisePreview.image = infoIcon.image;
}
}
}
}