Library/PackageCache/com.unity.postprocessing@2.1.2/PostProcessing/Runtime/Effects/AmbientOcclusion.cs

   1 using System;
   2
   3 namespace UnityEngine.Rendering.PostProcessing
   4 {
   5     /// <summary>
   6     /// Ambient occlusion modes.
   7     /// </summary>
   8     public enum AmbientOcclusionMode
   9     {
  10         /// <summary>
  11         /// A standard implementation of ambient obscurance that works on non modern platforms. If
  12         /// you target a compute-enabled platform we recommend that you use
  13         /// <see cref="MultiScaleVolumetricObscurance"/> instead.
  14         /// </summary>
  15         ScalableAmbientObscurance,
  16
  17         /// <summary>
  18         /// A modern version of ambient occlusion heavily optimized for consoles and desktop
  19         /// platforms.
  20         /// </summary>
  21         MultiScaleVolumetricObscurance
  22     }
  23
  24     /// <summary>
  25     /// Quality settings for <see cref="AmbientOcclusionMode.ScalableAmbientObscurance"/>.
  26     /// </summary>
  27     public enum AmbientOcclusionQuality
  28     {
  29         /// <summary>
  30         /// 4 samples + downsampling.
  31         /// </summary>
  32         Lowest,
  33
  34         /// <summary>
  35         /// 6 samples + downsampling.
  36         /// </summary>
  37         Low,
  38
  39         /// <summary>
  40         /// 10 samples + downsampling.
  41         /// </summary>
  42         Medium,
  43
  44         /// <summary>
  45         /// 8 samples.
  46         /// </summary>
  47         High,
  48
  49         /// <summary>
  50         /// 12 samples.
  51         /// </summary>
  52         Ultra
  53     }
  54
  55     /// <summary>
  56     /// A volume parameter holding a <see cref="AmbientOcclusionMode"/> value.
  57     /// </summary>
  58     [Serializable]
  59     public sealed class AmbientOcclusionModeParameter : ParameterOverride<AmbientOcclusionMode> {}
  60
  61     /// <summary>
  62     /// A volume parameter holding a <see cref="AmbientOcclusionQuality"/> value.
  63     /// </summary>
  64     [Serializable]
  65     public sealed class AmbientOcclusionQualityParameter : ParameterOverride<AmbientOcclusionQuality> {}
  66
  67     /// <summary>
  68     /// This class holds settings for the Ambient Occlusion effect.
  69     /// </summary>
  70     [Serializable]
  71     [PostProcess(typeof(AmbientOcclusionRenderer), "Unity/Ambient Occlusion")]
  72     public sealed class AmbientOcclusion : PostProcessEffectSettings
  73     {
  74         // Shared parameters
  75
  76         /// <summary>
  77         /// The ambient occlusion method to use.
  78         /// </summary>
  79         [Tooltip("The ambient occlusion method to use. \"Multi Scale Volumetric Obscurance\" is higher quality and faster on desktop & console platforms but requires compute shader support.")]
  80
  81         public AmbientOcclusionModeParameter mode = new AmbientOcclusionModeParameter { value = AmbientOcclusionMode.MultiScaleVolumetricObscurance };
  82
  83         /// <summary>
  84         /// The degree of darkness added by ambient occlusion.
  85         /// </summary>
  86         [Range(0f, 4f), Tooltip("The degree of darkness added by ambient occlusion. Higher values produce darker areas.")]
  87         public FloatParameter intensity = new FloatParameter { value = 0f };
  88
  89         /// <summary>
  90         /// A custom color to use for the ambient occlusion.
  91         /// </summary>
  92         [ColorUsage(false), Tooltip("The custom color to use for the ambient occlusion. The default is black.")]
  93
  94         public ColorParameter color = new ColorParameter { value = Color.black };
  95
  96         /// <summary>
  97         /// Only affects ambient lighting. This mode is only available with the Deferred rendering
  98         /// path and HDR rendering. Objects rendered with the Forward rendering path won't get any
  99         /// ambient occlusion.
 100         /// </summary>
 101         [Tooltip("Check this box to mark this Volume as to only affect ambient lighting. This mode is only available with the Deferred rendering path and HDR rendering. Objects rendered with the Forward rendering path won't get any ambient occlusion.")]
 102         public BoolParameter ambientOnly = new BoolParameter { value = true };
 103
 104         // MSVO-only parameters
 105
 106         /// <summary>
 107         /// The tolerance of the noise filter to changes in the depth pyramid.
 108         /// </summary>
 109         [Range(-8f, 0f)]
 110         public FloatParameter noiseFilterTolerance = new FloatParameter { value = 0f }; // Hidden
 111
 112         /// <summary>
 113         /// The tolerance of the bilateral blur filter to depth changes.
 114         /// </summary>
 115         [Range(-8f, -1f)]
 116         public FloatParameter blurTolerance = new FloatParameter { value = -4.6f }; // Hidden
 117
 118         /// <summary>
 119         /// The tolerance of the upsampling pass to depth changes.
 120         /// </summary>
 121         [Range(-12f, -1f)]
 122         public FloatParameter upsampleTolerance = new FloatParameter { value = -12f }; // Hidden
 123
 124         /// <summary>
 125         /// Modifies the thickness of occluders. This increases dark areas but also introduces dark
 126         /// halo around objects.
 127         /// </summary>
 128         [Range(1f, 10f), Tooltip("This modifies the thickness of occluders. It increases the size of dark areas and also introduces a dark halo around objects.")]
 129         public FloatParameter thicknessModifier = new FloatParameter { value = 1f };
 130
 131         // HDRP-only parameters
 132
 133         /// <summary>
 134         /// Modifies he influence of direct lighting on ambient occlusion. This is only used in the
 135         /// HD Render Pipeline currently.
 136         /// </summary>
 137         [Range(0f, 1f), Tooltip("Modifies the influence of direct lighting on ambient occlusion.")]
 138         public FloatParameter directLightingStrength = new FloatParameter { value = 0f };
 139
 140         // SAO-only parameters
 141         /// <summary>
 142         /// Radius of sample points, which affects extent of darkened areas.
 143         /// </summary>
 144         [Tooltip("The radius of sample points. This affects the size of darkened areas.")]
 145         public FloatParameter radius = new FloatParameter { value = 0.25f };
 146
 147         /// <summary>
 148         /// The number of sample points, which affects quality and performance. Lowest, Low & Medium
 149         /// passes are downsampled. High and Ultra are not and should only be used on high-end
 150         /// hardware.
 151         /// </summary>
 152         [Tooltip("The number of sample points. This affects both quality and performance. For \"Lowest\", \"Low\", and \"Medium\", passes are downsampled. For \"High\" and \"Ultra\", they are not and therefore you should only \"High\" and \"Ultra\" on high-end hardware.")]
 153         public AmbientOcclusionQualityParameter quality = new AmbientOcclusionQualityParameter { value = AmbientOcclusionQuality.Medium };
 154
 155         // SRPs can call this method without a context set (see HDRP).
 156         // We need a better way to handle this than checking for a null context, context should
 157         // never be null.
 158         /// <inheritdoc />
 159         public override bool IsEnabledAndSupported(PostProcessRenderContext context)
 160         {
 161             bool state = enabled.value
 162                 && intensity.value > 0f;
 163
 164             if (mode.value == AmbientOcclusionMode.ScalableAmbientObscurance)
 165             {
 166                 state &= !RuntimeUtilities.scriptableRenderPipelineActive;
 167
 168                 if (context != null)
 169                 {
 170                     state &= context.resources.shaders.scalableAO
 171                           && context.resources.shaders.scalableAO.isSupported;
 172                 }
 173             }
 174             else if (mode.value == AmbientOcclusionMode.MultiScaleVolumetricObscurance)
 175             {
 176 #if UNITY_2017_1_OR_NEWER
 177                 if (context != null)
 178                 {
 179                     state &= context.resources.shaders.multiScaleAO
 180                           && context.resources.shaders.multiScaleAO.isSupported
 181                           && context.resources.computeShaders.multiScaleAODownsample1
 182                           && context.resources.computeShaders.multiScaleAODownsample2
 183                           && context.resources.computeShaders.multiScaleAORender
 184                           && context.resources.computeShaders.multiScaleAOUpsample;
 185                 }
 186
 187                 state &= SystemInfo.supportsComputeShaders
 188                       && !RuntimeUtilities.isAndroidOpenGL
 189                       && RenderTextureFormat.RFloat.IsSupported()
 190                       && RenderTextureFormat.RHalf.IsSupported()
 191                       && RenderTextureFormat.R8.IsSupported();
 192 #else
 193                 state = false;
 194 #endif
 195             }
 196
 197             return state;
 198         }
 199     }
 200
 201     internal interface IAmbientOcclusionMethod
 202     {
 203         DepthTextureMode GetCameraFlags();
 204         void RenderAfterOpaque(PostProcessRenderContext context);
 205         void RenderAmbientOnly(PostProcessRenderContext context);
 206         void CompositeAmbientOnly(PostProcessRenderContext context);
 207         void Release();
 208     }
 209
 210     internal sealed class AmbientOcclusionRenderer : PostProcessEffectRenderer<AmbientOcclusion>
 211     {
 212         IAmbientOcclusionMethod[] m_Methods;
 213
 214         public override void Init()
 215         {
 216             if (m_Methods == null)
 217             {
 218                 m_Methods = new IAmbientOcclusionMethod[]
 219                 {
 220                     new ScalableAO(settings),
 221                     new MultiScaleVO(settings),
 222                 };
 223             }
 224         }
 225
 226         public bool IsAmbientOnly(PostProcessRenderContext context)
 227         {
 228             var camera = context.camera;
 229             return settings.ambientOnly.value
 230                 && camera.actualRenderingPath == RenderingPath.DeferredShading
 231                 && camera.allowHDR;
 232         }
 233
 234         public IAmbientOcclusionMethod Get()
 235         {
 236             return m_Methods[(int)settings.mode.value];
 237         }
 238
 239         public override DepthTextureMode GetCameraFlags()
 240         {
 241             return Get().GetCameraFlags();
 242         }
 243
 244         public override void Release()
 245         {
 246             foreach (var m in m_Methods)
 247                 m.Release();
 248         }
 249
 250         public ScalableAO GetScalableAO()
 251         {
 252             return (ScalableAO)m_Methods[(int)AmbientOcclusionMode.ScalableAmbientObscurance];
 253         }
 254
 255         public MultiScaleVO GetMultiScaleVO()
 256         {
 257             return (MultiScaleVO)m_Methods[(int)AmbientOcclusionMode.MultiScaleVolumetricObscurance];
 258         }
 259
 260         // Unused
 261         public override void Render(PostProcessRenderContext context)
 262         {
 263         }
 264     }
 265 }