Add runtime checks if strippable shaders are available

hkr · hkr · commit 78c7b57630a5 · 2018-01-26T11:12:55.000+01:00
diff --git a/PostProcessing/Editor/PostProcessResourceStripper.cs b/PostProcessing/Editor/PostProcessResourceStripper.cs
@@ -103,7 +103,7 @@ private void Apply(BuildTarget target)
                     resources.shaders.scalableAO = null;
             }
 
-            if (stripping.stripUnsupportedShaders && !RuntimeUtilities.supportsMotionVectors)
+            if (stripping.stripUnsupportedShaders && !SystemInfo.supportsMotionVectors)
             {
                 resources.shaders.motionBlur = null;
                 resources.shaders.temporalAntialiasing = null;
diff --git a/PostProcessing/Runtime/Effects/AmbientOcclusion.cs b/PostProcessing/Runtime/Effects/AmbientOcclusion.cs
@@ -71,12 +71,20 @@ public override bool IsEnabledAndSupported(PostProcessRenderContext context)
 
             if (mode.value == AmbientOcclusionMode.ScalableAmbientObscurance)
             {
-                state &= !RuntimeUtilities.scriptableRenderPipelineActive;
+                state &= !RuntimeUtilities.scriptableRenderPipelineActive
+                      && context.resources.shaders.scalableAO
+                      && context.resources.shaders.scalableAO.isSupported;
             }
             else if (mode.value == AmbientOcclusionMode.MultiScaleVolumetricObscurance)
             {
 #if UNITY_2017_1_OR_NEWER
                 state &= SystemInfo.supportsComputeShaders
+                      && context.resources.shaders.multiScaleAO
+                      && context.resources.shaders.multiScaleAO.isSupported
+                      && context.resources.computeShaders.multiScaleAODownsample1
+                      && context.resources.computeShaders.multiScaleAODownsample2
+                      && context.resources.computeShaders.multiScaleAORender
+                      && context.resources.computeShaders.multiScaleAOUpsample
                       && SystemInfo.SupportsRenderTextureFormat(RenderTextureFormat.RFloat)
                       && SystemInfo.SupportsRenderTextureFormat(RenderTextureFormat.RHalf)
                       && SystemInfo.SupportsRenderTextureFormat(RenderTextureFormat.R8);
diff --git a/PostProcessing/Runtime/Effects/AutoExposure.cs b/PostProcessing/Runtime/Effects/AutoExposure.cs
@@ -40,7 +40,10 @@ public override bool IsEnabledAndSupported(PostProcessRenderContext context)
         {
             return enabled.value
                 && SystemInfo.supportsComputeShaders
-                && SystemInfo.SupportsRenderTextureFormat(RenderTextureFormat.RFloat);
+                && SystemInfo.SupportsRenderTextureFormat(RenderTextureFormat.RFloat)
+                && context.resources.shaders.autoExposure
+                && context.resources.shaders.autoExposure.isSupported
+                && context.resources.computeShaders.exposureHistogram;
         }
     }
 
diff --git a/PostProcessing/Runtime/Effects/Fog.cs b/PostProcessing/Runtime/Effects/Fog.cs
@@ -21,6 +21,8 @@ internal bool IsEnabledAndSupported(PostProcessRenderContext context)
             return enabled
                 && RenderSettings.fog
                 && !RuntimeUtilities.scriptableRenderPipelineActive
+                && context.resources.shaders.deferredFog
+                && context.resources.shaders.deferredFog.isSupported
                 && context.camera.actualRenderingPath == RenderingPath.DeferredShading;  // In forward fog is already done at shader level
         }
 
diff --git a/PostProcessing/Runtime/Effects/ScreenSpaceReflections.cs b/PostProcessing/Runtime/Effects/ScreenSpaceReflections.cs
@@ -52,7 +52,10 @@ public override bool IsEnabledAndSupported(PostProcessRenderContext context)
                 && context.camera.actualRenderingPath == RenderingPath.DeferredShading
                 && SystemInfo.supportsMotionVectors
                 && SystemInfo.supportsComputeShaders
-                && SystemInfo.copyTextureSupport > CopyTextureSupport.None;
+                && SystemInfo.copyTextureSupport > CopyTextureSupport.None
+                && context.resources.shaders.screenSpaceReflections
+                && context.resources.shaders.screenSpaceReflections.isSupported
+                && context.resources.computeShaders.gaussianDownsample;
         }
     }
 
diff --git a/PostProcessing/Runtime/Monitors/HistogramMonitor.cs b/PostProcessing/Runtime/Monitors/HistogramMonitor.cs
@@ -53,6 +53,11 @@ internal override bool NeedsHalfRes()
             return true;
         }
 
