Add the very low and ultra quality.

The VERY_LOW quality shader now only takes the midpoint plus 2 extra samples.
The High and ULTRA quality settings now have a shader that samples in 3 or 4 rings.

Author: jon1solution

drivers/gles3/effects/post_effects.cpp

@@ -107,10 +107,14 @@ void PostEffects::post_copy(
 		flags |= PostShaderGLES3::USE_GLOW;
 	}
 	if (p_ssao_enabled) {
-		if (p_ssao_quality_level <= RS::ENV_SSAO_QUALITY_LOW) {
+		if (p_ssao_quality_level == RS::ENV_SSAO_QUALITY_VERY_LOW) {
+			flags |= PostShaderGLES3::USE_SSAO_ABYSS;
+		} else if (p_ssao_quality_level == RS::ENV_SSAO_QUALITY_LOW) {
 			flags |= PostShaderGLES3::USE_SSAO_LOW;
-		} else if (p_ssao_quality_level >= RS::ENV_SSAO_QUALITY_HIGH) {
+		} else if (p_ssao_quality_level == RS::ENV_SSAO_QUALITY_HIGH) {
 			flags |= PostShaderGLES3::USE_SSAO_HIGH;
+		} else if (p_ssao_quality_level == RS::ENV_SSAO_QUALITY_ULTRA) {
+			flags |= PostShaderGLES3::USE_SSAO_MEGA;
 		} else {
 			flags |= PostShaderGLES3::USE_SSAO_MED;
 		}

drivers/gles3/shaders/effects/post.glsl

@@ -10,9 +10,11 @@ USE_LUMINANCE_MULTIPLIER = false
 USE_BCS = false
 USE_COLOR_CORRECTION = false
 USE_1D_LUT = false
+USE_SSAO_ABYSS = false
 USE_SSAO_LOW = false
 USE_SSAO_MED = false
 USE_SSAO_HIGH = false
+USE_SSAO_MEGA = false
 
 #[vertex]
 layout(location = 0) in vec2 vertex_attrib;
@@ -94,7 +96,8 @@ vec3 apply_bcs(vec3 color) {
 }
 #endif
 
-#if defined(USE_SSAO_LOW) || defined(USE_SSAO_MED) || defined(USE_SSAO_HIGH)
+#if defined(USE_SSAO_ABYSS) || defined(USE_SSAO_LOW) || defined(USE_SSAO_MED) || defined(USE_SSAO_HIGH) || defined(USE_SSAO_MEGA)
+#define USE_SOME_SSAO
 uniform float ssao_intensity;
 uniform float ssao_radius_frac;
 uniform vec2 ssao_prn_UV;
@@ -104,8 +107,17 @@ uniform sampler2DArray depth_buffer_array; // texunit:3
 #else
 uniform sampler2D depth_buffer; // texunit:3
 #endif
+#if defined(USE_SSAO_ABYSS)
+// Use the tiny 2-sample version.
+#include "../s4ao_micro_inc.glsl"
+#elif defined(USE_SSAO_HIGH) || defined(USE_SSAO_MEGA)
+// Use the rings version for the higher qualities.
+#include "../s4ao_mega_inc.glsl"
+#else
+// Use the more generic NxN grid version.
 #include "../s4ao_inc.glsl"
 #endif
+#endif
 
 in vec2 uv_interp;
 
@@ -134,7 +146,7 @@ void main() {
 
 	color.rgb = srgb_to_linear(color.rgb);
 
-#if defined(USE_SSAO_LOW) || defined(USE_SSAO_MED) || defined(USE_SSAO_HIGH)
+#if defined(USE_SOME_SSAO)
 	// Putting SSAO after the conversion to linear color, though it might be better before the glow.
 	color.rgb *= s4ao(uv_interp); // The USE_SSAO_X controls the number of samples.
 #endif

drivers/gles3/shaders/s4ao_mega_inc.glsl

@@ -0,0 +1,50 @@
+// S4AO (Stupid Simple Screen Space Ambient Occlusion) - Jonathan Dummer (O1S)
+// The mega version uses N concentric rings of samples.
+
+#if defined(USE_SSAO_MEGA)
+const int rings = 4; // Start with the outer ring.
+const int samps[] = int[](24, 18, 12, 6); // ( 9, 6, 3 ) is a minimum, but I want better.
+#else
+const int rings = 3; // Start with the outer ring.
+const int samps[] = int[](15, 10, 5, 1); // ( 9, 6, 3 ) is a minimum, but I want better.
+#endif
+const float average_samples = 1.0 / float(samps[0] + samps[1] * int(rings > 1) + samps[2] * int(rings > 2) + samps[3] * int(rings > 3));
+const float ssao_falloff_frac = 0.25;
+// Perform the SSAO.
+float s4ao(vec2 UV) {
+#ifdef USE_MULTIVIEW
+	float depth = texture(depth_buffer_array, vec3(UV, view)).r;
+#else
+	float depth = texture(depth_buffer, UV).r;
+#endif
+	float inv_falloff = 1.0f / max(1e-4f, depth * ssao_falloff_frac);
+	// Random 2D rotation per pixel (0..1 -> parabola approximating a 180 deg arc)
+	float r01 = fract(dot(UV, ssao_prn_UV));
+	vec2 rcos = vec2(r01 - 0.5f, 2.0f * (r01 - r01 * r01)) * (2.0f * depth * ssao_radius_frac); // 180 degrees.
+	vec2 rsin = rcos.yx * vec2(-1, 1); // Perpendicular to the random cosine vector.
+	// Grab the samples and determine the occlusion.
+	float occlusion = 0.0f;
+	float ring_shrink = 0.75f; // Shrink every ring.
+	for (int r = 0; r < rings; ++r) {
+		float dt = (6.283185307f) / float(samps[r]);
+		float t = float(r & 1) * 0.5f * dt;
+		for (int s = 0; s < samps[r]; ++s) {
+			vec2 duv = cos(t) * rcos + sin(t) * rsin;
+#ifdef USE_MULTIVIEW
+			float dz = texture(depth_buffer_array, vec3(UV + duv, view)).r - depth;
+#else
+			float dz = texture(depth_buffer, UV + duv).r - depth;
+#endif
+			// How 'directly overhead' is it?  Factor in the falloff depth.
+			occlusion += normalize(vec3(duv, dz)).z * smoothstep(1.0f, 0.0f, dz * inv_falloff);
+			t += dt;
+		}
+		// The next ring will be smaller.
+		rcos *= ring_shrink;
+		rsin *= ring_shrink;
+	}
+	// Adjust the occlusion for intensity, and # samples.
+	occlusion *= ssao_intensity * average_samples;
+	occlusion = 1.0f - clamp(occlusion, 0.0f, 1.0f);
+	return occlusion * occlusion;
+}

drivers/gles3/shaders/s4ao_micro_inc.glsl

@@ -0,0 +1,32 @@
+// S4AO (Stupid Simple Screen Space Ambient Occlusion) - Jonathan Dummer (O1S)
+// This micro version uses only 3 depth samples, the midpoint and a randomly-rotated, balanced pair.
+
+const mediump float ssao_falloff_frac = 0.25;
+// Perform the SSAO.
+float s4ao(vec2 UV) {
+#ifdef USE_MULTIVIEW
+	mediump float depth = texture(depth_buffer_array, vec3(UV, view)).r;
+#else
+	mediump float depth = texture(depth_buffer, UV).r;
+#endif
+	mediump float inv_falloff = 1.0f / max(1e-4f, depth * ssao_falloff_frac);
+	// Random 2D rotation per pixel (0..1 -> parabola approximating a 180 deg arc)
+	mediump float r01 = fract(dot(UV, ssao_prn_UV));
+	mediump vec2 duv = vec2(r01 - 0.5f, 2.0f * (r01 - r01 * r01)) * (2.0f * depth * ssao_radius_frac); // 180 degrees.
+	// Grab the samples and determine the occlusion.
+	mediump float occlusion = 0.0f;
+	for (int s = 0; s < 2; ++s) {
+#ifdef USE_MULTIVIEW
+		mediump float dz = texture(depth_buffer_array, vec3(UV + duv, view)).r - depth;
+#else
+		mediump float dz = texture(depth_buffer, UV + duv).r - depth;
+#endif
+		// How 'directly overhead' is it?  Factor in the falloff depth.
+		occlusion += normalize(vec3(duv, dz)).z * mix(1.0f, 0.0f, dz * inv_falloff);
+		// Mirror the next sample.
+		duv = -duv;
+	}
+	// Adjust the occlusion for intensity, and # samples.
+	occlusion = 1.0f - clamp(occlusion * 0.5f * ssao_intensity, 0.0f, 1.0f);
+	return occlusion * occlusion;
+}