forked from BilalY/Rasagar
964 lines
46 KiB
C#
964 lines
46 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
using UnityEngine.Rendering;
|
|
using UnityEngine.Rendering.HighDefinition;
|
|
using UnityEngine.UIElements;
|
|
|
|
namespace UnityEditor.Rendering.HighDefinition
|
|
{
|
|
using CED = CoreEditorDrawer<SerializedFrameSettings>;
|
|
|
|
// Mirrors MaterialQuality enum and adds `FromQualitySettings`
|
|
enum MaterialQualityMode
|
|
{
|
|
Low,
|
|
Medium,
|
|
High,
|
|
FromQualitySettings,
|
|
}
|
|
|
|
static class MaterialQualityModeExtensions
|
|
{
|
|
public static MaterialQuality Into(this MaterialQualityMode quality)
|
|
{
|
|
switch (quality)
|
|
{
|
|
case MaterialQualityMode.High: return MaterialQuality.High;
|
|
case MaterialQualityMode.Medium: return MaterialQuality.Medium;
|
|
case MaterialQualityMode.Low: return MaterialQuality.Low;
|
|
case MaterialQualityMode.FromQualitySettings: return (MaterialQuality)0;
|
|
default: throw new ArgumentOutOfRangeException(nameof(quality));
|
|
}
|
|
}
|
|
|
|
public static MaterialQualityMode Into(this MaterialQuality quality)
|
|
{
|
|
if (quality == (MaterialQuality)0)
|
|
return MaterialQualityMode.FromQualitySettings;
|
|
switch (quality)
|
|
{
|
|
case MaterialQuality.High: return MaterialQualityMode.High;
|
|
case MaterialQuality.Medium: return MaterialQualityMode.Medium;
|
|
case MaterialQuality.Low: return MaterialQualityMode.Low;
|
|
default: throw new ArgumentOutOfRangeException(nameof(quality));
|
|
}
|
|
}
|
|
}
|
|
|
|
interface IDefaultFrameSettingsType
|
|
{
|
|
FrameSettingsRenderType GetFrameSettingsType();
|
|
}
|
|
|
|
partial class FrameSettingsUI
|
|
{
|
|
enum Expandable
|
|
{
|
|
RenderingPasses = 1 << 0,
|
|
RenderingSettings = 1 << 1,
|
|
LightingSettings = 1 << 2,
|
|
AsynComputeSettings = 1 << 3,
|
|
LightLoop = 1 << 4,
|
|
}
|
|
|
|
readonly static ExpandedState<Expandable, FrameSettings> k_ExpandedState = new ExpandedState<Expandable, FrameSettings>(~(-1), "HDRP");
|
|
|
|
static Rect lastBoxRect;
|
|
internal static CED.IDrawer Inspector(bool withOverride = true) => CED.Group(
|
|
CED.Group((serialized, owner) =>
|
|
{
|
|
lastBoxRect = EditorGUILayout.BeginVertical("box");
|
|
|
|
// Add dedicated scope here and on each FrameSettings field to have the contextual menu on everything
|
|
Rect rect = GUILayoutUtility.GetRect(1, EditorGUIUtility.singleLineHeight);
|
|
using (new FrameSettingsAreaImGUI.TitleDrawingScope(rect, FrameSettingsUI.frameSettingsHeaderContent, serialized))
|
|
{
|
|
EditorGUI.LabelField(rect, FrameSettingsUI.frameSettingsHeaderContent, EditorStyles.boldLabel);
|
|
}
|
|
}),
|
|
InspectorInnerbox(withOverride),
|
|
CED.Group((serialized, owner) =>
|
|
{
|
|
EditorGUILayout.EndVertical();
|
|
using (new FrameSettingsAreaImGUI.TitleDrawingScope(lastBoxRect, FrameSettingsUI.frameSettingsHeaderContent, serialized))
|
|
{
|
|
//Nothing to draw.
|
|
//We just want to have a big blue bar at left that match the whole framesetting box.
|
|
//This is because framesettings will be considered as one big block from prefab point
|
|
//of view as there is no way to separate it bit per bit in serialization and Prefab
|
|
//override API rely on SerializedProperty.
|
|
}
|
|
})
|
|
);
|
|
|
|
//separated to add enum popup on default frame settings
|
|
internal static CED.IDrawer InspectorInnerbox(bool withOverride = true, bool isBoxed = true) => CED.Group(
|
|
CED.FoldoutGroup(renderingSettingsHeaderContent, Expandable.RenderingPasses, k_ExpandedState, isBoxed ? FoldoutOption.Indent | FoldoutOption.Boxed : FoldoutOption.Indent,
|
|
CED.Group(206, (serialized, owner) => Drawer_Section(0, serialized.data, serialized.mask, owner, withOverride))
|
|
),
|
|
CED.FoldoutGroup(lightSettingsHeaderContent, Expandable.LightingSettings, k_ExpandedState, isBoxed ? FoldoutOption.Indent | FoldoutOption.Boxed : FoldoutOption.Indent,
|
|
CED.Group(206, (serialized, owner) => Drawer_Section(1, serialized.data, serialized.mask, owner, withOverride))
|
|
),
|
|
CED.FoldoutGroup(asyncComputeSettingsHeaderContent, Expandable.AsynComputeSettings, k_ExpandedState, isBoxed ? FoldoutOption.Indent | FoldoutOption.Boxed : FoldoutOption.Indent,
|
|
CED.Group(206, (serialized, owner) => Drawer_Section(2, serialized.data, serialized.mask, owner, withOverride))
|
|
),
|
|
CED.FoldoutGroup(lightLoopSettingsHeaderContent, Expandable.LightLoop, k_ExpandedState, isBoxed ? FoldoutOption.Indent | FoldoutOption.Boxed : FoldoutOption.Indent,
|
|
CED.Group(206, (serialized, owner) => Drawer_Section(3, serialized.data, serialized.mask, owner, withOverride))
|
|
)
|
|
);
|
|
|
|
static HDRenderPipelineAsset GetHDRPAssetFor(Editor owner)
|
|
{
|
|
HDRenderPipelineAsset hdrpAsset;
|
|
if (owner is HDRenderPipelineEditor)
|
|
{
|
|
// When drawing the inspector of a selected HDRPAsset in Project windows, access HDRP by owner drawing itself
|
|
hdrpAsset = (owner as HDRenderPipelineEditor).target as HDRenderPipelineAsset;
|
|
}
|
|
else
|
|
{
|
|
// Else rely on GraphicsSettings are you should be in hdrp and owner could be probe or camera.
|
|
hdrpAsset = HDRenderPipeline.currentAsset;
|
|
}
|
|
return hdrpAsset;
|
|
}
|
|
|
|
static FrameSettingsRenderType? GetDefaultFrameSettingsFor(Editor owner)
|
|
{
|
|
if (owner is IHDProbeEditor)
|
|
return (owner as IDefaultFrameSettingsType).GetFrameSettingsType();
|
|
else if (owner is HDCameraEditor)
|
|
return FrameSettingsRenderType.Camera;
|
|
return null;
|
|
}
|
|
|
|
private static void Drawer_Section(int index, SerializedFrameSettings.Data data, SerializedFrameSettings.Mask mask, Editor owner, bool withOverride)
|
|
{
|
|
FrameSettingsAreaImGUI.DrawWithOverride(
|
|
FrameSettingsExtractedDatas.CreateBoundInstance(data, GetDefaultFrameSettingsFor(owner), GetHDRPAssetFor(owner)),
|
|
index,
|
|
mask);
|
|
}
|
|
}
|
|
|
|
|
|
// Drawing methods with ImGUI
|
|
static class FrameSettingsAreaImGUI
|
|
{
|
|
internal const int k_IndentPerLevel = 15;
|
|
const int k_CheckBoxWidth = 15;
|
|
const int k_CheckboxLabelSeparator = 5;
|
|
const int k_LabelFieldSeparator = 2;
|
|
const int k_OverridesHeadersHeight = 17;
|
|
const int k_OverridesHeadersPadding = 3;
|
|
const int k_OverridesHeadersAllWidth = 17;
|
|
const int k_OverridesHeadersNoneWidth = 50;
|
|
|
|
static readonly GUIContent overrideTooltip = EditorGUIUtility.TrTextContent("", "Override this setting in component.");
|
|
|
|
public static void DrawWithOverride(FrameSettingsExtractedDatas.DataLinked boundInstance, int groupIndex, SerializedFrameSettings.Mask serializedMask)
|
|
{
|
|
EditorGUI.BeginChangeCheck();
|
|
var oldState = GUI.enabled;
|
|
if (GUI.enabled)
|
|
{
|
|
Rect rect = GUILayoutUtility.GetRect(0f, k_OverridesHeadersHeight, GUILayout.ExpandWidth(false));
|
|
OverridesHeaders(rect, boundInstance, serializedMask, groupIndex);
|
|
}
|
|
foreach(var field in boundInstance.GetDescriptorForGroup(groupIndex))
|
|
{
|
|
var line = GUILayoutUtility.GetRect(1, EditorGUIUtility.singleLineHeight);
|
|
var borderedLine = line;
|
|
borderedLine.x -= 1;
|
|
borderedLine.width += 2;
|
|
var remainingsOnLine = DrawOverridePart(line, field, serializedMask);
|
|
|
|
var currentIndent = EditorGUI.indentLevel;
|
|
EditorGUI.indentLevel = field.indentLevel;
|
|
|
|
GUIContent label = EditorGUIUtility.TrTextContent(field.displayedName, field.tooltip);
|
|
using (new TitleDrawingScope(remainingsOnLine, label, field.boundData.boundData, serializedMask))
|
|
remainingsOnLine = DrawLabel(remainingsOnLine, label);
|
|
DrawFieldPart(remainingsOnLine, field, true);
|
|
|
|
EditorGUI.indentLevel = currentIndent;
|
|
GUI.enabled = oldState;
|
|
}
|
|
if (EditorGUI.EndChangeCheck())
|
|
{
|
|
boundInstance.boundData.ApplyModifiedProperties();
|
|
serializedMask.ApplyModifiedProperties();
|
|
}
|
|
}
|
|
|
|
public static void DrawWithOverride(Rect rect, FrameSettingsExtractedDatas.DataLinked boundInstance, int groupIndex, SerializedFrameSettings.Mask serializedMask)
|
|
{
|
|
EditorGUI.BeginChangeCheck();
|
|
var oldState = GUI.enabled;
|
|
if (GUI.enabled)
|
|
{
|
|
Rect overridesHeadersRect = new Rect(rect.x, rect.y, rect.width, k_OverridesHeadersHeight);
|
|
OverridesHeaders(overridesHeadersRect, boundInstance, serializedMask, groupIndex);
|
|
rect.y += k_OverridesHeadersHeight;
|
|
rect.height -= k_OverridesHeadersHeight;
|
|
}
|
|
var linePosition = GetLines(rect, groupIndex).GetEnumerator();
|
|
foreach(var field in boundInstance.GetDescriptorForGroup(groupIndex))
|
|
{
|
|
linePosition.MoveNext();
|
|
var remainingsOnLine = DrawOverridePart(linePosition.Current, field, serializedMask);
|
|
|
|
var currentIndent = EditorGUI.indentLevel;
|
|
EditorGUI.indentLevel = field.indentLevel;
|
|
|
|
GUIContent label = EditorGUIUtility.TrTextContent(field.displayedName, field.tooltip);
|
|
using (new TitleDrawingScope(remainingsOnLine, label, field.boundData.boundData, serializedMask))
|
|
remainingsOnLine = DrawLabel(remainingsOnLine, label);
|
|
DrawFieldPart(remainingsOnLine, field, true);
|
|
|
|
EditorGUI.indentLevel = currentIndent;
|
|
GUI.enabled = oldState;
|
|
}
|
|
if (EditorGUI.EndChangeCheck())
|
|
{
|
|
boundInstance.boundData.ApplyModifiedProperties();
|
|
serializedMask.ApplyModifiedProperties();
|
|
}
|
|
}
|
|
|
|
static public void DrawWithoutOverride(FrameSettingsExtractedDatas.DataLinked boundInstance, int groupIndex)
|
|
{
|
|
EditorGUI.BeginChangeCheck();
|
|
var oldState = GUI.enabled;
|
|
foreach(var field in boundInstance.GetDescriptorForGroup(groupIndex))
|
|
{
|
|
var remainingsOnLine = GUILayoutUtility.GetRect(1, EditorGUIUtility.singleLineHeight);
|
|
|
|
var currentIndent = EditorGUI.indentLevel;
|
|
EditorGUI.indentLevel = field.indentLevel;
|
|
|
|
GUIContent label = EditorGUIUtility.TrTextContent(field.displayedName, field.tooltip);
|
|
using (new TitleDrawingScope(remainingsOnLine, label, field.boundData.boundData))
|
|
remainingsOnLine = DrawLabel(remainingsOnLine, label);
|
|
DrawFieldPart(remainingsOnLine, field, false);
|
|
|
|
EditorGUI.indentLevel = currentIndent;
|
|
GUI.enabled = oldState;
|
|
}
|
|
if (EditorGUI.EndChangeCheck())
|
|
boundInstance.boundData.ApplyModifiedProperties();
|
|
}
|
|
|
|
static public void DrawWithoutOverride(Rect rect, FrameSettingsExtractedDatas.DataLinked boundInstance, int groupIndex)
|
|
{
|
|
EditorGUI.BeginChangeCheck();
|
|
var oldState = GUI.enabled;
|
|
var linePosition = GetLines(rect, groupIndex).GetEnumerator();
|
|
foreach (var field in boundInstance.GetDescriptorForGroup(groupIndex))
|
|
{
|
|
linePosition.MoveNext();
|
|
var remainingsOnLine = linePosition.Current;
|
|
|
|
var currentIndent = EditorGUI.indentLevel;
|
|
EditorGUI.indentLevel = field.indentLevel;
|
|
|
|
GUIContent label = EditorGUIUtility.TrTextContent(field.displayedName, field.tooltip);
|
|
using (new TitleDrawingScope(remainingsOnLine, label, field.boundData.boundData))
|
|
remainingsOnLine = DrawLabel(remainingsOnLine, label);
|
|
DrawFieldPart(remainingsOnLine, field, false);
|
|
|
|
EditorGUI.indentLevel = currentIndent;
|
|
GUI.enabled = oldState;
|
|
}
|
|
if (EditorGUI.EndChangeCheck())
|
|
boundInstance.boundData.ApplyModifiedProperties();
|
|
}
|
|
|
|
static public float CalcHeightWithoutOverride(int groupIndex)
|
|
{
|
|
var lineAmount = FrameSettingsExtractedDatas.GetGroupLength(groupIndex);
|
|
return lineAmount * EditorGUIUtility.singleLineHeight + (lineAmount - 1) * EditorGUIUtility.standardVerticalSpacing;
|
|
}
|
|
|
|
static public float CalcHeightWithOverride(int groupIndex)
|
|
{
|
|
return k_OverridesHeadersHeight + CalcHeightWithoutOverride(groupIndex);
|
|
}
|
|
|
|
static public IEnumerable<Rect> GetLines(Rect encompassingRect, int groupIndex)
|
|
{
|
|
Rect line = encompassingRect;
|
|
line.height = EditorGUIUtility.singleLineHeight;
|
|
|
|
for(int i = FrameSettingsExtractedDatas.GetGroupLength(groupIndex); i > 0; --i)
|
|
{
|
|
yield return line;
|
|
line.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
|
|
}
|
|
}
|
|
|
|
static Rect DrawLabel(Rect rect, GUIContent label)
|
|
{
|
|
Rect labelRect = rect;
|
|
labelRect.width = EditorGUIUtility.labelWidth - k_IndentPerLevel * EditorGUI.indentLevel;
|
|
labelRect.x += EditorGUI.indentLevel * k_IndentPerLevel;
|
|
|
|
Rect fieldRect = rect;
|
|
fieldRect.x = labelRect.xMax + k_LabelFieldSeparator;
|
|
fieldRect.width -= fieldRect.x - rect.x;
|
|
|
|
EditorGUI.HandlePrefixLabel(rect, labelRect, label);
|
|
return fieldRect;
|
|
}
|
|
|
|
static Rect DrawOverridePart(Rect rect, FrameSettingsExtractedDatas.DataLinked.FieldDescriptor descriptor, SerializedFrameSettings.Mask mask)
|
|
{
|
|
int currentIndent = EditorGUI.indentLevel;
|
|
EditorGUI.indentLevel = 0;
|
|
|
|
Rect overrideRect = rect;
|
|
overrideRect.width = k_CheckBoxWidth;
|
|
|
|
Rect fieldRect = rect;
|
|
fieldRect.x += k_CheckBoxWidth + k_CheckboxLabelSeparator;
|
|
fieldRect.width -= fieldRect.x - rect.x;
|
|
|
|
var overrideInterface = descriptor.GetOverrideInterface(mask);
|
|
var val = overrideInterface.overrided;
|
|
bool originalValue = val ?? false;
|
|
overrideRect.yMin += 4f;
|
|
|
|
var overrideable = overrideInterface.IsOverrideableWithDependencies();
|
|
GUI.enabled &= overrideable;
|
|
|
|
if (overrideable)
|
|
{
|
|
bool modifiedValue = EditorGUI.Toggle(overrideRect, overrideTooltip, originalValue, val.HasValue ? CoreEditorStyles.smallTickbox : CoreEditorStyles.smallMixedTickbox);
|
|
if (originalValue ^ modifiedValue)
|
|
overrideInterface.overrided = modifiedValue;
|
|
|
|
GUI.enabled &= modifiedValue;
|
|
}
|
|
EditorGUI.indentLevel = currentIndent;
|
|
return fieldRect;
|
|
}
|
|
|
|
static void DrawFieldPart(Rect fieldRect, FrameSettingsExtractedDatas.DataLinked.FieldDescriptor descriptor, bool haveOverride)
|
|
{
|
|
int currentIndent = EditorGUI.indentLevel;
|
|
EditorGUI.indentLevel = 0;
|
|
if (haveOverride && !GUI.enabled)
|
|
{
|
|
//When disabled, show default values instead
|
|
DrawFieldPartWithDefaultValues(fieldRect, descriptor);
|
|
}
|
|
else
|
|
{
|
|
//When enabled, show serialized ones for this instance
|
|
DrawFieldPartWithCurrentValues(fieldRect, descriptor);
|
|
}
|
|
EditorGUI.indentLevel = currentIndent;
|
|
}
|
|
|
|
static void DrawFieldPartWithDefaultValues(Rect fieldRect, FrameSettingsExtractedDatas.DataLinked.FieldDescriptor descriptor)
|
|
{
|
|
if (descriptor.overridedDefaultValue == null)
|
|
{
|
|
switch (descriptor.displayType)
|
|
{
|
|
case FrameSettingsFieldAttribute.DisplayType.BoolAsCheckbox:
|
|
DrawFieldShape(fieldRect, descriptor.enabledInDefault ?? false);
|
|
break;
|
|
case FrameSettingsFieldAttribute.DisplayType.BoolAsEnumPopup:
|
|
//shame but it is not possible to use Convert.ChangeType to convert int into enum in current C#
|
|
//rely on string parsing for the moment
|
|
var oldEnumValue = Enum.Parse(descriptor.targetType, (descriptor.enabledInDefault ?? false) ? "1" : "0");
|
|
DrawFieldShape(fieldRect, oldEnumValue);
|
|
break;
|
|
case FrameSettingsFieldAttribute.DisplayType.Others:
|
|
if (descriptor.overridedGetter == null)
|
|
throw new Exception($"{nameof(FrameSettingsFieldAttribute.DisplayType.Others)} can only be used with an overridedGetter in {nameof(FrameSettingsExtractedDatas.DataLinked)}.AddDynamicOverrides()");
|
|
var oldValue = descriptor.overridedGetter();
|
|
DrawFieldShape(fieldRect, oldValue);
|
|
break;
|
|
default:
|
|
throw new ArgumentException("Unknown FrameSettingsFieldAttribute");
|
|
}
|
|
}
|
|
else
|
|
DrawFieldShape(fieldRect, descriptor.overridedDefaultValue());
|
|
}
|
|
|
|
static void DrawFieldPartWithCurrentValues(Rect fieldRect, FrameSettingsExtractedDatas.DataLinked.FieldDescriptor descriptor)
|
|
{
|
|
EditorGUI.showMixedValue = descriptor.hasMultipleDifferentValues;
|
|
switch (descriptor.displayType)
|
|
{
|
|
case FrameSettingsFieldAttribute.DisplayType.BoolAsCheckbox:
|
|
bool oldBool = descriptor.enabled ?? false;
|
|
bool newBool = (bool)DrawFieldShape(fieldRect, oldBool);
|
|
if (oldBool ^ newBool)
|
|
{
|
|
Undo.RecordObjects(descriptor.targetObjects, $"Changed FrameSettings {descriptor.displayedName}");
|
|
descriptor.enabled = newBool;
|
|
descriptor.callbackOnChange?.Invoke(oldBool, newBool);
|
|
}
|
|
break;
|
|
case FrameSettingsFieldAttribute.DisplayType.BoolAsEnumPopup:
|
|
//shame but it is not possible to use Convert.ChangeType to convert int into enum in current C#
|
|
//Also, Enum.Equals and Enum operator!= always send true here. As it seams to compare object reference instead of value.
|
|
var oldBoolValue = descriptor.enabled;
|
|
int oldEnumIntValue = -1;
|
|
int newEnumIntValue;
|
|
object newEnumValue;
|
|
if (oldBoolValue.HasValue)
|
|
{
|
|
var oldEnumValue = Enum.GetValues(descriptor.targetType).GetValue(oldBoolValue.Value ? 1 : 0);
|
|
newEnumValue = Convert.ChangeType(DrawFieldShape(fieldRect, oldEnumValue), descriptor.targetType);
|
|
oldEnumIntValue = ((IConvertible)oldEnumValue).ToInt32(System.Globalization.CultureInfo.CurrentCulture);
|
|
newEnumIntValue = ((IConvertible)newEnumValue).ToInt32(System.Globalization.CultureInfo.CurrentCulture);
|
|
}
|
|
else //in multi edition, do not assume any previous value
|
|
{
|
|
newEnumIntValue = EditorGUI.Popup(fieldRect, -1, Enum.GetNames(descriptor.targetType));
|
|
newEnumValue = newEnumIntValue < 0 ? null : Enum.GetValues(descriptor.targetType).GetValue(newEnumIntValue);
|
|
}
|
|
if (oldEnumIntValue != newEnumIntValue)
|
|
{
|
|
Undo.RecordObjects(descriptor.targetObjects, $"Changed FrameSettings {descriptor.displayedName}");
|
|
descriptor.enabled = Convert.ToInt32(newEnumValue) == 1;
|
|
descriptor.callbackOnChange?.Invoke(oldEnumIntValue, newEnumIntValue);
|
|
}
|
|
break;
|
|
case FrameSettingsFieldAttribute.DisplayType.Others:
|
|
if (descriptor.overridedGetter == null || descriptor.overridedSetter == null)
|
|
throw new Exception($"{nameof(FrameSettingsFieldAttribute.DisplayType.Others)} can only be used with an overridedGetter and a overridedSetter in {nameof(FrameSettingsExtractedDatas.DataLinked)}.AddDynamicOverrides()");
|
|
var oldValue = descriptor.overridedGetter();
|
|
EditorGUI.BeginChangeCheck();
|
|
var newValue = DrawFieldShape(fieldRect, oldValue);
|
|
// We need an extensive check here, otherwise in some case with boxing or polymorphism
|
|
// the != operator won't be accurate. (This is the case for enum types).
|
|
var valuesAreEquals = oldValue == null && newValue == null || oldValue != null && oldValue.Equals(newValue);
|
|
// If the UI reported a change, we also assign values.
|
|
// When assigning to a multiple selection, the equals check may fail while there was indeed a change.
|
|
if (EditorGUI.EndChangeCheck() || !valuesAreEquals)
|
|
{
|
|
Undo.RecordObjects(descriptor.targetObjects, $"Changed FrameSettings {descriptor.displayedName}");
|
|
descriptor.overridedSetter(newValue);
|
|
descriptor.callbackOnChange?.Invoke(oldValue, newValue);
|
|
}
|
|
break;
|
|
default:
|
|
throw new ArgumentException("Unknown FrameSettingsFieldAttribute");
|
|
}
|
|
EditorGUI.showMixedValue = false;
|
|
}
|
|
|
|
static object DrawFieldShape(Rect rect, object field)
|
|
{
|
|
switch (field)
|
|
{
|
|
case bool boolean:
|
|
return EditorGUI.Toggle(rect, boolean);
|
|
case int integer:
|
|
return EditorGUI.IntField(rect, integer);
|
|
case float floatValue:
|
|
return EditorGUI.FloatField(rect, floatValue);
|
|
case Enum enumeration:
|
|
return EditorGUI.EnumPopup(rect, enumeration);
|
|
default:
|
|
EditorGUI.LabelField(rect, new GUIContent("Unsupported type"));
|
|
Debug.LogError($"Unsupported format {field.GetType()} in OverridableSettingsArea.cs. Please add it!");
|
|
return null;
|
|
}
|
|
}
|
|
|
|
static void OverridesHeaders(Rect rect, FrameSettingsExtractedDatas.DataLinked boundInstance, SerializedFrameSettings.Mask mask, int groupIndex)
|
|
{
|
|
if (GUI.Button(new Rect(rect.x + k_OverridesHeadersPadding, rect.y, k_OverridesHeadersAllWidth, rect.height), EditorGUIUtility.TrTextContent("All", "Toggle all overrides on. To maximize performances you should only toggle overrides that you actually need."), CoreEditorStyles.miniLabelButton))
|
|
{
|
|
boundInstance.SetAllAllowedOverridesTo(mask, groupIndex, true);
|
|
GUI.changed = true;
|
|
}
|
|
|
|
if (GUI.Button(new Rect(rect.x + k_OverridesHeadersAllWidth + k_OverridesHeadersPadding*2, rect.y, k_OverridesHeadersNoneWidth, rect.height), EditorGUIUtility.TrTextContent("None", "Toggle all overrides off."), CoreEditorStyles.miniLabelButton))
|
|
{
|
|
boundInstance.SetAllAllowedOverridesTo(mask, groupIndex, false);
|
|
GUI.changed = true;
|
|
}
|
|
}
|
|
|
|
public struct TitleDrawingScope : IDisposable
|
|
{
|
|
bool m_HasOverride;
|
|
|
|
public TitleDrawingScope(Rect rect, GUIContent label, SerializedFrameSettings serialized)
|
|
: this(rect, label, serialized.data, serialized.mask) { }
|
|
public TitleDrawingScope(Rect rect, GUIContent label, SerializedFrameSettings.Data data, SerializedFrameSettings.Mask mask = null)
|
|
{
|
|
EditorGUI.BeginProperty(rect, label, data.root);
|
|
|
|
m_HasOverride = mask != null;
|
|
if (m_HasOverride)
|
|
EditorGUI.BeginProperty(rect, label, mask.root);
|
|
}
|
|
|
|
void IDisposable.Dispose()
|
|
{
|
|
EditorGUI.EndProperty();
|
|
if (m_HasOverride)
|
|
EditorGUI.EndProperty();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// Drawing methods with UITK
|
|
class FrameSettingsArea : VisualElement
|
|
{
|
|
internal const string k_StylesheetPathFormat = "Packages/com.unity.render-pipelines.high-definition/Editor/USS/FrameSettings{0}.uss";
|
|
const string k_FieldClass = "frame-settings-field";
|
|
|
|
protected Dictionary<FrameSettingsField, LineField> m_QuickAccess = new();
|
|
Dictionary<FrameSettingsField, Queue<Action<VisualElement>>> m_LateInitQueues = new();
|
|
protected FrameSettingsExtractedDatas.DataLinked m_BoundInstance;
|
|
protected int m_GroupIndex;
|
|
|
|
protected FrameSettingsArea(int groupIndex)
|
|
{
|
|
styleSheets.Add(AssetDatabase.LoadAssetAtPath<StyleSheet>(string.Format(k_StylesheetPathFormat, "")));
|
|
styleSheets.Add(AssetDatabase.LoadAssetAtPath<StyleSheet>(string.Format(k_StylesheetPathFormat, EditorGUIUtility.isProSkin ? "Dark" : "Light")));
|
|
m_GroupIndex = groupIndex;
|
|
}
|
|
|
|
public FrameSettingsArea(FrameSettingsExtractedDatas.DataLinked boundInstance, int groupIndex) : this(groupIndex)
|
|
{
|
|
if (boundInstance == null)
|
|
throw new ArgumentNullException(nameof(boundInstance));
|
|
if (!FrameSettingsExtractedDatas.Exists(groupIndex))
|
|
throw new ArgumentOutOfRangeException(nameof(groupIndex));
|
|
m_BoundInstance = boundInstance;
|
|
GenerateLayoutForGroup();
|
|
FinishDelayedInit();
|
|
}
|
|
|
|
public void GenerateLayoutForGroup()
|
|
{
|
|
VisualElement header = CreateHeader();
|
|
if (header != null)
|
|
Add(header);
|
|
foreach (var descriptor in m_BoundInstance.GetDescriptorForGroup(m_GroupIndex))
|
|
Add(CreateFieldLayout(descriptor), descriptor.field);
|
|
}
|
|
|
|
protected virtual VisualElement CreateHeader() => null;
|
|
|
|
protected virtual LineField CreateFieldLayout(FrameSettingsExtractedDatas.DataLinked.FieldDescriptor descriptor)
|
|
=> new LineField(descriptor.field, CreateInnerFieldLayout(descriptor));
|
|
|
|
VisualElement CreateInnerFieldLayout(FrameSettingsExtractedDatas.DataLinked.FieldDescriptor descriptor)
|
|
{
|
|
switch (descriptor.displayType)
|
|
{
|
|
case FrameSettingsFieldAttribute.DisplayType.BoolAsCheckbox:
|
|
return CreateField(descriptor.enabledUnchecked, descriptor, v => descriptor.enabledUnchecked = (bool)v);
|
|
case FrameSettingsFieldAttribute.DisplayType.BoolAsEnumPopup:
|
|
var val = (Enum)Enum.GetValues(descriptor.targetType).GetValue(descriptor.enabledUnchecked ? 1 : 0);
|
|
Action<object> setter = v => descriptor.enabledUnchecked = ((IConvertible)v).ToInt32(System.Globalization.CultureInfo.InvariantCulture) == 1;
|
|
return CreateField(val, descriptor, setter);
|
|
case FrameSettingsFieldAttribute.DisplayType.Others:
|
|
{
|
|
if (descriptor.overridedGetter == null || descriptor.overridedSetter == null)
|
|
throw new Exception($"{nameof(FrameSettingsFieldAttribute.DisplayType.Others)} can only be used with an overridedGetter and a overridedSetter in {nameof(FrameSettingsExtractedDatas.DataLinked)}.AddDynamicOverrides()");
|
|
|
|
return CreateField(descriptor.overridedGetter(), descriptor);
|
|
}
|
|
default:
|
|
throw new ArgumentException($"Unknown {nameof(FrameSettingsFieldAttribute.DisplayType)}");
|
|
}
|
|
}
|
|
|
|
VisualElement CreateField<T>(T value, FrameSettingsExtractedDatas.DataLinked.FieldDescriptor descriptor, Action<object> registerChange = null)
|
|
{
|
|
switch (value) //only kept bool, int, float and enum as nothing else is used
|
|
{
|
|
case bool boolean:
|
|
return SetUp(new Toggle() { value = boolean }, descriptor, registerChange);
|
|
case int integer:
|
|
return SetUp(new IntegerField() { value = integer }, descriptor, registerChange);
|
|
case float floatValue:
|
|
return SetUp(new FloatField() { value = floatValue }, descriptor, registerChange);
|
|
case Enum enumeration:
|
|
return SetUp(new EnumField(enumeration), descriptor, registerChange);
|
|
default:
|
|
throw new ArgumentException($"Unsupported format {typeof(T)} in OverridableFrameSettingsArea.cs. Please add it!");
|
|
}
|
|
}
|
|
|
|
VisualElement SetUp<T>(BaseField<T> field, FrameSettingsExtractedDatas.DataLinked.FieldDescriptor descriptor, Action<object> registerChange = null)
|
|
{
|
|
//initilization styling
|
|
field.label = descriptor.displayedName;
|
|
field.tooltip = descriptor.tooltip;
|
|
field.showMixedValue = descriptor.hasMultipleDifferentValues;
|
|
|
|
//dynamic styling
|
|
field.labelElement.style.paddingLeft = 1 + descriptor.indentLevel * FrameSettingsAreaImGUI.k_IndentPerLevel;
|
|
field.AddToClassList("unity-base-field__aligned"); //Align with other BaseField<T>
|
|
field.AddToClassList(k_FieldClass);
|
|
if (descriptor.fieldDependentLabel != FrameSettingsField.None)
|
|
{
|
|
// workaround because IPrefixLabel is not public
|
|
var encapsulatedDescriptor = descriptor;
|
|
void RegisterValueChanged<K>(BaseField<K> otherField)
|
|
{
|
|
otherField.RegisterValueChangedCallback(evt =>
|
|
{
|
|
field.labelElement.text = encapsulatedDescriptor.displayedName;
|
|
});
|
|
}
|
|
AddDelayedInit(descriptor.fieldDependentLabel, elt =>
|
|
{
|
|
switch (elt)
|
|
{
|
|
case Toggle toggle:
|
|
RegisterValueChanged(toggle);
|
|
return;
|
|
case IntegerField integreField:
|
|
RegisterValueChanged(integreField);
|
|
return;
|
|
case FloatField floatField:
|
|
RegisterValueChanged(floatField);
|
|
return;
|
|
case EnumField enumField:
|
|
RegisterValueChanged(enumField);
|
|
return;
|
|
default:
|
|
throw new ArgumentException($"Unsupported format BaseField<T> in {nameof(FrameSettingsArea)}. Please add it! Found {elt.GetType()}");
|
|
}
|
|
});
|
|
}
|
|
|
|
//callback on change
|
|
field.RegisterValueChangedCallback(evt =>
|
|
{
|
|
Undo.RecordObjects(descriptor.targetObjects, $"Changed FrameSettings {descriptor.displayedName}");
|
|
if (descriptor.overridedSetter != null)
|
|
descriptor.overridedSetter(evt.newValue);
|
|
else
|
|
registerChange(evt.newValue);
|
|
descriptor.callbackOnChange?.Invoke(evt.previousValue, evt.newValue);
|
|
m_BoundInstance.boundData.ApplyModifiedProperties();
|
|
});
|
|
return field;
|
|
}
|
|
|
|
// Usefull to add dependency between bits. This is mainly used to rename labels on other bit change.
|
|
protected void AddDelayedInit(FrameSettingsField forField, Action<VisualElement> action)
|
|
{
|
|
if (m_QuickAccess.ContainsKey(forField))
|
|
action?.Invoke(m_QuickAccess[forField].field);
|
|
else if (action != null)
|
|
{
|
|
if (!m_LateInitQueues.ContainsKey(forField))
|
|
m_LateInitQueues[forField] = new();
|
|
m_LateInitQueues[forField].Enqueue(action);
|
|
}
|
|
}
|
|
|
|
void Add(LineField element, FrameSettingsField field)
|
|
{
|
|
Add(m_QuickAccess[field] = element);
|
|
if (!m_LateInitQueues.ContainsKey(field))
|
|
return;
|
|
while (m_LateInitQueues[field].TryDequeue(out var action))
|
|
action(element.field);
|
|
}
|
|
|
|
protected void FinishDelayedInit()
|
|
{
|
|
foreach (var kpv in m_LateInitQueues)
|
|
{
|
|
if (kpv.Value == null)
|
|
continue;
|
|
|
|
while (kpv.Value.TryDequeue(out var action))
|
|
action(m_QuickAccess[kpv.Key].field);
|
|
}
|
|
}
|
|
|
|
internal class LineField : VisualElement
|
|
{
|
|
FrameSettingsField m_FrameSettingsField;
|
|
VisualElement m_Field;
|
|
List<FrameSettingsField> m_FieldsDependingOnThisOne;
|
|
|
|
public VisualElement field => m_Field;
|
|
public FrameSettingsField frameSettingsField => m_FrameSettingsField;
|
|
|
|
public T GetFistChildAs<T>()
|
|
where T : VisualElement
|
|
{
|
|
var e = Children().GetEnumerator();
|
|
e.MoveNext();
|
|
return e.Current as T;
|
|
}
|
|
|
|
public LineField(FrameSettingsField frameSettingsField, VisualElement field)
|
|
{
|
|
name = $"line-field-{frameSettingsField}";
|
|
m_FrameSettingsField = frameSettingsField;
|
|
Add(m_Field = field);
|
|
style.flexDirection = FlexDirection.Row;
|
|
m_FieldsDependingOnThisOne = new();
|
|
}
|
|
|
|
internal void AddDependence(FrameSettingsField dependentField)
|
|
=> m_FieldsDependingOnThisOne.Add(dependentField);
|
|
|
|
internal void PropagateActionToDependenteLineFields(FrameSettingsArea host, Action<LineField> action)
|
|
{
|
|
if (action == null)
|
|
return;
|
|
|
|
foreach (var field in m_FieldsDependingOnThisOne)
|
|
action(host.m_QuickAccess[field]);
|
|
}
|
|
}
|
|
}
|
|
|
|
class FrameSettingsAreaWithOverrides : FrameSettingsArea
|
|
{
|
|
const string k_OverrideHeaderClass = "frame-settings-override-header";
|
|
const string k_OverrideCheckboxClass = "frame-settings-override-checkbox";
|
|
|
|
SerializedFrameSettings.Mask m_Mask;
|
|
|
|
public FrameSettingsAreaWithOverrides(FrameSettingsExtractedDatas.DataLinked boundInstance, SerializedFrameSettings.Mask serializedMask, int groupIndex)
|
|
: base(groupIndex)
|
|
{
|
|
if (boundInstance == null)
|
|
throw new ArgumentNullException(nameof(boundInstance));
|
|
if (serializedMask == null)
|
|
throw new ArgumentNullException(nameof(serializedMask));
|
|
if (!FrameSettingsExtractedDatas.Exists(groupIndex))
|
|
throw new ArgumentOutOfRangeException(nameof(groupIndex));
|
|
m_BoundInstance = boundInstance;
|
|
m_Mask = serializedMask;
|
|
GenerateLayoutForGroup();
|
|
FinishDelayedInit();
|
|
}
|
|
|
|
protected override VisualElement CreateHeader()
|
|
{
|
|
void UpdateDisplayFromSerializedValues()
|
|
{
|
|
foreach ( var line in m_QuickAccess.Values)
|
|
{
|
|
var descriptor = m_BoundInstance.GetFieldDescriptor(line.frameSettingsField);
|
|
var overrideInterface = descriptor.GetOverrideInterface(m_Mask);
|
|
var toggle = line.GetFistChildAs<Toggle>();
|
|
toggle.SetValueWithoutNotify(overrideInterface.overridedUnchecked);
|
|
toggle.showMixedValue = overrideInterface.hasMultipleDifferentOverrides;
|
|
UpdateFieldAlongOverrides(toggle, line.field, descriptor);
|
|
}
|
|
}
|
|
|
|
var line = new VisualElement();
|
|
line.Add(new Button(() =>
|
|
{
|
|
Undo.RecordObjects(m_Mask.root.serializedObject.targetObjects, $"Changed all FrameSettings override");
|
|
m_BoundInstance.SetAllAllowedOverridesTo(m_Mask, m_GroupIndex, true);
|
|
m_Mask.ApplyModifiedProperties();
|
|
UpdateDisplayFromSerializedValues();
|
|
})
|
|
{
|
|
text = "All",
|
|
tooltip = "Toggle all overrides on. To maximize performances you should only toggle overrides that you actually need.",
|
|
name = "All",
|
|
});
|
|
line.Add(new Button(() =>
|
|
{
|
|
Undo.RecordObjects(m_Mask.root.serializedObject.targetObjects, $"Changed all FrameSettings override");
|
|
m_BoundInstance.SetAllAllowedOverridesTo(m_Mask, m_GroupIndex, false);
|
|
m_Mask.ApplyModifiedProperties();
|
|
UpdateDisplayFromSerializedValues();
|
|
})
|
|
{
|
|
text = "None",
|
|
tooltip = "Toggle all overrides off.",
|
|
name = "None",
|
|
});
|
|
line.AddToClassList(k_OverrideHeaderClass);
|
|
return line;
|
|
}
|
|
|
|
protected override LineField CreateFieldLayout(FrameSettingsExtractedDatas.DataLinked.FieldDescriptor descriptor)
|
|
{
|
|
var line = base.CreateFieldLayout(descriptor);
|
|
var overrideCheckbox = CreateOverride(descriptor);
|
|
line.Insert(0, overrideCheckbox);
|
|
return line;
|
|
}
|
|
|
|
VisualElement GetSiblingFieldOnLine(Toggle t) => (t.hierarchy.parent as LineField).field;
|
|
|
|
void UpdateFieldAlongOverrides(Toggle overrideToggle, VisualElement field, FrameSettingsExtractedDatas.DataLinked.FieldDescriptor descriptor)
|
|
{
|
|
void SetToDefaultValue()
|
|
{
|
|
var overrided = descriptor.overridedDefaultValue?.Invoke();
|
|
switch (field)
|
|
{
|
|
case Toggle toggleField:
|
|
toggleField.SetValueWithoutNotify((bool)(overrided ?? descriptor.enabledInDefault.Value));
|
|
return;
|
|
case IntegerField integerField:
|
|
integerField.SetValueWithoutNotify((int)(overrided ?? descriptor.overridedGetter()));
|
|
return;
|
|
case FloatField floatField:
|
|
floatField.SetValueWithoutNotify((float)(overrided ?? descriptor.overridedGetter()));
|
|
return;
|
|
case EnumField enumField:
|
|
object oldEnumValue;
|
|
switch (descriptor.displayType)
|
|
{
|
|
case FrameSettingsFieldAttribute.DisplayType.BoolAsEnumPopup:
|
|
oldEnumValue = overrided ?? Enum.Parse(descriptor.targetType, (descriptor.enabledInDefault ?? false) ? "1" : "0");
|
|
break;
|
|
default:
|
|
oldEnumValue = overrided ?? descriptor.overridedGetter();
|
|
break;
|
|
}
|
|
enumField.SetValueWithoutNotify(oldEnumValue as Enum);
|
|
return;
|
|
default:
|
|
throw new ArgumentException($"Unsupported format BaseField<T> in {nameof(FrameSettingsArea)}. Please add it! Found {field.GetType()}");
|
|
}
|
|
}
|
|
|
|
void SetToSerializedValueBack()
|
|
{
|
|
switch (field)
|
|
{
|
|
case Toggle toggleField:
|
|
toggleField.SetValueWithoutNotify(descriptor.enabledUnchecked);
|
|
toggleField.showMixedValue = descriptor.hasMultipleDifferentValues;
|
|
break;
|
|
case IntegerField integerField:
|
|
integerField.SetValueWithoutNotify((int)descriptor.overridedGetter());
|
|
integerField.showMixedValue = descriptor.hasMultipleDifferentValues;
|
|
break;
|
|
case FloatField floatField:
|
|
floatField.SetValueWithoutNotify((float)descriptor.overridedGetter());
|
|
floatField.showMixedValue = descriptor.hasMultipleDifferentValues;
|
|
break;
|
|
case EnumField enumField:
|
|
Enum value;
|
|
switch (descriptor.displayType)
|
|
{
|
|
case FrameSettingsFieldAttribute.DisplayType.BoolAsEnumPopup:
|
|
value = (Enum)Enum.GetValues(descriptor.targetType).GetValue(descriptor.enabledUnchecked ? 1 : 0);
|
|
break;
|
|
default:
|
|
value = (Enum)descriptor.overridedGetter();
|
|
break;
|
|
}
|
|
enumField.SetValueWithoutNotify(value);
|
|
enumField.showMixedValue = descriptor.hasMultipleDifferentValues;
|
|
break;
|
|
default:
|
|
throw new ArgumentException($"Unsupported format BaseField<T> in {nameof(FrameSettingsArea)}. Please add it! Found {field.GetType()}");
|
|
}
|
|
}
|
|
|
|
var overrideInterface = descriptor.GetOverrideInterface(m_Mask);
|
|
bool visibleToggle = overrideInterface.IsOverrideableWithDependencies();
|
|
overrideToggle.style.visibility = visibleToggle ? Visibility.Visible : Visibility.Hidden;
|
|
|
|
bool locallyOverrided = overrideInterface.overridedUnchecked;
|
|
if (visibleToggle && locallyOverrided)
|
|
{
|
|
SetToSerializedValueBack();
|
|
field.SetEnabled(true);
|
|
}
|
|
else
|
|
{
|
|
field.SetEnabled(false);
|
|
SetToDefaultValue();
|
|
}
|
|
}
|
|
|
|
Toggle CreateOverride(FrameSettingsExtractedDatas.DataLinked.FieldDescriptor descriptor)
|
|
{
|
|
//Initialize override toggle
|
|
var o = descriptor.GetOverrideInterface(m_Mask);
|
|
var toggle = new Toggle()
|
|
{
|
|
value = o.overridedUnchecked,
|
|
showMixedValue = o.hasMultipleDifferentOverrides,
|
|
};
|
|
toggle.AddToClassList(k_OverrideCheckboxClass);
|
|
|
|
//Handle direct impact of override toggle on value to display
|
|
//Line is not fully constructed yet. So we must delay
|
|
AddDelayedInit(descriptor.field, elt =>
|
|
{
|
|
//Line not fully constructed yet -> Delaying
|
|
UpdateFieldAlongOverrides(toggle, GetSiblingFieldOnLine(toggle), descriptor);
|
|
|
|
toggle.RegisterValueChangedCallback(evt =>
|
|
{
|
|
//Serialization of override mask
|
|
Undo.RecordObjects(descriptor.targetObjects, $"Changed FrameSettings {descriptor.displayedName} override");
|
|
o.overridedUnchecked = evt.newValue;
|
|
m_Mask.ApplyModifiedProperties();
|
|
|
|
//Display of field
|
|
LineField line = toggle.hierarchy.parent as LineField;
|
|
UpdateFieldAlongOverrides(toggle, line.field, descriptor);
|
|
line.PropagateActionToDependenteLineFields(this, l
|
|
=> UpdateFieldAlongOverrides(l.GetFistChildAs<Toggle>(), l.field, descriptor.boundData.GetFieldDescriptor(l.frameSettingsField)));
|
|
});
|
|
});
|
|
|
|
//Handle dependent fields impact on value to display
|
|
foreach (var field in descriptor.dependencies)
|
|
{
|
|
AddDelayedInit(field, elt =>
|
|
{
|
|
m_QuickAccess[field].AddDependence(descriptor.field);
|
|
|
|
//As there is no common interface allowing to RegisterValueChangedCallback
|
|
//without knowing the type first, only handling supported types.
|
|
switch (elt)
|
|
{
|
|
case Toggle toggle:
|
|
RegisterValueChanged(toggle);
|
|
return;
|
|
case IntegerField integreField:
|
|
RegisterValueChanged(integreField);
|
|
return;
|
|
case FloatField floatField:
|
|
RegisterValueChanged(floatField);
|
|
return;
|
|
case EnumField enumField:
|
|
RegisterValueChanged(enumField);
|
|
return;
|
|
default:
|
|
throw new ArgumentException($"Unsupported format BaseField<T> in {nameof(FrameSettingsArea)}. Please add it! Found {elt.GetType()}");
|
|
}
|
|
});
|
|
}
|
|
void RegisterValueChanged<K>(BaseField<K> otherField)
|
|
{
|
|
otherField.RegisterValueChangedCallback(evt
|
|
=> UpdateFieldAlongOverrides(toggle, GetSiblingFieldOnLine(toggle), descriptor));
|
|
}
|
|
|
|
return toggle;
|
|
}
|
|
}
|
|
}
|