+        internal override bool ShaderResourcesAvailable(PostProcessRenderContext context)
+        {
+            return context.resources.computeShaders.gammaHistogram;
+        }
+
         internal override void Render(PostProcessRenderContext context)
         {
             CheckOutput(width, height);
diff --git a/PostProcessing/Runtime/Monitors/LightMeterMonitor.cs b/PostProcessing/Runtime/Monitors/LightMeterMonitor.cs
@@ -11,6 +11,11 @@ public sealed class LightMeterMonitor : Monitor
         // Note: only works with HDR grading, as this monitor only makes sense when working in HDR
         public bool showCurves = true;
 
+        internal override bool ShaderResourcesAvailable(PostProcessRenderContext context)
+        {
+            return context.resources.shaders.lightMeter && context.resources.shaders.lightMeter.isSupported;
+        }
+
         internal override void Render(PostProcessRenderContext context)
         {
             CheckOutput(width, height);
diff --git a/PostProcessing/Runtime/Monitors/Monitor.cs b/PostProcessing/Runtime/Monitors/Monitor.cs
@@ -14,12 +14,15 @@ public abstract class Monitor
 
         internal bool requested = false;
 
-        public bool IsRequestedAndSupported()
+        public bool IsRequestedAndSupported(PostProcessRenderContext context)
         {
             return requested
-                && SystemInfo.supportsComputeShaders;
+                && SystemInfo.supportsComputeShaders
+                && ShaderResourcesAvailable(context);
         }
 
+        internal abstract bool ShaderResourcesAvailable(PostProcessRenderContext context);
+
         internal virtual bool NeedsHalfRes()
         {
             return false;
diff --git a/PostProcessing/Runtime/Monitors/VectorscopeMonitor.cs b/PostProcessing/Runtime/Monitors/VectorscopeMonitor.cs
@@ -33,6 +33,11 @@ internal override bool NeedsHalfRes()
             return true;
         }
 
+        internal override bool ShaderResourcesAvailable(PostProcessRenderContext context)
+        {
+            return context.resources.computeShaders.vectorscope;
+        }
+
         internal override void Render(PostProcessRenderContext context)
         {
             CheckOutput(size, size);
diff --git a/PostProcessing/Runtime/Monitors/WaveformMonitor.cs b/PostProcessing/Runtime/Monitors/WaveformMonitor.cs
@@ -45,6 +45,12 @@ internal override bool NeedsHalfRes()
             return true;
         }
 
+
+        internal override bool ShaderResourcesAvailable(PostProcessRenderContext context)
+        {
+            return context.resources.computeShaders.waveform;
+        }
+
         internal override void Render(PostProcessRenderContext context)
         {
             // Waveform show localized data, so width depends on the aspect ratio
diff --git a/PostProcessing/Runtime/PostProcessDebugLayer.cs b/PostProcessing/Runtime/PostProcessDebugLayer.cs
@@ -164,7 +164,7 @@ internal void RenderMonitors(PostProcessRenderContext context)
 
             foreach (var kvp in m_Monitors)
             {
-                bool active = kvp.Value.IsRequestedAndSupported();
+                bool active = kvp.Value.IsRequestedAndSupported(context);
                 anyActive |= active;
                 needsHalfRes |= active && kvp.Value.NeedsHalfRes();
             }
diff --git a/PostProcessing/Runtime/PostProcessLayer.cs b/PostProcessing/Runtime/PostProcessLayer.cs
@@ -940,7 +940,7 @@ int RenderEffect<T>(PostProcessRenderContext context, bool useTempTarget = false
         bool ShouldGenerateLogHistogram(PostProcessRenderContext context)
         {
             bool autoExpo = GetBundle<AutoExposure>().settings.IsEnabledAndSupported(context);
-            bool lightMeter = debugLayer.lightMeter.IsRequestedAndSupported();
+            bool lightMeter = debugLayer.lightMeter.IsRequestedAndSupported(context);
             return autoExpo || lightMeter;
         }
     }
diff --git a/PostProcessing/Runtime/Utils/RuntimeUtilities.cs b/PostProcessing/Runtime/Utils/RuntimeUtilities.cs
@@ -231,11 +231,6 @@ public static bool supportsDeferredShading
             get { return scriptableRenderPipelineActive || GraphicsSettings.GetShaderMode(BuiltinShaderType.DeferredShading) != BuiltinShaderMode.Disabled; }
         }
 
-        public static bool supportsMotionVectors
-        {
-            get { return scriptableRenderPipelineActive || GraphicsSettings.GetShaderMode(BuiltinShaderType.MotionVectors) != BuiltinShaderMode.Disabled; }
-        }
-
         public static bool supportsDepthNormals
         {
             get { return scriptableRenderPipelineActive || GraphicsSettings.GetShaderMode(BuiltinShaderType.DepthNormals) != BuiltinShaderMode.Disabled; }

Original file line number	Diff line number	Diff line change
`@@ -103,7 +103,7 @@ private void Apply(BuildTarget target)`
`103`	`103`	`resources.shaders.scalableAO = null;`
`104`	`104`	`}`
`105`	`105`
`106`		`- if (stripping.stripUnsupportedShaders && !RuntimeUtilities.supportsMotionVectors)`
	`106`	`+ if (stripping.stripUnsupportedShaders && !SystemInfo.supportsMotionVectors)`
`107`	`107`	`{`
`108`	`108`	`resources.shaders.motionBlur = null;`
`109`	`109`	`resources.shaders.temporalAntialiasing = null;`
Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,10 @@ public override bool IsEnabledAndSupported(PostProcessRenderContext context)`
`40`	`40`	`{`
`41`	`41`	`return enabled.value`
`42`	`42`	`&& SystemInfo.supportsComputeShaders`
`43`		`- && SystemInfo.SupportsRenderTextureFormat(RenderTextureFormat.RFloat);`
	`43`	`+ && SystemInfo.SupportsRenderTextureFormat(RenderTextureFormat.RFloat)`
	`44`	`+ && context.resources.shaders.autoExposure`
	`45`	`+ && context.resources.shaders.autoExposure.isSupported`
	`46`	`+ && context.resources.computeShaders.exposureHistogram;`
`44`	`47`	`}`
`45`	`48`	`}`
`46`	`49`
Original file line number	Diff line number	Diff line change
`@@ -21,6 +21,8 @@ internal bool IsEnabledAndSupported(PostProcessRenderContext context)`
`21`	`21`	`return enabled`
`22`	`22`	`&& RenderSettings.fog`
`23`	`23`	`&& !RuntimeUtilities.scriptableRenderPipelineActive`
	`24`	`+ && context.resources.shaders.deferredFog`
	`25`	`+ && context.resources.shaders.deferredFog.isSupported`
`24`	`26`	`&& context.camera.actualRenderingPath == RenderingPath.DeferredShading; // In forward fog is already done at shader level`
`25`	`27`	`}`
`26`	`28`
Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,10 @@ public override bool IsEnabledAndSupported(PostProcessRenderContext context)`
`52`	`52`	`&& context.camera.actualRenderingPath == RenderingPath.DeferredShading`
`53`	`53`	`&& SystemInfo.supportsMotionVectors`
`54`	`54`	`&& SystemInfo.supportsComputeShaders`
`55`		`- && SystemInfo.copyTextureSupport > CopyTextureSupport.None;`
	`55`	`+ && SystemInfo.copyTextureSupport > CopyTextureSupport.None`
	`56`	`+ && context.resources.shaders.screenSpaceReflections`
	`57`	`+ && context.resources.shaders.screenSpaceReflections.isSupported`
	`58`	`+ && context.resources.computeShaders.gaussianDownsample;`
`56`	`59`	`}`
`57`	`60`	`}`
`58`	`61`
Original file line number	Diff line number	Diff line change
`@@ -53,6 +53,11 @@ internal override bool NeedsHalfRes()`
`53`	`53`	`return true;`
`54`	`54`	`}`
`55`	`55`
	`56`	`+ internal override bool ShaderResourcesAvailable(PostProcessRenderContext context)`
	`57`	`+ {`
	`58`	`+ return context.resources.computeShaders.gammaHistogram;`
	`59`	`+ }`
	`60`	`+`
`56`	`61`	`internal override void Render(PostProcessRenderContext context)`
`57`	`62`	`{`
`58`	`63`	`CheckOutput(width, height);`
Original file line number	Diff line number	Diff line change
`@@ -14,12 +14,15 @@ public abstract class Monitor`
`14`	`14`
`15`	`15`	`internal bool requested = false;`
`16`	`16`
`17`		`- public bool IsRequestedAndSupported()`
	`17`	`+ public bool IsRequestedAndSupported(PostProcessRenderContext context)`
`18`	`18`	`{`
`19`	`19`	`return requested`
`20`		`- && SystemInfo.supportsComputeShaders;`
	`20`	`+ && SystemInfo.supportsComputeShaders`
	`21`	`+ && ShaderResourcesAvailable(context);`
`21`	`22`	`}`
`22`	`23`
	`24`	`+ internal abstract bool ShaderResourcesAvailable(PostProcessRenderContext context);`
	`25`	`+`
`23`	`26`	`internal virtual bool NeedsHalfRes()`
`24`	`27`	`{`
`25`	`28`	`return false;`
Original file line number	Diff line number	Diff line change
`@@ -33,6 +33,11 @@ internal override bool NeedsHalfRes()`
`33`	`33`	`return true;`
`34`	`34`	`}`
`35`	`35`
	`36`	`+ internal override bool ShaderResourcesAvailable(PostProcessRenderContext context)`
	`37`	`+ {`
	`38`	`+ return context.resources.computeShaders.vectorscope;`
	`39`	`+ }`
	`40`	`+`
`36`	`41`	`internal override void Render(PostProcessRenderContext context)`
`37`	`42`	`{`
`38`	`43`	`CheckOutput(size, size);`
Original file line number	Diff line number	Diff line change
`@@ -45,6 +45,12 @@ internal override bool NeedsHalfRes()`
`45`	`45`	`return true;`
`46`	`46`	`}`
`47`	`47`
	`48`	`+`
	`49`	`+ internal override bool ShaderResourcesAvailable(PostProcessRenderContext context)`
	`50`	`+ {`
	`51`	`+ return context.resources.computeShaders.waveform;`
	`52`	`+ }`
	`53`	`+`
`48`	`54`	`internal override void Render(PostProcessRenderContext context)`
`49`	`55`	`{`
`50`	`56`	`// Waveform show localized data, so width depends on the aspect ratio`