Library/PackageCache/com.unity.postprocessing@2.1.2/PostProcessing/Editor/PostProcessLayerEditor.cs

   1 using System;
   2 using System.Collections.Generic;
   3 using System.Linq;
   4 using UnityEngine;
   5 using UnityEngine.Rendering.PostProcessing;
   6 using UnityEditorInternal;
   7 using System.IO;
   8
   9 namespace UnityEditor.Rendering.PostProcessing
  10 {
  11     using SerializedBundleRef = PostProcessLayer.SerializedBundleRef;
  12     using EXRFlags = Texture2D.EXRFlags;
  13
  14     [CanEditMultipleObjects, CustomEditor(typeof(PostProcessLayer))]
  15     sealed class PostProcessLayerEditor : BaseEditor<PostProcessLayer>
  16     {
  17         SerializedProperty m_StopNaNPropagation;
  18 #pragma warning disable 414
  19         SerializedProperty m_DirectToCameraTarget;
  20 #pragma warning restore 414
  21         SerializedProperty m_VolumeTrigger;
  22         SerializedProperty m_VolumeLayer;
  23
  24         SerializedProperty m_AntialiasingMode;
  25         SerializedProperty m_TaaJitterSpread;
  26         SerializedProperty m_TaaSharpness;
  27         SerializedProperty m_TaaStationaryBlending;
  28         SerializedProperty m_TaaMotionBlending;
  29         SerializedProperty m_SmaaQuality;
  30         SerializedProperty m_FxaaFastMode;
  31         SerializedProperty m_FxaaKeepAlpha;
  32
  33         SerializedProperty m_FogEnabled;
  34         SerializedProperty m_FogExcludeSkybox;
  35
  36         SerializedProperty m_ShowToolkit;
  37         SerializedProperty m_ShowCustomSorter;
  38
  39         Dictionary<PostProcessEvent, ReorderableList> m_CustomLists;
  40
  41         static GUIContent[] s_AntialiasingMethodNames =
  42         {
  43             new GUIContent("No Anti-aliasing"),
  44             new GUIContent("Fast Approximate Anti-aliasing (FXAA)"),
  45             new GUIContent("Subpixel Morphological Anti-aliasing (SMAA)"),
  46             new GUIContent("Temporal Anti-aliasing (TAA)")
  47         };
  48
  49         enum ExportMode
  50         {
  51             FullFrame,
  52             DisablePost,
  53             BreakBeforeColorGradingLinear,
  54             BreakBeforeColorGradingLog
  55         }
  56
  57         void OnEnable()
  58         {
  59             m_StopNaNPropagation = FindProperty(x => x.stopNaNPropagation);
  60             m_DirectToCameraTarget = FindProperty(x => x.finalBlitToCameraTarget);
  61             m_VolumeTrigger = FindProperty(x => x.volumeTrigger);
  62             m_VolumeLayer = FindProperty(x => x.volumeLayer);
  63
  64             m_AntialiasingMode = FindProperty(x => x.antialiasingMode);
  65             m_TaaJitterSpread = FindProperty(x => x.temporalAntialiasing.jitterSpread);
  66             m_TaaSharpness = FindProperty(x => x.temporalAntialiasing.sharpness);
  67             m_TaaStationaryBlending = FindProperty(x => x.temporalAntialiasing.stationaryBlending);
  68             m_TaaMotionBlending = FindProperty(x => x.temporalAntialiasing.motionBlending);
  69             m_SmaaQuality = FindProperty(x => x.subpixelMorphologicalAntialiasing.quality);
  70             m_FxaaFastMode = FindProperty(x => x.fastApproximateAntialiasing.fastMode);
  71             m_FxaaKeepAlpha = FindProperty(x => x.fastApproximateAntialiasing.keepAlpha);
  72
  73             m_FogEnabled = FindProperty(x => x.fog.enabled);
  74             m_FogExcludeSkybox = FindProperty(x => x.fog.excludeSkybox);
  75
  76             m_ShowToolkit = serializedObject.FindProperty("m_ShowToolkit");
  77             m_ShowCustomSorter = serializedObject.FindProperty("m_ShowCustomSorter");
  78         }
  79
  80         void OnDisable()
  81         {
  82             m_CustomLists = null;
  83         }
  84
  85         public override void OnInspectorGUI()
  86         {
  87             serializedObject.Update();
  88
  89             var camera = m_Target.GetComponent<Camera>();
  90
  91             #if !UNITY_2017_2_OR_NEWER
  92             if (RuntimeUtilities.isSinglePassStereoSelected)
  93                 EditorGUILayout.HelpBox("Unity 2017.2+ required for full Single-pass stereo rendering support.", MessageType.Warning);
  94             #endif
  95
  96             DoVolumeBlending();
  97             DoAntialiasing();
  98             DoFog(camera);
  99
 100             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."));
 101
 102 #if UNITY_2019_1_OR_NEWER
 103             if (!RuntimeUtilities.scriptableRenderPipelineActive)
 104                 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."));
 105 #endif
 106
 107             EditorGUILayout.Space();
 108
 109             DoToolkit();
 110             DoCustomEffectSorter();
 111
 112             EditorUtilities.DrawSplitter();
 113             EditorGUILayout.Space();
 114
 115             serializedObject.ApplyModifiedProperties();
 116         }
 117
 118         void DoVolumeBlending()
 119         {
 120             EditorGUILayout.LabelField(EditorUtilities.GetContent("Volume blending"), EditorStyles.boldLabel);
 121             EditorGUI.indentLevel++;
 122             {
 123                 // The layout system sort of break alignement when mixing inspector fields with
 124                 // custom layouted fields, do the layout manually instead
 125                 var indentOffset = EditorGUI.indentLevel * 15f;
 126                 var lineRect = GUILayoutUtility.GetRect(1, EditorGUIUtility.singleLineHeight);
 127                 var labelRect = new Rect(lineRect.x, lineRect.y, EditorGUIUtility.labelWidth - indentOffset, lineRect.height);
 128                 var fieldRect = new Rect(labelRect.xMax, lineRect.y, lineRect.width - labelRect.width - 60f, lineRect.height);
 129                 var buttonRect = new Rect(fieldRect.xMax, lineRect.y, 60f, lineRect.height);
 130
 131                 EditorGUI.PrefixLabel(labelRect, EditorUtilities.GetContent("Trigger|A transform that will act as a trigger for volume blending."));
 132                 m_VolumeTrigger.objectReferenceValue = (Transform)EditorGUI.ObjectField(fieldRect, m_VolumeTrigger.objectReferenceValue, typeof(Transform), true);
 133                 if (GUI.Button(buttonRect, EditorUtilities.GetContent("This|Assigns the current GameObject as a trigger."), EditorStyles.miniButton))
 134                     m_VolumeTrigger.objectReferenceValue = m_Target.transform;
 135
 136                 if (m_VolumeTrigger.objectReferenceValue == null)
 137                     EditorGUILayout.HelpBox("No trigger has been set, the camera will only be affected by global volumes.", MessageType.Info);
 138
 139                 EditorGUILayout.PropertyField(m_VolumeLayer, EditorUtilities.GetContent("Layer|This camera will only be affected by volumes in the selected scene-layers."));
 140
 141                 int mask = m_VolumeLayer.intValue;
 142                 if (mask == 0)
 143                     EditorGUILayout.HelpBox("No layer has been set, the trigger will never be affected by volumes.", MessageType.Warning);
 144                 else if (mask == -1 || ((mask & 1) != 0))
 145                     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);
 146             }
 147             EditorGUI.indentLevel--;
 148
 149             EditorGUILayout.Space();
 150         }
 151
 152         void DoAntialiasing()
 153         {
 154             EditorGUILayout.LabelField(EditorUtilities.GetContent("Anti-aliasing"), EditorStyles.boldLabel);
 155             EditorGUI.indentLevel++;
 156             {
 157                 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);
 158
 159                 if (m_AntialiasingMode.intValue == (int)PostProcessLayer.Antialiasing.TemporalAntialiasing)
 160                 {
 161                     #if !UNITY_2017_3_OR_NEWER
 162                     if (RuntimeUtilities.isSinglePassStereoSelected)
 163                         EditorGUILayout.HelpBox("TAA requires Unity 2017.3+ for Single-pass stereo rendering support.", MessageType.Warning);
 164                     #endif
 165
 166                     EditorGUILayout.PropertyField(m_TaaJitterSpread);
 167                     EditorGUILayout.PropertyField(m_TaaStationaryBlending);
 168                     EditorGUILayout.PropertyField(m_TaaMotionBlending);
 169                     EditorGUILayout.PropertyField(m_TaaSharpness);
 170                 }
 171                 else if (m_AntialiasingMode.intValue == (int)PostProcessLayer.Antialiasing.SubpixelMorphologicalAntialiasing)
 172                 {
 173                     if (RuntimeUtilities.isSinglePassStereoSelected)
 174                         EditorGUILayout.HelpBox("SMAA doesn't work with Single-pass stereo rendering.", MessageType.Warning);
 175
 176                     EditorGUILayout.PropertyField(m_SmaaQuality);
 177
 178                     if (m_SmaaQuality.intValue != (int)SubpixelMorphologicalAntialiasing.Quality.Low && EditorUtilities.isTargetingConsolesOrMobiles)
 179                         EditorGUILayout.HelpBox("For performance reasons it is recommended to use Low Quality on mobile and console platforms.", MessageType.Warning);
 180                 }
 181                 else if (m_AntialiasingMode.intValue == (int)PostProcessLayer.Antialiasing.FastApproximateAntialiasing)
 182                 {
 183                     EditorGUILayout.PropertyField(m_FxaaFastMode);
 184                     EditorGUILayout.PropertyField(m_FxaaKeepAlpha);
 185
 186                     if (!m_FxaaFastMode.boolValue && EditorUtilities.isTargetingConsolesOrMobiles)
 187                         EditorGUILayout.HelpBox("For performance reasons it is recommended to use Fast Mode on mobile and console platforms.", MessageType.Warning);
 188                 }
 189             }
 190             EditorGUI.indentLevel--;
 191
 192             EditorGUILayout.Space();
 193         }
 194
 195         void DoFog(Camera camera)
 196         {
 197             if (camera == null || camera.actualRenderingPath != RenderingPath.DeferredShading)
 198                 return;
 199
 200             EditorGUILayout.LabelField(EditorUtilities.GetContent("Deferred Fog"), EditorStyles.boldLabel);
 201             EditorGUI.indentLevel++;
 202             {
 203                 EditorGUILayout.PropertyField(m_FogEnabled);
 204
 205                 if (m_FogEnabled.boolValue)
 206                 {
 207                     EditorGUILayout.PropertyField(m_FogExcludeSkybox);
 208                     EditorGUILayout.HelpBox("This adds fog compatibility to the deferred rendering path; actual fog settings should be set in the Lighting panel.", MessageType.Info);
 209                 }
 210             }
 211             EditorGUI.indentLevel--;
 212
 213             EditorGUILayout.Space();
 214         }
 215
 216         void DoToolkit()
 217         {
 218             EditorUtilities.DrawSplitter();
 219             m_ShowToolkit.boolValue = EditorUtilities.DrawHeader("Toolkit", m_ShowToolkit.boolValue);
 220
 221             if (m_ShowToolkit.boolValue)
 222             {
 223                 GUILayout.Space(2);
 224
 225                 if (GUILayout.Button(EditorUtilities.GetContent("Export frame to EXR..."), EditorStyles.miniButton))
 226                 {
 227                     var menu = new GenericMenu();
 228                     menu.AddItem(EditorUtilities.GetContent("Full Frame (as displayed)"), false, () => ExportFrameToExr(ExportMode.FullFrame));
 229                     menu.AddItem(EditorUtilities.GetContent("Disable post-processing"), false, () => ExportFrameToExr(ExportMode.DisablePost));
 230                     menu.AddItem(EditorUtilities.GetContent("Break before Color Grading (Linear)"), false, () => ExportFrameToExr(ExportMode.BreakBeforeColorGradingLinear));
 231                     menu.AddItem(EditorUtilities.GetContent("Break before Color Grading (Log)"), false, () => ExportFrameToExr(ExportMode.BreakBeforeColorGradingLog));
 232                     menu.ShowAsContext();
 233                 }
 234
 235                 if (GUILayout.Button(EditorUtilities.GetContent("Select all layer volumes|Selects all the volumes that will influence this layer."), EditorStyles.miniButton))
 236                 {
 237                     var volumes = RuntimeUtilities.GetAllSceneObjects<PostProcessVolume>()
 238                         .Where(x => (m_VolumeLayer.intValue & (1 << x.gameObject.layer)) != 0)
 239                         .Select(x => x.gameObject)
 240                         .Cast<UnityEngine.Object>()
 241                         .ToArray();
 242
 243                     if (volumes.Length > 0)
 244                         Selection.objects = volumes;
 245                 }
 246
 247                 if (GUILayout.Button(EditorUtilities.GetContent("Select all active volumes|Selects all volumes currently affecting the layer."), EditorStyles.miniButton))
 248                 {
 249                     var volumes = new List<PostProcessVolume>();
 250                     PostProcessManager.instance.GetActiveVolumes(m_Target, volumes);
 251
 252                     if (volumes.Count > 0)
 253                     {
 254                         Selection.objects = volumes
 255                             .Select(x => x.gameObject)
 256                             .Cast<UnityEngine.Object>()
 257                             .ToArray();
 258                     }
 259                 }
 260
 261                 GUILayout.Space(3);
 262             }
 263         }
 264
 265         void DoCustomEffectSorter()
 266         {
 267             EditorUtilities.DrawSplitter();
 268             m_ShowCustomSorter.boolValue = EditorUtilities.DrawHeader("Custom Effect Sorting", m_ShowCustomSorter.boolValue);
 269
 270             if (m_ShowCustomSorter.boolValue)
 271             {
 272                 bool isInPrefab = false;
 273
 274                 // Init lists if needed
 275                 if (m_CustomLists == null)
 276                 {
 277                     // In some cases the editor will refresh before components which means
 278                     // components might not have been fully initialized yet. In this case we also
 279                     // need to make sure that we're not in a prefab as sorteBundles isn't a
 280                     // serializable object and won't exist until put on a scene.
 281                     if (m_Target.sortedBundles == null)
 282                     {
 283                         isInPrefab = string.IsNullOrEmpty(m_Target.gameObject.scene.name);
 284
 285                         if (!isInPrefab)
 286                         {
 287                             // sortedBundles will be initialized and ready to use on the next frame
 288                             Repaint();
 289                         }
 290                     }
 291                     else
 292                     {
 293                         // Create a reorderable list for each injection event
 294                         m_CustomLists = new Dictionary<PostProcessEvent, ReorderableList>();
 295                         foreach (var evt in Enum.GetValues(typeof(PostProcessEvent)).Cast<PostProcessEvent>())
 296                         {
 297                             var bundles = m_Target.sortedBundles[evt];
 298                             var listName = ObjectNames.NicifyVariableName(evt.ToString());
 299
 300                             var list = new ReorderableList(bundles, typeof(SerializedBundleRef), true, true, false, false);
 301
 302                             list.drawHeaderCallback = (rect) =>
 303                             {
 304                                 EditorGUI.LabelField(rect, listName);
 305                             };
 306
 307                             list.drawElementCallback = (rect, index, isActive, isFocused) =>
 308                             {
 309                                 var sbr = (SerializedBundleRef)list.list[index];
 310                                 EditorGUI.LabelField(rect, sbr.bundle.attribute.menuItem);
 311                             };
 312
 313                             list.onReorderCallback = (l) =>
 314                             {
 315                                 EditorUtility.SetDirty(m_Target);
 316                             };
 317
 318                             m_CustomLists.Add(evt, list);
 319                         }
 320                     }
 321                 }
 322
 323                 GUILayout.Space(5);
 324
 325                 if (isInPrefab)
 326                 {
 327                     EditorGUILayout.HelpBox("Not supported in prefabs.", MessageType.Info);
 328                     GUILayout.Space(3);
 329                     return;
 330                 }
 331
 332                 bool anyList = false;
 333                 if (m_CustomLists != null)
 334                 {
 335                     foreach (var kvp in m_CustomLists)
 336                     {
 337                         var list = kvp.Value;
 338
 339                         // Skip empty lists to avoid polluting the inspector
 340                         if (list.count == 0)
 341                             continue;
 342
 343                         list.DoLayoutList();
 344                         anyList = true;
 345                     }
 346                 }
 347
 348                 if (!anyList)
 349                 {
 350                     EditorGUILayout.HelpBox("No custom effect loaded.", MessageType.Info);
 351                     GUILayout.Space(3);
 352                 }
 353             }
 354         }
 355
 356         void ExportFrameToExr(ExportMode mode)
 357         {
 358             string path = EditorUtility.SaveFilePanel("Export EXR...", "", "Frame", "exr");
 359
 360             if (string.IsNullOrEmpty(path))
 361                 return;
 362
 363             EditorUtility.DisplayProgressBar("Export EXR", "Rendering...", 0f);
 364
 365             var camera = m_Target.GetComponent<Camera>();
 366             var w = camera.pixelWidth;
 367             var h = camera.pixelHeight;
 368
 369             var texOut = new Texture2D(w, h, TextureFormat.RGBAFloat, false, true);
 370             var target = RenderTexture.GetTemporary(w, h, 24, RenderTextureFormat.ARGBFloat, RenderTextureReadWrite.Linear);
 371
 372             var lastActive = RenderTexture.active;
 373             var lastTargetSet = camera.targetTexture;
 374             var lastPostFXState = m_Target.enabled;
 375             var lastBreakColorGradingState = m_Target.breakBeforeColorGrading;
 376
 377             if (mode == ExportMode.DisablePost)
 378                 m_Target.enabled = false;
 379             else if (mode == ExportMode.BreakBeforeColorGradingLinear || mode == ExportMode.BreakBeforeColorGradingLog)
 380                 m_Target.breakBeforeColorGrading = true;
 381
 382             camera.targetTexture = target;
 383             camera.Render();
 384             camera.targetTexture = lastTargetSet;
 385
 386             EditorUtility.DisplayProgressBar("Export EXR", "Reading...", 0.25f);
 387
 388             m_Target.enabled = lastPostFXState;
 389             m_Target.breakBeforeColorGrading = lastBreakColorGradingState;
 390
 391             if (mode == ExportMode.BreakBeforeColorGradingLog)
 392             {
 393                 // Convert to log
 394                 var material = new Material(Shader.Find("Hidden/PostProcessing/Editor/ConvertToLog"));
 395                 var newTarget = RenderTexture.GetTemporary(w, h, 0, RenderTextureFormat.ARGBFloat, RenderTextureReadWrite.Linear);
 396                 Graphics.Blit(target, newTarget, material, 0);
 397                 RenderTexture.ReleaseTemporary(target);
 398                 DestroyImmediate(material);
 399                 target = newTarget;
 400             }
 401
 402             RenderTexture.active = target;
 403             texOut.ReadPixels(new Rect(0, 0, w, h), 0, 0);
 404             texOut.Apply();
 405             RenderTexture.active = lastActive;
 406
 407             EditorUtility.DisplayProgressBar("Export EXR", "Encoding...", 0.5f);
 408
 409             var bytes = texOut.EncodeToEXR(EXRFlags.OutputAsFloat | EXRFlags.CompressZIP);
 410
 411             EditorUtility.DisplayProgressBar("Export EXR", "Saving...", 0.75f);
 412
 413             File.WriteAllBytes(path, bytes);
 414
 415             EditorUtility.ClearProgressBar();
 416             AssetDatabase.Refresh();
 417
 418             RenderTexture.ReleaseTemporary(target);
 419             DestroyImmediate(texOut);
 420         }
 421     }
 422 }