using System.Runtime.CompilerServices;
using UnityEngine;
namespace UnityEditor.Rendering
{
/// <summary>
/// Helper class for drawing shadow cascade with GUI.
/// </summary>
public static class ShadowCascadeGUI
{
private const string kPathToHorizontalGradientTexture = "Packages/com.unity.render-pipelines.core/Editor/Lighting/Icons/HorizontalGradient.png";
private const string kPathToUpSnatchTexture = "Packages/com.unity.render-pipelines.core/Editor/Lighting/Icons/UpSnatch.png";
private const string kPathToUpSnatchFocusedTexture = "Packages/com.unity.render-pipelines.core/Editor/Lighting/Icons/UpSnatchFocused.png";
private const string kPathToDownSnatchTexture = "Packages/com.unity.render-pipelines.core/Editor/Lighting/Icons/DownSnatch.png";
private const string kPathTDownSnatchFocusedTexture = "Packages/com.unity.render-pipelines.core/Editor/Lighting/Icons/DownSnatchFocused.png";
private const float kSliderbarMargin = 2.0f;
private const float kSliderbarHeight = 28.0f;
//Value that used in LODSliderRange in normal background texture
private const float kLODSliderRangeModifier = 0.78824f;
// Keep in sync with the ones in Debug.hlsl
private static readonly Color[] kCascadeColors =
{
new Color(0.5f, 0.5f, 0.7f, 1.0f),
new Color(0.5f, 0.7f, 0.5f, 1.0f),
new Color(0.7f, 0.7f, 0.5f, 1.0f),
new Color(0.7f, 0.5f, 0.5f, 1.0f),
};
private static readonly Color kDisabledColor = new Color(0.5f, 0.5f, 0.5f, 0.4f); //Works with both personal and pro skin
private static Vector2 s_DragLastMousePosition;
private static readonly int s_CascadeSliderId = "s_CascadeSliderId".GetHashCode();
private static GUIStyle s_HorizontalGradient = null; // Lazy init
private static GUIStyle s_UpSnatch = null; // Lazy init
private static GUIStyle s_DownSnatch = null; // Lazy init
private static readonly GUIStyle s_CascadeSliderBG = "LODSliderRange"; // Using a LODGroup skin
private static readonly GUIStyle s_TextCenteredStyle = new GUIStyle(EditorStyles.whiteMiniLabel)
{
alignment = TextAnchor.MiddleCenter
};
/// <summary>
/// Represents the state of the cascade handle.
/// </summary>
public enum HandleState
{
/// <summary>
/// Handle will not be drawn.
/// </summary>
Hidden,
/// <summary>
/// Handle will be disabled.
/// </summary>
Disabled,
/// <summary>
/// Handle will be enabled.
/// </summary>
Enabled,
}
/// <summary>
/// Data of single cascade for drawing in GUI.
/// </summary>
public struct Cascade
{
/// <summary>
/// Cascade normalized size that ranges from 0 to 1.
/// Sum of all cascade sizes can not exceed 1.
/// </summary>
public float size;
/// <summary>
/// Cascade border size that ranges from 0 to 1.
/// Border represents the width of shadow blend.
/// Where 0 value result in no blend and 1 will blend from cascade beginning.
/// </summary>
public float borderSize;
/// <summary>
/// Current state of cascade handle that will be used for drawing it.
/// </summary>
public HandleState cascadeHandleState;
/// <summary>
/// Current state of border handle that will be used for drawing it.
/// </summary>
public HandleState borderHandleState;
}
/// <summary>
/// Draw cascades using editor GUI. This also includes handles
/// </summary>
/// <param name="cascades">Array of cascade data.</param>
/// <param name="useMetric">True if numbers should be presented with metric system, otherwise procentage.</param>
/// <param name="baseMetric">The base of the metric system. In most cases it is maximum shadow distance.</param>
public static void DrawCascades(ref Cascade[] cascades, bool useMetric, float baseMetric)
{
// Validate arguments
if (cascades == null || cascades.Length == 0)
{
Debug.LogError($"No cascades passed.");
return;
}
// Validate cascade sizes
float cascadeSizeSum = 0;
for (int i = 0; i < cascades.Length; ++i)
{
cascadeSizeSum += cascades[i].size;
}
if (Mathf.Abs(cascadeSizeSum - 1f) > 0.01f)
{
Debug.LogError($"Cascade total sum of size must be 1.0 (Currently it is {cascadeSizeSum}).");
// Normalize
for (int i = 0; i < cascades.Length; ++i)
{
if (cascadeSizeSum > 0)
cascades[i].size /= cascadeSizeSum;
else
cascades[i].size = (1f / cascades.Length);
}
}
// Validate cascade border sizes
for (int i = 0; i < cascades.Length; ++i)
{
cascades[i].borderSize = Mathf.Clamp01(cascades[i].borderSize);
}
EditorGUILayout.BeginVertical();
// Space for cascade handles
GUILayout.Space(13f);
EditorGUILayout.BeginHorizontal();
// Correctly handle indents
GUILayout.Space(EditorGUI.indentLevel * 15f);
var sliderRect = GUILayoutUtility.GetRect(
GUIContent.none,
s_CascadeSliderBG,
GUILayout.Height(kSliderbarMargin + kSliderbarHeight + kSliderbarMargin),
GUILayout.ExpandWidth(true));
DrawBackgroundBoxGUI(sliderRect, Color.gray);
var formatSymbol = useMetric ? 'm' : '%';
var usableRect = new Rect(sliderRect.x + kSliderbarMargin, sliderRect.y + kSliderbarMargin, sliderRect.width - kSliderbarMargin * 2, sliderRect.height - kSliderbarMargin * 2);
var partitionWidth = 2.0f / EditorGUIUtility.pixelsPerPoint;
var partitionHalfWidth = partitionWidth * 0.5f;
// Calculate pixel perfect cascade widths
float widthForCascades = usableRect.width;
float[] cascadeWidths = new float[cascades.Length];
float sumOfCascadeWidthsWithoutLast = 0;
float startX = 0;
for (int i = 0; i < cascades.Length - 1; ++i)
{
float endX = startX + cascades[i].size * widthForCascades;
float pixelPerfectStartX = Mathf.Round(startX * EditorGUIUtility.pixelsPerPoint) / EditorGUIUtility.pixelsPerPoint;
float pixelPerfectEndX = Mathf.Round(endX * EditorGUIUtility.pixelsPerPoint) / EditorGUIUtility.pixelsPerPoint;
float pixelPerfectCascadeWidth = pixelPerfectEndX - pixelPerfectStartX;
cascadeWidths[i] = pixelPerfectCascadeWidth;
sumOfCascadeWidthsWithoutLast += cascadeWidths[i];
startX = endX;
}
cascadeWidths[cascades.Length - 1] = widthForCascades - sumOfCascadeWidthsWithoutLast;
float currentX = usableRect.x;
for (int i = 0; i < cascades.Length; ++i)
{
ref var cascade = ref cascades[i];
var cascadeWidth = cascadeWidths[i];
bool isLastCascade = (i == cascades.Length - 1);
// Split cascade into cascade without border and border
float borderValue;
float cascadeValue;
float borderWidth;
float cascadeWithoutBorderWidth;
if (cascade.borderHandleState != HandleState.Hidden)
{
borderValue = cascade.size * cascade.borderSize;
cascadeValue = cascade.size - borderValue;
var cascadeWidthWithoutPartition = cascadeWidth;
cascadeWithoutBorderWidth = Mathf.Round(cascadeWidthWithoutPartition * (1 - cascade.borderSize) * EditorGUIUtility.pixelsPerPoint) / EditorGUIUtility.pixelsPerPoint;
borderWidth = cascadeWidth - cascadeWithoutBorderWidth;
}
else
{
borderValue = 0;
cascadeValue = cascade.size;
borderWidth = 0;
cascadeWithoutBorderWidth = cascadeWidth;
}
// Draw cascade
var cascadeRect = new Rect(currentX, usableRect.y, cascadeWithoutBorderWidth, usableRect.height);
currentX += DrawBoxGUI(cascadeRect, kCascadeColors[i]);
// Draw cascade text
float cascadeValueForText = useMetric ? cascadeValue * baseMetric : cascadeValue * 100;
string cascadeText = $"{i}\n{cascadeValueForText:F1}{formatSymbol}";
DrawLabelGUI(cascadeRect, cascadeText, Color.black);
if (cascade.borderHandleState != HandleState.Hidden)
{
// As we are rounding everything against pixel per point and subtracting from total it might result in fractions for the last cascade border
if (isLastCascade && cascade.borderSize == 0.0)
borderWidth = 0;
// Draw border snatch handle
var borderPartitionHandleRect = new Rect(
currentX - 6 - partitionHalfWidth,
usableRect.y + usableRect.height - 1,
12,
18);
var enabled = cascade.borderHandleState == HandleState.Enabled;
var borderPartitionColor = enabled ? kCascadeColors[i] : kDisabledColor;
var delta = DrawSnatchWithHandle(borderPartitionHandleRect, cascadeWidth, borderPartitionColor, GetUpSnatchStyle(), enabled);
cascade.borderSize = Mathf.Clamp01(cascade.borderSize - delta);
// Draw border partition
DrawBoxGUI(new Rect(currentX - partitionWidth, usableRect.y, partitionWidth, usableRect.height), Color.black);
// Draw border
var borderRect = new Rect(currentX, usableRect.y, borderWidth, usableRect.height);
var gradientLeftColor = kCascadeColors[i];
var gradientRightColor = isLastCascade ? Color.black : kCascadeColors[i + 1];
currentX += DrawGradientBoxGUI(borderRect, gradientLeftColor, gradientRightColor);
// Draw border text
float borderValueForText = useMetric ? borderValue * baseMetric : borderValue * 100;
string borderText;
if (isLastCascade)
{
string fallbackText = (borderWidth < 57) ? "F." : "Fallback";
borderText = $"{i}\u2192{fallbackText}\n{borderValueForText:F1}{formatSymbol}";
}
else
{
borderText = $"{i}\u2192{i + 1}\n{borderValueForText:F1}{formatSymbol}";
}
DrawLabelGUI(borderRect, borderText, Color.black);
}
if (!isLastCascade) // Don't draw partition for last cascade
{
if (cascade.cascadeHandleState != HandleState.Hidden)
{
// Draw cascade partition snatch handle
var cascadeHandleRect = new Rect(
currentX - 6 - partitionHalfWidth,
usableRect.y - 19 + 1,
12,
18);
var enabled = cascade.cascadeHandleState == HandleState.Enabled;
var cascadePartitionColor = enabled ? kCascadeColors[i + 1] : kDisabledColor;
var delta = DrawSnatchWithHandle(cascadeHandleRect, usableRect.width, cascadePartitionColor, GetDownSnatchStyle(), enabled);
if (delta != 0)
{
ref var nextCascade = ref cascades[i + 1];
// We want to resize only the current cascade and next cascade
// Lets convert this problem to the slider
var sliderMinimum = 0;
var sliderMaximum = cascade.size + nextCascade.size;
var sliderPosition = cascade.size + delta;
// Force minimum cascade size and prevent cascade going out of bounds
var cascadeMinimumSize = 0.001f;
var sliderPositionPixelPerfectClamped = Mathf.Clamp(sliderPosition,
sliderMinimum + cascadeMinimumSize, sliderMaximum - cascadeMinimumSize);
cascade.size = sliderPositionPixelPerfectClamped;
nextCascade.size = sliderMaximum - sliderPositionPixelPerfectClamped;
}
}
// Draw cascade partition
DrawBoxGUI(new Rect(currentX - partitionWidth, usableRect.y, partitionWidth, usableRect.height), Color.black);
}
}
EditorGUILayout.EndHorizontal();
// Space for border handles
GUILayout.Space(15f);
EditorGUILayout.EndVertical();
}
private static float DrawBackgroundBoxGUI(Rect rect, Color color)
{
var cachedColor = GUI.backgroundColor;
GUI.backgroundColor = color;
GUI.Box(rect, GUIContent.none);
GUI.backgroundColor = cachedColor;
return rect.width;
}
private static float DrawGradientBoxGUI(Rect rect, Color leftColor, Color rightColor)
{
if (s_HorizontalGradient == null)
{
var horizontalGradientTexture = AssetDatabase.LoadAssetAtPath<Texture2D>(kPathToHorizontalGradientTexture);
Debug.Assert(horizontalGradientTexture != null);
s_HorizontalGradient = new GUIStyle();
s_HorizontalGradient.normal.background = horizontalGradientTexture;
}
var cachedColor = GUI.backgroundColor;
// Draw right color as background
GUI.backgroundColor = rightColor;
GUI.Box(rect, GUIContent.none, s_CascadeSliderBG);
// Draw left color as gradient overlay
// Tune the color of overlay gradient to reflect color darkening from s_CascadeSliderBG (LODSliderRange) style which use AnimationRowOdd (LightSkin) texture for that
GUI.backgroundColor = RGBMultiplied(kLODSliderRangeModifier, leftColor);
GUI.Box(rect, GUIContent.none, s_HorizontalGradient);
GUI.backgroundColor = cachedColor;
return rect.width;
}
private static float DrawBoxGUI(Rect rect, Color color)
{
var cachedColor = GUI.backgroundColor;
GUI.backgroundColor = color;
GUI.Box(rect, GUIContent.none, s_CascadeSliderBG);
GUI.backgroundColor = cachedColor;
return rect.width;
}
private static float DrawLabelGUI(Rect rect, string text, Color color)
{
var cachedColor = GUI.backgroundColor;
var oldColor = GUI.color;
GUI.color = color;
GUI.Label(rect, text, s_TextCenteredStyle);
GUI.backgroundColor = cachedColor;
GUI.color = oldColor;
return rect.width;
}
private static float DrawSnatchWithHandle(Rect rect, float distance, Color color, GUIStyle snatch, bool enabled = true)
{
// check for user input on any of the partition handles
// this mechanism gets the current event in the queue... make sure that the mouse is over our control before consuming the event
int sliderControlId = GUIUtility.GetControlID(s_CascadeSliderId, FocusType.Keyboard, rect);
Event currentEvent = Event.current;
EventType eventType = currentEvent.GetTypeForControl(sliderControlId);
if (eventType == EventType.Repaint)
{
bool isFocused = GUIUtility.keyboardControl == sliderControlId && enabled;
bool isHovered = rect.Contains(currentEvent.mousePosition) && enabled;
var cachedColor = GUI.backgroundColor;
// Draw focused with white color as we want to keep original one in texture
GUI.backgroundColor = Color.white;
if (isFocused)
snatch.Draw(rect, false, false, false, isFocused);
// Draw on top of the snatch texture
GUI.backgroundColor = color * (isFocused || isHovered ? 1.4f : 1.0f);
snatch.Draw(rect, false, false, false, false);
GUI.backgroundColor = cachedColor;
}
float delta = 0;
if (enabled)
{
EditorGUIUtility.AddCursorRect(rect, MouseCursor.ResizeHorizontal, sliderControlId);
switch (eventType)
{
case EventType.KeyDown:
if (GUIUtility.keyboardControl != sliderControlId)
break;
if (currentEvent.keyCode == KeyCode.RightArrow)
{
delta = 0.01f;
GUI.changed = true;
currentEvent.Use();
}
else if (currentEvent.keyCode == KeyCode.LeftArrow)
{
delta = -0.01f;
GUI.changed = true;
currentEvent.Use();
}
break;
case EventType.MouseDown:
if (!rect.Contains(currentEvent.mousePosition))
break;
// We do not consume event on purpose.
// In case there is overlapping snatch, this way the last one will be hot control
GUIUtility.hotControl = sliderControlId;
GUIUtility.keyboardControl = sliderControlId;
s_DragLastMousePosition = currentEvent.mousePosition;
break;
case EventType.MouseUp:
// mouseUp event anywhere should release the hotcontrol (if it belongs to us), drags (if any)
if (GUIUtility.hotControl == sliderControlId)
{
GUIUtility.hotControl = 0;
currentEvent.Use();
}
break;
case EventType.MouseDrag:
if (GUIUtility.hotControl != sliderControlId)
break;
delta = (currentEvent.mousePosition - s_DragLastMousePosition).x / (distance);
GUI.changed = true;
s_DragLastMousePosition = currentEvent.mousePosition;
currentEvent.Use();
break;
}
}
return delta;
}
private static GUIStyle GetDownSnatchStyle()
{
if (s_DownSnatch == null)
{
var downSnatch = AssetDatabase.LoadAssetAtPath<Texture2D>(kPathToDownSnatchTexture);
Debug.Assert(downSnatch != null);
var downSnatchFocused = AssetDatabase.LoadAssetAtPath<Texture2D>(kPathTDownSnatchFocusedTexture);
Debug.Assert(downSnatchFocused != null);
s_DownSnatch = new GUIStyle();
s_DownSnatch.normal.background = downSnatch;
s_DownSnatch.hover.background = downSnatch; // We will simulate hover with brighter color
s_DownSnatch.focused.background = downSnatchFocused;
}
return s_DownSnatch;
}
private static GUIStyle GetUpSnatchStyle()
{
if (s_UpSnatch == null)
{
var downSnatch = AssetDatabase.LoadAssetAtPath<Texture2D>(kPathToUpSnatchTexture);
Debug.Assert(downSnatch != null);
var downSnatchFocused = AssetDatabase.LoadAssetAtPath<Texture2D>(kPathToUpSnatchFocusedTexture);
Debug.Assert(downSnatchFocused != null);
s_UpSnatch = new GUIStyle();
s_UpSnatch.normal.background = downSnatch;
s_UpSnatch.hover.background = downSnatch; // We will simulate hover with brighter color
s_UpSnatch.focused.background = downSnatchFocused;
}
return s_UpSnatch;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
static Color RGBMultiplied(float multiplier, Color color)
{
return new Color(color.r * multiplier, color.g * multiplier, color.b * multiplier, color.a);
}
}
}