Merge pull request #3005 from secondlife/rye/postperf

Reduce number of full screen copies during renderFinalize

Author: Rye

indra/newview/CMakeLists.txt

@@ -1686,6 +1686,7 @@ set(viewer_APPSETTINGS_FILES
     packages-info.txt
     featuretable.txt
     featuretable_mac.txt
+    featuretable_linux.txt
     )
 
 source_group("App Settings" FILES ${viewer_APPSETTINGS_FILES})

indra/newview/app_settings/settings.xml

@@ -10080,6 +10080,17 @@
       <key>Value</key>
       <string>00000000-0000-0000-0000-000000000000</string>
     </map>
+    <key>RenderCAS</key>
+    <map>
+        <key>Comment</key>
+        <string>Use Contrast Adaptive Sharpening post process effect</string>
+        <key>Persist</key>
+        <integer>0</integer>
+        <key>Type</key>
+        <string>Boolean</string>
+        <key>Value</key>
+        <integer>1</integer>
+    </map>
     <key>RenderCASSharpness</key>
     <map>
         <key>Comment</key>

indra/newview/app_settings/shaders/class1/deferred/CASF.glsl

@@ -38,6 +38,7 @@ uniform sampler2D diffuseRect;
 uniform vec2 out_screen_res;
 uniform uvec4 cas_param_0;
 uniform uvec4 cas_param_1;
+uniform float gamma;
 
 vec3 srgb_to_linear(vec3 cs);
 vec3 linear_to_srgb(vec3 cl);
