using System;
using System.Collections.Generic;
using System.Reflection;
#if UNITY_EDITOR
using UnityEditor;
#endif
namespace UnityEngine.Rendering
{
/// <summary>
/// Debug Display Settings Volume
/// </summary>
public class DebugDisplaySettingsVolume : IDebugDisplaySettingsData
{
/// <summary>Current volume debug settings.</summary>
[Obsolete("This property has been obsoleted and will be removed in a future version. #from(6000.2)")]
public IVolumeDebugSettings volumeDebugSettings { get; }
private int m_SelectedComponentIndex = -1;
/// <summary>Current volume component to debug.</summary>
public int selectedComponent
{
get => m_SelectedComponentIndex;
set
{
if (value != m_SelectedComponentIndex)
{
m_SelectedComponentIndex = value;
OnSelectionChanged();
}
}
}
private void DestroyVolumeInterpolatedResults()
{
if (m_VolumeInterpolatedResults != null)
ScriptableObject.DestroyImmediate(m_VolumeInterpolatedResults);
}
/// <summary>Type of the current component to debug.</summary>
public Type selectedComponentType
{
get => selectedComponent > 0 ? volumeComponentsPathAndType[selectedComponent - 1].Item2 : null;
set
{
var index = volumeComponentsPathAndType.FindIndex(t => t.Item2 == value);
if (index != -1)
selectedComponent = index + 1;
}
}
/// <summary>List of Volume component types.</summary>
public List<(string, Type)> volumeComponentsPathAndType => VolumeManager.instance.GetVolumeComponentsForDisplay(GraphicsSettings.currentRenderPipelineAssetType);
private Camera m_SelectedCamera;
/// <summary>Current camera to debug.</summary>
public Camera selectedCamera
{
get => m_SelectedCamera;
set
{
if (value != m_SelectedCamera)
{
m_SelectedCamera = value;
OnSelectionChanged();
}
}
}
private void OnSelectionChanged()
{
ClearInterpolationData();
DestroyVolumeInterpolatedResults();
}
VolumeComponent m_VolumeInterpolatedResults;
private bool m_StoreStackInterpolatedValues;
private ObservableList<Volume> m_InfluenceVolumes = new ();
private List<(Volume volume, float weight)> m_VolumesWeights = new ();
private void ClearInterpolationData()
{
m_VolumesWeights.Clear();
}
static bool AreVolumesChanged(ObservableList<Volume> influenceVolumes, List<(Volume volume, float weight)> volumesWeights)
{
// First, check if the lists have the same number of elements
if (influenceVolumes.Count != volumesWeights.Count)
return true;
// Sequence Equals
for (int i = 0; i < influenceVolumes.Count; i++)
{
if (influenceVolumes[i] != volumesWeights[i].volume)
return true;
}
// If all checks pass, the lists are the same (in terms of both content and order)
return false;
}
private void OnBeginVolumeStackUpdate(VolumeStack stack, Camera camera)
{
if (camera == selectedCamera)
{
ClearInterpolationData();
m_StoreStackInterpolatedValues = selectedCamera != null && selectedComponentType != null;
}
}
private void OnEndVolumeStackUpdate(VolumeStack stack, Camera camera)
{
if (m_StoreStackInterpolatedValues)
{
if (AreVolumesChanged(m_InfluenceVolumes, m_VolumesWeights))
{
m_InfluenceVolumes.Clear();
foreach (var pair in m_VolumesWeights)
m_InfluenceVolumes.Add(pair.volume);
}
// Copy the results of the interpolation into our resulVolumeComponent
var componentInStack = stack.GetComponent(selectedComponentType);
for (int i = 0; i < componentInStack.parameters.Count; ++i)
{
resultVolumeComponent.parameters[i].SetValue(componentInStack.parameters[i]);
}
m_StoreStackInterpolatedValues = false;
}
}
private void OnVolumeStackInterpolated(VolumeStack stack, Volume volume, float interpolationFactor)
{
if (m_StoreStackInterpolatedValues)
{
m_VolumesWeights.Add((volume, interpolationFactor));
}
}
/// <summary>
/// Obtains the volume weight
/// </summary>
/// <param name="volume"><see cref="Volume"/></param>
/// <returns>The weight of the volume</returns>
public float GetVolumeWeight(Volume volume)
{
// Try to get the weight associated with the volume
// If the volume is not found, return a default value (e.g., 0.0f)
if (m_VolumesWeights.Count == 0)
return 0.0f;
foreach (var pair in m_VolumesWeights)
{
if (volume == pair.volume)
return pair.weight;
}
return 0.0f;
}
/// <summary>
/// Gets the Volumes List for the current camera and selected volume component
/// </summary>
/// <returns>The list of influenced volumes</returns>
public ObservableList<Volume> GetVolumesList()
{
return m_InfluenceVolumes;
}
void IDebugDisplaySettingsData.Reset()
{
#if UNITY_EDITOR || DEVELOPMENT_BUILD
VolumeManager.instance.overrideVolumeStackData -= OnVolumeStackInterpolated;
VolumeManager.instance.beginVolumeStackUpdate -= OnBeginVolumeStackUpdate;
VolumeManager.instance.endVolumeStackUpdate -= OnEndVolumeStackUpdate;
VolumeManager.instance.renderingDebuggerAttached = false;
#endif
ClearInterpolationData();
DestroyVolumeInterpolatedResults();
}
/// <summary>
/// Constructor with the settings
/// </summary>
/// <param name="volumeDebugSettings">The volume debug settings object used for configuration.</param>
[Obsolete("This constructor has been obsoleted and will be removed in a future version. #from(6000.2)")]
public DebugDisplaySettingsVolume(IVolumeDebugSettings volumeDebugSettings)
: this()
{
this.volumeDebugSettings = volumeDebugSettings;
}
/// <summary>
/// Constructor with the settings
/// </summary>
public DebugDisplaySettingsVolume()
{
#if UNITY_EDITOR || DEVELOPMENT_BUILD
VolumeManager.instance.overrideVolumeStackData += OnVolumeStackInterpolated;
VolumeManager.instance.beginVolumeStackUpdate += OnBeginVolumeStackUpdate;
VolumeManager.instance.endVolumeStackUpdate += OnEndVolumeStackUpdate;
#endif
}
internal int volumeComponentEnumIndex;
internal VolumeComponent resultVolumeComponent
{
get
{
if (m_VolumeInterpolatedResults == null)
m_VolumeInterpolatedResults = ScriptableObject.CreateInstance(selectedComponentType) as VolumeComponent;
return m_VolumeInterpolatedResults;
}
}
internal static string ExtractResult(VolumeParameter param)
{
if (param == null)
return Strings.parameterNotCalculated;
var paramType = param.GetType();
var property = paramType.GetProperty("value");
if (property == null)
return "-";
var value = property.GetValue(param);
var propertyType = property.PropertyType;
if (value == null || value.Equals(null))
return Strings.none + $" ({propertyType.Name})";
var toString = propertyType.GetMethod("ToString", Type.EmptyTypes);
if ((toString == null) || (toString.DeclaringType == typeof(object)) || (toString.DeclaringType == typeof(Object)))
{
// Check if the parameter has a name
var nameProp = property.PropertyType.GetProperty("name");
if (nameProp == null)
return Strings.debugViewNotSupported;
var valueString = $"{nameProp.GetValue(value)}";
return valueString ?? Strings.none;
}
return value.ToString();
}
static class Styles
{
public static readonly GUIContent none = new GUIContent("None");
}
static class Strings
{
public static readonly string cameraNeedsRendering = "Values might not be fully updated if the camera you are inspecting is not rendered.";
public static readonly string none = "None";
public static readonly string parameter = "Parameter";
public static readonly string component = "Component";
public static readonly string debugViewNotSupported = "N/A";
public static readonly string volumeInfo = "Volume Info";
public static readonly string gameObject = "GameObject";
public static readonly string priority = "Priority";
public static readonly string resultValue = "Result";
public static readonly string resultValueTooltip = "The interpolated result value of the parameter. This value is used to render the camera.";
public static readonly string globalDefaultValue = "Graphics Settings";
public static readonly string globalDefaultValueTooltip = "Default value for this parameter, defined by the Default Volume Profile in Global Settings.";
public static readonly string qualityLevelValue = "Quality Settings";
public static readonly string qualityLevelValueTooltip = "Override value for this parameter, defined by the Volume Profile in the current SRP Asset.";
public static readonly string global = "Global";
public static readonly string local = "Local";
public static readonly string volumeProfile = "Volume Profile";
public static readonly string parameterNotCalculated = "N/A";
}
const string k_PanelTitle = "Volume";
#if UNITY_EDITOR
internal static void OpenInRenderingDebugger()
{
EditorApplication.ExecuteMenuItem("Window/Analysis/Rendering Debugger");
var idx = DebugManager.instance.FindPanelIndex(k_PanelTitle);
if (idx != -1)
DebugManager.instance.RequestEditorWindowPanelIndex(idx);
}
#endif
internal static class WidgetFactory
{
public static DebugUI.EnumField CreateComponentSelector(SettingsPanel panel, Action<DebugUI.Field<int>, int> refresh)
{
int componentIndex = 0;
var componentNames = new List<GUIContent>() { Styles.none };
var componentValues = new List<int>() { componentIndex++ };
var volumesAndTypes = panel.data.volumeComponentsPathAndType;
foreach (var type in volumesAndTypes)
{
componentNames.Add(new GUIContent() { text = type.Item1 });
componentValues.Add(componentIndex++);
}
return new DebugUI.EnumField
{
displayName = Strings.component,
getter = () => panel.data.selectedComponent,
setter = value => panel.data.selectedComponent = value,
enumNames = componentNames.ToArray(),
enumValues = componentValues.ToArray(),
getIndex = () => panel.data.volumeComponentEnumIndex,
setIndex = value => { panel.data.volumeComponentEnumIndex = value; },
onValueChanged = refresh
};
}
public static DebugUI.CameraSelector CreateCameraSelector(SettingsPanel panel, Action<DebugUI.Field<Object>, Object> refresh)
{
return new DebugUI.CameraSelector()
{
getter = () => panel.data.selectedCamera,
setter = value => panel.data.selectedCamera = value as Camera,
onValueChanged = refresh
};
}
internal static DebugUI.Widget CreateVolumeParameterWidget(string name, bool isResultParameter, VolumeParameter param)
{
#if UNITY_EDITOR || DEVELOPMENT_BUILD
if (param != null)
{
Func<bool> isHiddenCallback = isResultParameter ?
() => false :
() => !param.overrideState;
var parameterType = param.GetType();
if (parameterType == typeof(ColorParameter))
{
var p = (ColorParameter)param;
return new DebugUI.ColorField()
{
displayName = name,
hdr = p.hdr,
showAlpha = p.showAlpha,
getter = () => p.value,
setter = value => p.value = value,
isHiddenCallback = isHiddenCallback
};
}
else if (parameterType.BaseType.IsGenericType && parameterType.BaseType.GetGenericArguments().Length > 0)
{
// Get the generic type argument, e.g., <Texture> in VolumeParameter<Texture>
var genericArgument = parameterType.BaseType.GetGenericArguments()[0];
// Check if the argument is a UnityEngine.Object or derived type
if (typeof(Object).IsAssignableFrom(genericArgument))
{
return new DebugUI.ObjectField()
{
displayName = name,
getter = () =>
{
var property = parameterType.GetProperty("value");
if (property == null)
return null;
var value = property.GetValue(param);
return value as Object;
},
isHiddenCallback = isHiddenCallback
};
}
}
var typeInfo = parameterType.GetTypeInfo();
var genericArguments = typeInfo.BaseType.GenericTypeArguments;
if (genericArguments.Length > 0 && genericArguments[0].IsArray)
{
return new DebugUI.ObjectListField()
{
displayName = name,
getter = () => (Object[])parameterType.GetProperty("value").GetValue(param, null),
type = parameterType,
isHiddenCallback = isHiddenCallback
};
}
return new DebugUI.Value()
{
displayName = name,
getter = () => ExtractResult(param),
isHiddenCallback = isHiddenCallback
};
}
#endif
return new DebugUI.Value() { displayName = name, getter = () => Strings.parameterNotCalculated, };
}
static DebugUI.Value s_EmptyDebugUIValue = new DebugUI.Value { getter = () => string.Empty };
struct VolumeParameterChain
{
public DebugUI.Widget.NameAndTooltip nameAndTooltip;
public VolumeProfile volumeProfile;
public VolumeComponent volumeComponent;
public Volume volume;
}
static VolumeComponent GetSelectedVolumeComponent(VolumeProfile profile, Type selectedType)
{
if (profile != null)
{
foreach (var component in profile.components)
if (component.GetType() == selectedType)
return component;
}
return null;
}
static List<VolumeParameterChain> GetResolutionChain(DebugDisplaySettingsVolume data)
{
List<VolumeParameterChain> chain = new List<VolumeParameterChain>();
Type selectedType = data.selectedComponentType;
if (data.selectedCamera == null || selectedType == null)
return chain;
if (data.resultVolumeComponent == null)
return chain;
var result = new VolumeParameterChain()
{
nameAndTooltip = new DebugUI.Widget.NameAndTooltip()
{
name = Strings.resultValue,
tooltip = Strings.resultValueTooltip,
},
volumeComponent = data.resultVolumeComponent
};
chain.Add(result);
// Add volume components that override the default values.
// Iterate in reverse order to display the last interpolated Volume (most relevant) next to the result in the table view.
var volumes = data.GetVolumesList();
for (int i = volumes.Count - 1; i >= 0; i--)
{
var volume = volumes[i];
var profile = volume.HasInstantiatedProfile() ? volume.profile : volume.sharedProfile;
var overrideComponent = GetSelectedVolumeComponent(profile, selectedType);
if (overrideComponent != null)
{
var overrideVolume = new VolumeParameterChain()
{
nameAndTooltip = new DebugUI.Widget.NameAndTooltip()
{
name = profile.name,
tooltip = profile.name,
},
volumeProfile = profile,
volumeComponent = overrideComponent,
volume = volume
};
chain.Add(overrideVolume);
}
}
// Add custom default profiles
if (VolumeManager.instance.customDefaultProfiles != null)
{
foreach (var customProfile in VolumeManager.instance.customDefaultProfiles)
{
var customProfileComponent = GetSelectedVolumeComponent(customProfile, selectedType);
if (customProfileComponent != null)
{
var overrideVolume = new VolumeParameterChain()
{
nameAndTooltip = new DebugUI.Widget.NameAndTooltip()
{
name = customProfile.name,
tooltip = customProfile.name,
},
volumeProfile = customProfile,
volumeComponent = customProfileComponent,
};
chain.Add(overrideVolume);
}
}
}
// Add Quality Settings
if (VolumeManager.instance.qualityDefaultProfile != null)
{
var qualitySettingsComponent = GetSelectedVolumeComponent(VolumeManager.instance.qualityDefaultProfile, selectedType);
if (qualitySettingsComponent != null)
{
var overrideVolume = new VolumeParameterChain()
{
nameAndTooltip = new DebugUI.Widget.NameAndTooltip()
{
name = Strings.qualityLevelValue,
tooltip = Strings.qualityLevelValueTooltip,
},
volumeProfile = VolumeManager.instance.qualityDefaultProfile,
volumeComponent = qualitySettingsComponent,
};
chain.Add(overrideVolume);
}
}
// Add Graphics Settings
if (VolumeManager.instance.globalDefaultProfile != null)
{
var graphicsSettingsComponent = GetSelectedVolumeComponent(VolumeManager.instance.globalDefaultProfile, selectedType);
if (graphicsSettingsComponent != null)
{
var overrideVolume = new VolumeParameterChain()
{
nameAndTooltip = new DebugUI.Widget.NameAndTooltip()
{
name = Strings.globalDefaultValue,
tooltip = Strings.globalDefaultValueTooltip,
},
volumeProfile = VolumeManager.instance.globalDefaultProfile,
volumeComponent = graphicsSettingsComponent,
};
chain.Add(overrideVolume);
}
}
return chain;
}
public static DebugUI.Table CreateVolumeTable(DebugDisplaySettingsVolume data)
{
// Function for updating the attach state and also checking if the table should be visible
Func<bool> hiddenCallback = () =>
{
#if UNITY_EDITOR || DEVELOPMENT_BUILD
VolumeManager.instance.renderingDebuggerAttached = data.selectedComponent > 0 && data.selectedCamera != null;
return !VolumeManager.instance.renderingDebuggerAttached;
#else
return true;
#endif
};
var table = new DebugUI.Table()
{
displayName = Strings.parameter,
isReadOnly = true,
isHiddenCallback = hiddenCallback,
};
var resolutionChain = GetResolutionChain(data);
if (resolutionChain.Count == 0)
return table;
GenerateTableRows(table, resolutionChain);
GenerateTableColumns(table, data, resolutionChain);
return table;
}
private static void GenerateTableColumns(DebugUI.Table table, DebugDisplaySettingsVolume data, List<VolumeParameterChain> resolutionChain)
{
for (int i = 0; i < resolutionChain.Count; ++i)
{
var chain = resolutionChain[i];
int iRowIndex = -1;
if (chain.volume != null)
{
((DebugUI.Table.Row)table.children[++iRowIndex]).children.Add(new DebugUI.Value()
{
nameAndTooltip = chain.nameAndTooltip,
getter = () =>
{
var scope = chain.volume.isGlobal ? Strings.global : Strings.local;
var weight = data.GetVolumeWeight(chain.volume);
if (chain.volumeComponent.active)
return $"{scope} ({(weight * 100f):F2}%)";
else
return $"{scope} (disabled)";
},
refreshRate = 0.2f
});
((DebugUI.Table.Row)table.children[++iRowIndex]).children.Add(new DebugUI.ObjectField() { displayName = string.Empty, getter = () => chain.volume });
((DebugUI.Table.Row)table.children[++iRowIndex]).children.Add(new DebugUI.Value()
{
nameAndTooltip = chain.nameAndTooltip,
getter = () => chain.volume.priority
});
}
else
{
((DebugUI.Table.Row)table.children[++iRowIndex]).children.Add(new DebugUI.Value()
{
nameAndTooltip = chain.nameAndTooltip,
getter = () => string.Empty
});
((DebugUI.Table.Row)table.children[++iRowIndex]).children.Add(s_EmptyDebugUIValue);
((DebugUI.Table.Row)table.children[++iRowIndex]).children.Add(s_EmptyDebugUIValue);
}
((DebugUI.Table.Row)table.children[++iRowIndex]).children.Add(chain.volumeProfile != null ?
new DebugUI.ObjectField() { displayName = string.Empty, getter = () => chain.volumeProfile } :
s_EmptyDebugUIValue);
((DebugUI.Table.Row)table.children[++iRowIndex]).children.Add(s_EmptyDebugUIValue);
bool isResultParameter = i == 0;
for (int j = 0; j < chain.volumeComponent.parameterList.Length; ++j)
{
var parameter = chain.volumeComponent.parameterList[j];
((DebugUI.Table.Row)table.children[++iRowIndex]).children.Add(
CreateVolumeParameterWidget(chain.nameAndTooltip.name, isResultParameter, parameter));
}
}
}
private static void GenerateTableRows(DebugUI.Table table, List<VolumeParameterChain> resolutionChain)
{
var volumeInfoRow = new DebugUI.Table.Row()
{
displayName = Strings.volumeInfo,
opened = true, // Open by default for the in-game view
};
table.children.Add(volumeInfoRow);
var gameObjectRow = new DebugUI.Table.Row()
{
displayName = Strings.gameObject,
};
table.children.Add(gameObjectRow);
var priorityRow = new DebugUI.Table.Row()
{
displayName = Strings.priority,
};
table.children.Add(priorityRow);
var volumeProfileRow = new DebugUI.Table.Row()
{
displayName = Strings.volumeProfile,
};
table.children.Add(volumeProfileRow);
var separatorRow = new DebugUI.Table.Row()
{
displayName = string.Empty ,
};
table.children.Add(separatorRow);
var results = resolutionChain[0].volumeComponent;
for (int i = 0; i < results.parameterList.Length; ++i)
{
var parameter = results.parameterList[i];
#if UNITY_EDITOR || DEVELOPMENT_BUILD
string displayName = VolumeDebugData.GetVolumeParameterDebugId(parameter);// In the development player, just the debug id
#else
string displayName = i.ToString(); // Everywhere else, just a dummy id ( TODO: The Volume panel code should be stripped completely in nom-development builds )
#endif
table.children.Add(new DebugUI.Table.Row()
{
displayName = displayName
});
}
}
}
[DisplayInfo(name = k_PanelTitle, order = int.MaxValue)]
internal class SettingsPanel : DebugDisplaySettingsPanel<DebugDisplaySettingsVolume>
{
// When we are moving the scene camera, we want the editor window to be repainted too
public override DebugUI.Flags Flags => DebugUI.Flags.EditorForceUpdate;
public override void Dispose()
{
base.Dispose();
data.GetVolumesList().ItemAdded -= OnVolumeInfluenceChanged;
data.GetVolumesList().ItemRemoved -= OnVolumeInfluenceChanged;
}
public SettingsPanel(DebugDisplaySettingsVolume data)
: base(data)
{
var cameraSelector = WidgetFactory.CreateCameraSelector(this, (_, __) => Refresh());
// Select first camera if none is selected
var availableCameras = cameraSelector.getObjects() as List<Camera>;
if (data.selectedCamera == null && availableCameras is { Count: > 0 })
data.selectedCamera = availableCameras[0];
AddWidget(cameraSelector);
AddWidget(WidgetFactory.CreateComponentSelector(this, (_, __) => Refresh()));
Func<bool> hiddenCallback = () => data.selectedCamera == null || data.selectedComponent <= 0;
AddWidget(new DebugUI.MessageBox()
{
displayName = Strings.cameraNeedsRendering,
style = DebugUI.MessageBox.Style.Warning,
isHiddenCallback = hiddenCallback,
});
m_VolumeTable = WidgetFactory.CreateVolumeTable(data);
AddWidget(m_VolumeTable);
data.GetVolumesList().ItemAdded += OnVolumeInfluenceChanged;
data.GetVolumesList().ItemRemoved += OnVolumeInfluenceChanged;
}
private void OnVolumeInfluenceChanged(ObservableList<Volume> sender, ListChangedEventArgs<Volume> e)
{
Refresh();
DebugManager.instance.ReDrawOnScreenDebug();
}
DebugUI.Table m_VolumeTable = null;
void Refresh()
{
var panel = DebugManager.instance.GetPanel(PanelName);
if (panel == null)
return;
bool needsRefresh = false;
if (m_Data.selectedComponent > 0 && m_Data.selectedCamera != null)
{
needsRefresh = true;
var volumeTable = WidgetFactory.CreateVolumeTable(m_Data);
m_VolumeTable.children.Clear();
foreach (var row in volumeTable.children)
{
m_VolumeTable.children.Add(row);
}
}
if (needsRefresh)
{
DebugManager.instance.ReDrawOnScreenDebug();
}
}
}
#region IDebugDisplaySettingsData
/// <summary>
/// Checks whether ANY of the debug settings are currently active.
/// </summary>
public bool AreAnySettingsActive => false; // Volume Debug Panel doesn't need to modify the renderer data, therefore this property returns false
/// <inheritdoc/>
public IDebugDisplaySettingsPanelDisposable CreatePanel()
{
return new SettingsPanel(this);
}
#endregion
}
}