private void TopRowFields()
{
using (new EditorGUILayout.HorizontalScope())
{
if (GUILayout.Button(
EditorUtilities.GetContent(
"All|Toggle all overrides on. To maximize performances you should only toggle overrides that you actually need."),
Styling.miniLabelButton, GUILayout.Width(17f), GUILayout.ExpandWidth(false)))
{
SetAllOverridesTo(true);
}
if (GUILayout.Button(EditorUtilities.GetContent("None|Toggle all overrides off."),
Styling.miniLabelButton, GUILayout.Width(32f), GUILayout.ExpandWidth(false)))
{
SetAllOverridesTo(false);
}
GUILayout.FlexibleSpace();
var enabled = m_Enabled.boolValue;
enabled = GUILayout.Toggle(enabled, EditorUtilities.GetContent("On|Enable this effect."),
EditorStyles.miniButtonLeft, GUILayout.Width(35f), GUILayout.ExpandWidth(false));
enabled = !GUILayout.Toggle(!enabled, EditorUtilities.GetContent("Off|Disable this effect."),
EditorStyles.miniButtonRight, GUILayout.Width(35f), GUILayout.ExpandWidth(false));
m_Enabled.boolValue = enabled;
}
}
void DoAntialiasing()
{
EditorGUILayout.LabelField(EditorUtilities.GetContent("Anti-aliasing"), EditorStyles.boldLabel);
EditorGUI.indentLevel++;
{
m_AntialiasingMode.intValue = EditorGUILayout.Popup(EditorUtilities.GetContent("Mode|The anti-aliasing method to use. FXAA is fast but low quality. SMAA works well for non-HDR scenes. TAA is a bit slower but higher quality and works well with HDR."), m_AntialiasingMode.intValue, s_AntialiasingMethodNames);
if (m_AntialiasingMode.intValue == (int)PostProcessLayer.Antialiasing.TemporalAntialiasing)
{
if (RuntimeUtilities.isSinglePassStereoEnabled)
EditorGUILayout.HelpBox("TAA doesn't work with Single-pass stereo rendering.", MessageType.Warning);
EditorGUILayout.PropertyField(m_TaaJitterSpread);
EditorGUILayout.PropertyField(m_TaaStationaryBlending);
EditorGUILayout.PropertyField(m_TaaMotionBlending);
EditorGUILayout.PropertyField(m_TaaSharpen);
}
else if (m_AntialiasingMode.intValue == (int)PostProcessLayer.Antialiasing.SubpixelMorphologicalAntialiasing)
{
if (RuntimeUtilities.isSinglePassStereoEnabled)
EditorGUILayout.HelpBox("SMAA doesn't work with Single-pass stereo rendering.", MessageType.Warning);
}
else if (m_AntialiasingMode.intValue == (int)PostProcessLayer.Antialiasing.FastApproximateAntialiasing)
{
EditorGUILayout.PropertyField(m_FxaaMobileOptimized);
EditorGUILayout.PropertyField(m_FxaaKeepAlpha);
}
}
EditorGUI.indentLevel--;
EditorGUILayout.Space();
}
void DoAmbientOcclusion(Camera camera)
{
if (RuntimeUtilities.scriptableRenderPipelineActive)
{
return;
}
EditorGUILayout.LabelField(EditorUtilities.GetContent("Ambient Occlusion"), EditorStyles.boldLabel);
EditorGUI.indentLevel++;
{
EditorGUILayout.PropertyField(m_AOEnabled);
if (m_AOEnabled.boolValue)
{
EditorGUILayout.PropertyField(m_AOIntensity);
EditorGUILayout.PropertyField(m_AORadius);
EditorGUILayout.PropertyField(m_AOQuality);
if (camera != null && camera.actualRenderingPath == RenderingPath.DeferredShading && camera.allowHDR)
{
EditorGUILayout.PropertyField(m_AOAmbientOnly);
}
}
}
EditorGUI.indentLevel--;
EditorGUILayout.Space();
}
private void DoToolkit()
{
EditorUtilities.DrawSplitter();
m_ShowToolkit.boolValue = EditorUtilities.DrawHeader("Toolkit", m_ShowToolkit.boolValue);
if (m_ShowToolkit.boolValue)
{
GUILayout.Space(2);
if (GUILayout.Button(EditorUtilities.GetContent("Export frame to EXR..."), EditorStyles.miniButton))
{
var menu = new GenericMenu();
menu.AddItem(EditorUtilities.GetContent("Full Frame (as displayed)"), false,
() => ExportFrameToExr(ExportMode.FullFrame));
menu.AddItem(EditorUtilities.GetContent("Disable post-processing"), false,
() => ExportFrameToExr(ExportMode.DisablePost));
menu.AddItem(EditorUtilities.GetContent("Break before Color Grading (Linear)"), false,
() => ExportFrameToExr(ExportMode.BreakBeforeColorGradingLinear));
menu.AddItem(EditorUtilities.GetContent("Break before Color Grading (Log)"), false,
() => ExportFrameToExr(ExportMode.BreakBeforeColorGradingLog));
menu.ShowAsContext();
}
if (GUILayout.Button(
EditorUtilities.GetContent(
"Select all layer volumes|Selects all the volumes that will influence this layer."),
EditorStyles.miniButton))
{
var volumes = RuntimeUtilities.GetAllSceneObjects <PostProcessVolume>()
.Where(x => (m_VolumeLayer.intValue & (1 << x.gameObject.layer)) != 0)
.Select(x => x.gameObject)
.Cast <Object>()
.ToArray();
if (volumes.Length > 0)
{
Selection.objects = volumes;
}
}
if (GUILayout.Button(
EditorUtilities.GetContent(
"Select all active volumes|Selects all volumes currently affecting the layer."),
EditorStyles.miniButton))
{
var volumes = new List <PostProcessVolume>();
PostProcessManager.instance.GetActiveVolumes(m_Target, volumes);
if (volumes.Count > 0)
{
Selection.objects = volumes
.Select(x => x.gameObject)
.Cast <Object>()
.ToArray();
}
}
GUILayout.Space(3);
}
}
void DoFog(Camera camera)
{
if (RuntimeUtilities.scriptableRenderPipelineActive)
{
return;
}
if (camera == null || camera.actualRenderingPath != RenderingPath.DeferredShading)
{
return;
}
EditorGUILayout.LabelField(EditorUtilities.GetContent("Deferred Fog"), EditorStyles.boldLabel);
EditorGUI.indentLevel++;
{
EditorGUILayout.PropertyField(m_FogEnabled);
if (m_FogEnabled.boolValue)
{
EditorGUILayout.PropertyField(m_FogExcludeSkybox);
EditorGUILayout.HelpBox("This effect adds fog compatibility to the deferred rendering path; actual fog settings should be set in the Lighting panel.", MessageType.Info);
}
}
EditorGUI.indentLevel--;
EditorGUILayout.Space();
}
public override void OnInspectorGUI()
{
serializedObject.Update();
using (var changed = new EditorGUI.ChangeCheckScope())
{
EditorGUILayout.PropertyField(m_PostProcessLayer);
if (changed.changed)
{
RebuildProperties();
}
}
if (m_PostProcessLayer.objectReferenceValue != null)
{
m_Monitors.Update();
DoMonitorGUI(EditorUtilities.GetContent("Light Meter"), m_LightMeterEnabled, m_LightMeterShowCurves);
DoMonitorGUI(EditorUtilities.GetContent("Histogram"), m_HistogramEnabled, m_HistogramChannel);
DoMonitorGUI(EditorUtilities.GetContent("Waveform"), m_WaveformEnabled, m_WaveformExposure);
DoMonitorGUI(EditorUtilities.GetContent("Vectoscope"), m_VectorscopeEnabled, m_VectorscopeExposure);
m_Monitors.ApplyModifiedProperties();
}
serializedObject.ApplyModifiedProperties();
}
public override void OnInspectorGUI()
{
serializedObject.Update();
var camera = m_Target.GetComponent <Camera>();
DoVolumeBlending();
DoAntialiasing();
DoFog(camera);
EditorGUILayout.PropertyField(m_StopNaNPropagation, EditorUtilities.GetContent("Stop NaN Propagation|Automatically replaces NaN/Inf in shaders by a black pixel to avoid breaking some effects. This will slightly affect performances and should only be used if you experience NaN issues that you can't fix. Has no effect on GLES2 platforms."));
#if UNITY_2019_1_OR_NEWER
if (!RuntimeUtilities.scriptableRenderPipelineActive)
{
EditorGUILayout.PropertyField(m_DirectToCameraTarget, EditorUtilities.GetContent("Directly to Camera Target|Use the final blit to the camera render target for postprocessing. This has less overhead but breaks compatibility with legacy image effect that use OnRenderImage."));
}
#endif
EditorGUILayout.Space();
DoToolkit();
DoCustomEffectSorter();
EditorUtilities.DrawSplitter();
EditorGUILayout.Space();
serializedObject.ApplyModifiedProperties();
}
void DoVolumeBlending()
{
EditorGUILayout.LabelField(EditorUtilities.GetContent("Volume blending"), EditorStyles.boldLabel);
EditorGUI.indentLevel++;
{
// The layout system sort of break alignement when mixing inspector fields with
// custom layouted fields, do the layout manually instead
var indentOffset = EditorGUI.indentLevel * 15f;
var lineRect = GUILayoutUtility.GetRect(1, EditorGUIUtility.singleLineHeight);
var labelRect = new Rect(lineRect.x, lineRect.y, EditorGUIUtility.labelWidth - indentOffset, lineRect.height);
var fieldRect = new Rect(labelRect.xMax, lineRect.y, lineRect.width - labelRect.width - 60f, lineRect.height);
var buttonRect = new Rect(fieldRect.xMax, lineRect.y, 60f, lineRect.height);
EditorGUI.PrefixLabel(labelRect, EditorUtilities.GetContent("Trigger|A transform that will act as a trigger for volume blending."));
m_VolumeTrigger.objectReferenceValue = (Transform)EditorGUI.ObjectField(fieldRect, m_VolumeTrigger.objectReferenceValue, typeof(Transform), true);
if (GUI.Button(buttonRect, EditorUtilities.GetContent("This|Assigns the current GameObject as a trigger."), EditorStyles.miniButton))
m_VolumeTrigger.objectReferenceValue = m_Target.transform;
if (m_VolumeTrigger.objectReferenceValue == null)
EditorGUILayout.HelpBox("No trigger has been set, the camera will only be affected by global volumes.", MessageType.Info);
EditorGUILayout.PropertyField(m_VolumeLayer, EditorUtilities.GetContent("Layer|This camera will only be affected by volumes in the selected scene-layers."));
int mask = m_VolumeLayer.intValue;
if (mask == 0)
EditorGUILayout.HelpBox("No layer has been set, the trigger will never be affected by volumes.", MessageType.Warning);
else if (mask == -1 || ((mask & 1) != 0))
EditorGUILayout.HelpBox("Do not use \"Everything\" or \"Default\" as a layer mask as it will slow down the volume blending process! Put post-processing volumes in their own dedicated layer for best performances.", MessageType.Warning);
}
EditorGUI.indentLevel--;
EditorGUILayout.Space();
}
public override void OnInspectorGUI()
{
serializedObject.Update();
var camera = m_Target.GetComponent <Camera>();
#if !UNITY_2017_2_OR_NEWER
if (RuntimeUtilities.isSinglePassStereoSelected)
{
EditorGUILayout.HelpBox("Unity 2017.2+ required for full Single-pass stereo rendering support.", MessageType.Warning);
}
#endif
DoVolumeBlending();
DoAntialiasing();
DoFog(camera);
EditorGUILayout.PropertyField(m_StopNaNPropagation,
EditorUtilities.GetContent(
"Stop NaN Propagation|Automatically replaces NaN/Inf in shaders by a black pixel to avoid breaking some effects. This will slightly affect performances and should only be used if you experience NaN issues that you can't fix. Has no effect on GLES2 platforms."));
EditorGUILayout.Space();
DoToolkit();
DoCustomEffectSorter();
EditorUtilities.DrawSplitter();
EditorGUILayout.Space();
serializedObject.ApplyModifiedProperties();
}
public override void OnInspectorGUI()
{
serializedObject.Update();
using (var changed = new EditorGUI.ChangeCheckScope())
{
EditorGUILayout.PropertyField(m_PostProcessLayer);
serializedObject.ApplyModifiedProperties(); // Needed to rebuild properties after a change
serializedObject.Update();
if (changed.changed)
{
RebuildProperties();
}
}
if (RuntimeUtilities.scriptableRenderPipelineActive)
{
EditorGUILayout.Space();
EditorGUILayout.HelpBox("A scriptable render pipeline is active, these features might not be available.", MessageType.Info);
}
if (m_PostProcessLayer.objectReferenceValue != null)
{
m_LayerObject.Update();
// Overlays
EditorGUILayout.Space();
EditorGUILayout.LabelField(EditorUtilities.GetContent("Overlay"), EditorStyles.boldLabel);
EditorGUI.indentLevel++;
EditorGUILayout.PropertyField(m_Overlay);
DoOverlayGUI(DebugOverlay.Depth, m_LinearDepth);
DoOverlayGUI(DebugOverlay.MotionVectors, m_MotionColorIntensity, m_MotionGridSize);
DoOverlayGUI(DebugOverlay.ColorBlindnessSimulation, m_ColorBlindness, m_ColorBlindnessStrength);
// Special cases
if (m_Overlay.intValue == (int)DebugOverlay.NANTracker && m_Target.postProcessLayer.stopNaNPropagation)
{
EditorGUILayout.HelpBox("Disable \"Stop NaN Propagation\" in the Post-process layer or NaNs will be overwritten!", MessageType.Warning);
}
EditorGUI.indentLevel--;
// Monitors
EditorGUILayout.Space();
EditorGUILayout.LabelField(EditorUtilities.GetContent("Monitors"), EditorStyles.boldLabel);
EditorGUI.indentLevel++;
DoMonitorGUI(EditorUtilities.GetContent("Light Meter"), m_LightMeterEnabled, m_LightMeterShowCurves);
DoMonitorGUI(EditorUtilities.GetContent("Histogram"), m_HistogramEnabled, m_HistogramChannel);
DoMonitorGUI(EditorUtilities.GetContent("Waveform"), m_WaveformEnabled, m_WaveformExposure);
DoMonitorGUI(EditorUtilities.GetContent("Vectorscope"), m_VectorscopeEnabled, m_VectorscopeExposure);
EditorGUI.indentLevel--;
m_LayerObject.ApplyModifiedProperties();
}
serializedObject.ApplyModifiedProperties();
}
void DoAntialiasing()
{
EditorGUILayout.LabelField(EditorUtilities.GetContent("Anti-aliasing"), EditorStyles.boldLabel);
EditorGUI.indentLevel++;
{
m_AntialiasingMode.intValue = EditorGUILayout.Popup(EditorUtilities.GetContent("Mode|The anti-aliasing method to use. FXAA is fast but low quality. SMAA works well for non-HDR scenes. TAA is a bit slower but higher quality and works well with HDR."), m_AntialiasingMode.intValue, s_AntialiasingMethodNames);
if (m_AntialiasingMode.intValue == (int)PostProcessLayer.Antialiasing.TemporalAntialiasing)
{
#if !UNITY_2017_3_OR_NEWER
if (RuntimeUtilities.isSinglePassStereoSelected)
{
EditorGUILayout.HelpBox("TAA requires Unity 2017.3+ for Single-pass stereo rendering support.", MessageType.Warning);
}
#endif
#if UNITY_2017_3_OR_NEWER
if (m_TargetCameraComponent != null && m_TargetCameraComponent.allowDynamicResolution)
{
EditorGUILayout.HelpBox("TAA is not supported with Dynamic Resolution.", MessageType.Warning);
}
#endif
EditorGUILayout.PropertyField(m_TaaJitterSpread);
EditorGUILayout.PropertyField(m_TaaStationaryBlending);
EditorGUILayout.PropertyField(m_TaaMotionBlending);
EditorGUILayout.PropertyField(m_TaaSharpness);
}
else if (m_AntialiasingMode.intValue == (int)PostProcessLayer.Antialiasing.SubpixelMorphologicalAntialiasing)
{
if (RuntimeUtilities.isSinglePassStereoSelected)
{
EditorGUILayout.HelpBox("SMAA doesn't work with Single-pass stereo rendering.", MessageType.Warning);
}
EditorGUILayout.PropertyField(m_SmaaQuality);
if (m_SmaaQuality.intValue != (int)SubpixelMorphologicalAntialiasing.Quality.Low && EditorUtilities.isTargetingConsolesOrMobiles)
{
EditorGUILayout.HelpBox("For performance reasons it is recommended to use Low Quality on mobile and console platforms.", MessageType.Warning);
}
}
else if (m_AntialiasingMode.intValue == (int)PostProcessLayer.Antialiasing.FastApproximateAntialiasing)
{
EditorGUILayout.PropertyField(m_FxaaFastMode);
EditorGUILayout.PropertyField(m_FxaaKeepAlpha);
if (!m_FxaaFastMode.boolValue && EditorUtilities.isTargetingConsolesOrMobiles)
{
EditorGUILayout.HelpBox("For performance reasons it is recommended to use Fast Mode on mobile and console platforms.", MessageType.Warning);
}
}
}
EditorGUI.indentLevel--;
EditorGUILayout.Space();
}
void DoAmbientOcclusion(Camera camera)
{
EditorGUILayout.LabelField(EditorUtilities.GetContent("Ambient Occlusion"), EditorStyles.boldLabel);
EditorGUI.indentLevel++;
{
EditorGUILayout.PropertyField(m_AOEnabled);
if (m_AOEnabled.boolValue)
{
int aoMode = m_AOMode.intValue;
m_AOMode.intValue = EditorGUILayout.Popup(EditorUtilities.GetContent("Mode|The ambient occlusion method to use. \"Modern\" is higher quality and faster on desktop & console platforms but requires compute shader support."), aoMode, s_AmbientOcclusionMethodNames);
if (aoMode == (int)AmbientOcclusion.Mode.SAO)
{
EditorGUILayout.PropertyField(m_SAOIntensity);
EditorGUILayout.PropertyField(m_SAORadius);
EditorGUILayout.PropertyField(m_SAOQuality);
EditorGUILayout.PropertyField(m_SAOColor);
}
else if (aoMode == (int)AmbientOcclusion.Mode.MSVO)
{
if (!SystemInfo.supportsComputeShaders)
{
EditorGUILayout.HelpBox("Multi-scale volumetric obscurance requires compute shader support.", MessageType.Warning);
}
EditorGUILayout.PropertyField(m_MSVOIntensity);
EditorGUILayout.PropertyField(m_MSVOThicknessModifier);
EditorGUILayout.PropertyField(m_MSVOColor);
}
if (camera != null && camera.actualRenderingPath == RenderingPath.DeferredShading && camera.allowHDR)
{
EditorGUILayout.PropertyField(m_AOAmbientOnly);
}
}
}
EditorGUI.indentLevel--;
EditorGUILayout.Space();
}
public override void OnInspectorGUI()
{
serializedObject.Update();
var camera = m_Target.GetComponent<Camera>();
DoVolumeBlending();
DoAntialiasing();
EditorGUILayout.PropertyField(m_StopNaNPropagation, EditorUtilities.GetContent("Stop NaN Propagation|Automatically replaces NaN/Inf in shaders by a black pixel to avoid breaking some effects. This will slightly affect performances and should only be used if you experience NaN issues that you can't fix. Has no effect on GLES2 platforms."));
EditorGUILayout.Space();
DoRenderingFeatures(camera);
DoToolkit();
DoCustomEffectSorter();
EditorUtilities.DrawSplitter();
EditorGUILayout.Space();
serializedObject.ApplyModifiedProperties();
}
public override void OnInspectorGUI()
{
serializedObject.Update();
EditorGUILayout.PropertyField(m_IsGlobal);
if (!m_IsGlobal.boolValue) // Blend radius is not needed for global volumes
{
EditorGUILayout.PropertyField(m_BlendRadius);
}
EditorGUILayout.PropertyField(m_Weight);
EditorGUILayout.PropertyField(m_Priority);
bool assetHasChanged = false;
bool showCopy = m_Profile.objectReferenceValue != null;
// The layout system sort of break alignement when mixing inspector fields with custom
// layouted fields, do the layout manually instead
int buttonWidth = showCopy ? 45 : 60;
float indentOffset = EditorGUI.indentLevel * 15f;
var lineRect = GUILayoutUtility.GetRect(1, EditorGUIUtility.singleLineHeight);
var labelRect = new Rect(lineRect.x, lineRect.y, EditorGUIUtility.labelWidth - indentOffset, lineRect.height);
var fieldRect = new Rect(labelRect.xMax, lineRect.y, lineRect.width - labelRect.width - buttonWidth * (showCopy ? 2 : 1), lineRect.height);
var buttonNewRect = new Rect(fieldRect.xMax, lineRect.y, buttonWidth, lineRect.height);
var buttonCopyRect = new Rect(buttonNewRect.xMax, lineRect.y, buttonWidth, lineRect.height);
EditorGUI.PrefixLabel(labelRect, EditorUtilities.GetContent("Profile|A reference to a profile asset."));
using (var scope = new EditorGUI.ChangeCheckScope())
{
m_Profile.objectReferenceValue = (PostProcessProfile)EditorGUI.ObjectField(fieldRect, m_Profile.objectReferenceValue, typeof(PostProcessProfile), false);
assetHasChanged = scope.changed;
}
if (GUI.Button(buttonNewRect, EditorUtilities.GetContent("New|Create a new profile."), showCopy ? EditorStyles.miniButtonLeft : EditorStyles.miniButton))
{
// By default, try to put assets in a folder next to the currently active
// scene file. If the user isn't a scene, put them in root instead.
var targetName = m_Target.name;
var scene = m_Target.gameObject.scene;
var asset = ProfileFactory.CreatePostProcessProfile(scene, targetName);
m_Profile.objectReferenceValue = asset;
assetHasChanged = true;
}
if (showCopy && GUI.Button(buttonCopyRect, EditorUtilities.GetContent("Clone|Create a new profile and copy the content of the currently assigned profile."), EditorStyles.miniButtonRight))
{
// Duplicate the currently assigned profile and save it as a new profile
var origin = (PostProcessProfile)m_Profile.objectReferenceValue;
var path = AssetDatabase.GetAssetPath(origin);
path = AssetDatabase.GenerateUniqueAssetPath(path);
var asset = Instantiate(origin);
asset.settings.Clear();
AssetDatabase.CreateAsset(asset, path);
foreach (var item in origin.settings)
{
var itemCopy = Instantiate(item);
itemCopy.hideFlags = HideFlags.HideInInspector | HideFlags.HideInHierarchy;
itemCopy.name = item.name;
asset.settings.Add(itemCopy);
AssetDatabase.AddObjectToAsset(itemCopy, asset);
}
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
m_Profile.objectReferenceValue = asset;
assetHasChanged = true;
}
EditorGUILayout.Space();
if (m_Profile.objectReferenceValue == null)
{
if (assetHasChanged)
{
m_EffectList.Clear(); // Asset wasn't null before, do some cleanup
}
EditorGUILayout.HelpBox("Assign a Post-process Profile to this volume using the \"Asset\" field or create one automatically by clicking the \"New\" button.\nAssets are automatically put in a folder next to your scene file. If you scene hasn't been saved yet they will be created at the root of the Assets folder.", MessageType.Info);
}
else
{
if (assetHasChanged)
{
RefreshEffectListEditor((PostProcessProfile)m_Profile.objectReferenceValue);
}
m_EffectList.OnGUI();
}
serializedObject.ApplyModifiedProperties();
}
protected void PropertyField(SerializedParameterOverride property)
{
var title = EditorUtilities.GetContent(property.displayName);
PropertyField(property, title);
}
public void OnGUI()
{
if (asset == null)
{
return;
}
if (asset.isDirty)
{
RefreshEditors();
asset.isDirty = false;
}
bool isEditable = !VersionControl.Provider.isActive ||
AssetDatabase.IsOpenForEdit(asset, StatusQueryOptions.UseCachedIfPossible);
using (new EditorGUI.DisabledScope(!isEditable))
{
EditorGUILayout.LabelField(EditorUtilities.GetContent("Overrides"), EditorStyles.boldLabel);
// Override list
for (int i = 0; i < m_Editors.Count; i++)
{
var editor = m_Editors[i];
string title = editor.GetDisplayTitle();
int id = i; // Needed for closure capture below
EditorUtilities.DrawSplitter();
bool displayContent = EditorUtilities.DrawHeader(
title,
editor.baseProperty,
editor.activeProperty,
editor.target,
() => ResetEffectOverride(editor.target.GetType(), id),
() => RemoveEffectOverride(id)
);
if (displayContent)
{
using (new EditorGUI.DisabledScope(!editor.activeProperty.boolValue))
editor.OnInternalInspectorGUI();
}
}
if (m_Editors.Count > 0)
{
EditorUtilities.DrawSplitter();
EditorGUILayout.Space();
}
else
{
EditorGUILayout.HelpBox("No override set on this volume.", MessageType.Info);
}
if (GUILayout.Button("Add effect...", EditorStyles.miniButton))
{
var menu = new GenericMenu();
var typeMap = PostProcessManager.instance.settingsTypes;
foreach (var kvp in typeMap)
{
var type = kvp.Key;
var title = EditorUtilities.GetContent(kvp.Value.menuItem);
bool exists = asset.HasSettings(type);
if (!exists)
{
menu.AddItem(title, false, () => AddEffectOverride(type));
}
else
{
menu.AddDisabledItem(title);
}
}
menu.ShowAsContext();
}
EditorGUILayout.Space();
}
}
void DoStandardModeGUI(bool hdr)
{
if (!hdr)
{
PropertyField(m_LdrLut);
PropertyField(m_LdrLutContribution);
var lut = (target as ColorGrading).ldrLut.value;
CheckLutImportSettings(lut);
}
if (hdr)
{
EditorGUILayout.Space();
EditorUtilities.DrawHeaderLabel("Tonemapping");
PropertyField(m_Tonemapper);
if (m_Tonemapper.value.intValue == (int)Tonemapper.Custom)
{
DrawCustomToneCurve();
PropertyField(m_ToneCurveToeStrength);
PropertyField(m_ToneCurveToeLength);
PropertyField(m_ToneCurveShoulderStrength);
PropertyField(m_ToneCurveShoulderLength);
PropertyField(m_ToneCurveShoulderAngle);
PropertyField(m_ToneCurveGamma);
}
}
EditorGUILayout.Space();
EditorUtilities.DrawHeaderLabel("White Balance");
PropertyField(m_Temperature);
PropertyField(m_Tint);
EditorGUILayout.Space();
EditorUtilities.DrawHeaderLabel("Tone");
if (hdr)
{
PropertyField(m_PostExposure);
}
PropertyField(m_ColorFilter);
PropertyField(m_HueShift);
PropertyField(m_Saturation);
if (!hdr)
{
PropertyField(m_Brightness);
}
PropertyField(m_Contrast);
EditorGUILayout.Space();
int currentChannel = GlobalSettings.currentChannelMixer;
using (new EditorGUILayout.HorizontalScope())
{
EditorGUILayout.PrefixLabel("Channel Mixer", GUIStyle.none, Styling.headerLabel);
EditorGUI.BeginChangeCheck();
{
using (new EditorGUILayout.HorizontalScope())
{
GUILayoutUtility.GetRect(9f, 18f, GUILayout.ExpandWidth(false)); // Dirty hack to do proper right column alignement
if (GUILayout.Toggle(currentChannel == 0, EditorUtilities.GetContent("Red|Red output channel."), EditorStyles.miniButtonLeft))
{
currentChannel = 0;
}
if (GUILayout.Toggle(currentChannel == 1, EditorUtilities.GetContent("Green|Green output channel."), EditorStyles.miniButtonMid))
{
currentChannel = 1;
}
if (GUILayout.Toggle(currentChannel == 2, EditorUtilities.GetContent("Blue|Blue output channel."), EditorStyles.miniButtonRight))
{
currentChannel = 2;
}
}
}
if (EditorGUI.EndChangeCheck())
{
GUI.FocusControl(null);
}
}
GlobalSettings.currentChannelMixer = currentChannel;
if (currentChannel == 0)
{
PropertyField(m_MixerRedOutRedIn);
PropertyField(m_MixerRedOutGreenIn);
PropertyField(m_MixerRedOutBlueIn);
}
else if (currentChannel == 1)
{
PropertyField(m_MixerGreenOutRedIn);
PropertyField(m_MixerGreenOutGreenIn);
PropertyField(m_MixerGreenOutBlueIn);
}
else
{
PropertyField(m_MixerBlueOutRedIn);
PropertyField(m_MixerBlueOutGreenIn);
PropertyField(m_MixerBlueOutBlueIn);
}
EditorGUILayout.Space();
EditorUtilities.DrawHeaderLabel("Trackballs");
using (new EditorGUILayout.HorizontalScope())
{
PropertyField(m_Lift);
GUILayout.Space(4f);
PropertyField(m_Gamma);
GUILayout.Space(4f);
PropertyField(m_Gain);
}
EditorGUILayout.Space();
EditorUtilities.DrawHeaderLabel("Grading Curves");
DoCurvesGUI(hdr);
}
void CurveOverrideToggle(SerializedProperty overrideProp)
{
overrideProp.boolValue = GUILayout.Toggle(overrideProp.boolValue, EditorUtilities.GetContent("Override"), EditorStyles.toolbarButton);
}