@@ -2545,11 +2546,69 @@ A_STATIC void CasSetup(
 #endif
 
 #ifdef A_GPU
+
+//=================================
+// borrowed noise from:
+//  <https://www.shadertoy.com/view/4dS3Wd>
+//  By Morgan McGuire @morgan3d, http://graphicscodex.com
+//
+float hash(float n) { return fract(sin(n) * 1e4); }
+float hash(vec2 p) { return fract(1e4 * sin(17.0 * p.x + p.y * 0.1) * (0.1 + abs(sin(p.y * 13.0 + p.x)))); }
+
+float noise(float x) {
+    float i = floor(x);
+    float f = fract(x);
+    float u = f * f * (3.0 - 2.0 * f);
+    return mix(hash(i), hash(i + 1.0), u);
+}
+
+float noise(vec2 x) {
+    vec2 i = floor(x);
+    vec2 f = fract(x);
+
+    // Four corners in 2D of a tile
+    float a = hash(i);
+    float b = hash(i + vec2(1.0, 0.0));
+    float c = hash(i + vec2(0.0, 1.0));
+    float d = hash(i + vec2(1.0, 1.0));
+
+    // Simple 2D lerp using smoothstep envelope between the values.
+    // return vec3(mix(mix(a, b, smoothstep(0.0, 1.0, f.x)),
+    //          mix(c, d, smoothstep(0.0, 1.0, f.x)),
+    //          smoothstep(0.0, 1.0, f.y)));
+
+    // Same code, with the clamps in smoothstep and common subexpressions
+    // optimized away.
+    vec2 u = f * f * (3.0 - 2.0 * f);
+    return mix(a, b, u.x) + (c - a) * u.y * (1.0 - u.x) + (d - b) * u.x * u.y;
+}
+
+//===============================================================
+
+vec3 legacyGamma(vec3 color)
+{
+    vec3 c = 1. - clamp(color, vec3(0.), vec3(1.));
+    c = 1. - pow(c, vec3(gamma)); // s/b inverted already CPU-side
+
+    return c;
+}
+
 void main()
 {
     vec4 diff = vec4(0.f);
     uvec2 point = uvec2(vary_fragcoord * out_screen_res.xy);
     CasFilter(diff.r, diff.g, diff.b, point, cas_param_0, cas_param_1, true);
+    diff.rgb = linear_to_srgb(diff.rgb);
+
+#ifdef LEGACY_GAMMA
+    diff.rgb = legacyGamma(diff.rgb);
+#endif
+
+    vec2 tc = vary_fragcoord.xy*out_screen_res.xy*4.0;
+    vec3 seed = (diff.rgb+vec3(1.0))*vec3(tc.xy, tc.x+tc.y);
+    vec3 nz = vec3(noise(seed.rg), noise(seed.gb), noise(seed.rb));
+    diff.rgb += nz*0.003;
+
     diff.a = texture(diffuseRect, vary_fragcoord).a;
     frag_color = diff;
 }

indra/newview/app_settings/shaders/class1/deferred/SMAANeighborhoodBlendF.glsl

@@ -31,10 +31,12 @@ in vec2 vary_texcoord0;
 in vec4 vary_offset;
 
 uniform sampler2D diffuseRect;
+uniform sampler2D emissiveRect;
 uniform sampler2D blendTex;
 #if SMAA_REPROJECTION
 uniform sampler2D velocityTex;
 #endif
+uniform sampler2D depthMap;
 
 #define float4 vec4
 #define float2 vec2
@@ -51,13 +53,19 @@ float4 SMAANeighborhoodBlendingPS(float2 texcoord,
 
 void main()
 {
-    frag_color = SMAANeighborhoodBlendingPS(vary_texcoord0,
+    vec4 diff = SMAANeighborhoodBlendingPS(vary_texcoord0,
                                             vary_offset,
                                             diffuseRect,
                                             blendTex
                                             #if SMAA_REPROJECTION
                                             , velocityTex
                                             #endif
                                             );
+#ifndef NO_GLOW
+    diff.rgb += texture2D(emissiveRect, vary_texcoord0).rgb;
+#endif
+    frag_color = diff;
+
+    gl_FragDepth = texture(depthMap, vary_texcoord0.xy).r;
 }
 

indra/newview/app_settings/shaders/class1/deferred/cofF.glsl

@@ -29,6 +29,7 @@ out vec4 frag_color;
 
 uniform sampler2D diffuseRect;
 uniform sampler2D depthMap;
+uniform sampler2D emissiveRect;
 
 uniform float focal_distance;
 uniform float blur_constant;
@@ -66,12 +67,13 @@ void main()
     vec4 p = inv_proj*ndc;
     float depth = p.z/p.w;
 
-    vec4 diff = texture(diffuseRect, vary_fragcoord.xy);
+    vec4 diff = texture(diffuseRect, tc);
 
     float sc = calc_cof(depth);
     sc = min(sc, max_cof);
     sc = max(sc, -max_cof);
 
-    frag_color.rgb = diff.rgb;
+    vec4 bloom = texture2D(emissiveRect, tc);
+    frag_color.rgb = diff.rgb + bloom.rgb;
     frag_color.a = sc/max_cof*0.5+0.5;
 }

indra/newview/app_settings/shaders/class1/deferred/postDeferredGammaCorrect.glsl

@@ -30,60 +30,12 @@ out vec4 frag_color;
 uniform sampler2D diffuseRect;
 uniform sampler2D depthMap;
 
-uniform vec2 screen_res;
 in vec2 vary_fragcoord;
 
-//=================================
-// borrowed noise from:
-//  <https://www.shadertoy.com/view/4dS3Wd>
-//  By Morgan McGuire @morgan3d, http://graphicscodex.com
-//
-float hash(float n) { return fract(sin(n) * 1e4); }
-float hash(vec2 p) { return fract(1e4 * sin(17.0 * p.x + p.y * 0.1) * (0.1 + abs(sin(p.y * 13.0 + p.x)))); }
-
-float noise(float x) {
-    float i = floor(x);
-    float f = fract(x);
-    float u = f * f * (3.0 - 2.0 * f);
-    return mix(hash(i), hash(i + 1.0), u);
-}
-
-float noise(vec2 x) {
-    vec2 i = floor(x);
-    vec2 f = fract(x);
-
-    // Four corners in 2D of a tile
-    float a = hash(i);
-    float b = hash(i + vec2(1.0, 0.0));
-    float c = hash(i + vec2(0.0, 1.0));
-    float d = hash(i + vec2(1.0, 1.0));
-
-    // Simple 2D lerp using smoothstep envelope between the values.
-    // return vec3(mix(mix(a, b, smoothstep(0.0, 1.0, f.x)),
-    //          mix(c, d, smoothstep(0.0, 1.0, f.x)),
-    //          smoothstep(0.0, 1.0, f.y)));
-
-    // Same code, with the clamps in smoothstep and common subexpressions
-    // optimized away.
-    vec2 u = f * f * (3.0 - 2.0 * f);
-    return mix(a, b, u.x) + (c - a) * u.y * (1.0 - u.x) + (d - b) * u.x * u.y;
-}
-
-//=============================
-
-
-
 void main()
 {
     vec4 diff = texture(diffuseRect, vary_fragcoord.xy);
 
-#ifdef HAS_NOISE
-    vec2 tc = vary_fragcoord.xy*screen_res*4.0;
-    vec3 seed = (diff.rgb+vec3(1.0))*vec3(tc.xy, tc.x+tc.y);
-    vec3 nz = vec3(noise(seed.rg), noise(seed.gb), noise(seed.rb));
-    diff.rgb += nz*0.003;
-#endif
-
     frag_color = diff;
 
     gl_FragDepth = texture(depthMap, vary_fragcoord.xy).r;

indra/newview/app_settings/shaders/class1/deferred/postDeferredNoDoFF.glsl

@@ -30,6 +30,7 @@ out vec4 frag_color;
 uniform sampler2D diffuseRect;
 uniform sampler2D exposureMap;
 
+uniform float gamma;
 uniform vec2 screen_res;
 in vec2 vary_fragcoord;
 
@@ -149,6 +150,42 @@ vec3 toneMap(vec3 color)
     return color;
 }
 
+//=================================
+// borrowed noise from:
+//  <https://www.shadertoy.com/view/4dS3Wd>
+//  By Morgan McGuire @morgan3d, http://graphicscodex.com
+//
+float hash(float n) { return fract(sin(n) * 1e4); }
+float hash(vec2 p) { return fract(1e4 * sin(17.0 * p.x + p.y * 0.1) * (0.1 + abs(sin(p.y * 13.0 + p.x)))); }
+
+float noise(float x) {
+    float i = floor(x);
+    float f = fract(x);
+    float u = f * f * (3.0 - 2.0 * f);
+    return mix(hash(i), hash(i + 1.0), u);
+}
+
+float noise(vec2 x) {
+    vec2 i = floor(x);
+    vec2 f = fract(x);
+
+    // Four corners in 2D of a tile
+    float a = hash(i);
+    float b = hash(i + vec2(1.0, 0.0));
+    float c = hash(i + vec2(0.0, 1.0));
+    float d = hash(i + vec2(1.0, 1.0));
+
+    // Simple 2D lerp using smoothstep envelope between the values.
+    // return vec3(mix(mix(a, b, smoothstep(0.0, 1.0, f.x)),
+    //          mix(c, d, smoothstep(0.0, 1.0, f.x)),
+    //          smoothstep(0.0, 1.0, f.y)));
+
+    // Same code, with the clamps in smoothstep and common subexpressions
+    // optimized away.
+    vec2 u = f * f * (3.0 - 2.0 * f);
+    return mix(a, b, u.x) + (c - a) * u.y * (1.0 - u.x) + (d - b) * u.x * u.y;
+}
+
 //===============================================================
 
 void debugExposure(inout vec3 color)
@@ -161,16 +198,40 @@ void debugExposure(inout vec3 color)
     }
 }
 
+vec3 legacyGamma(vec3 color)
+{
+    vec3 c = 1. - clamp(color, vec3(0.), vec3(1.));
+    c = 1. - pow(c, vec3(gamma)); // s/b inverted already CPU-side
+
+    return c;
+}
+
 void main()
 {
     //this is the one of the rare spots where diffuseRect contains linear color values (not sRGB)
     vec4 diff = texture(diffuseRect, vary_fragcoord);
 
+#ifdef TONEMAP
 #ifndef NO_POST
     diff.rgb = toneMap(diff.rgb);
-#else
+#endif
+#ifndef GAMMA_CORRECT
     diff.rgb = clamp(diff.rgb, vec3(0.0), vec3(1.0));
 #endif
+#endif
+
+#ifdef GAMMA_CORRECT
+    diff.rgb = linear_to_srgb(diff.rgb);
+
+#ifdef LEGACY_GAMMA
+    diff.rgb = legacyGamma(diff.rgb);
+#endif
+
+    vec2 tc = vary_fragcoord.xy*screen_res*4.0;
+    vec3 seed = (diff.rgb+vec3(1.0))*vec3(tc.xy, tc.x+tc.y);
+    vec3 nz = vec3(noise(seed.rg), noise(seed.gb), noise(seed.rb));
+    diff.rgb += nz*0.003;
+#endif
 
     //debugExposure(diff.rgb);
     frag_color = max(diff, vec4(0));

indra/newview/app_settings/shaders/class1/deferred/postDeferredTonemap.glsl

@@ -29,10 +29,12 @@ out vec4 frag_color;
 
 uniform sampler2D diffuseRect;
 uniform sampler2D emissiveRect;
+uniform sampler2D depthMap;
 
 in vec2 tc;
 
 void main()
 {
     frag_color = texture(diffuseRect, tc) + texture(emissiveRect, tc);
+    gl_FragDepth = texture(depthMap, tc.xy).r;
 }