gpu: Implement GL_INTEL_framebuffer_CMAA via shaders in the GPU Service

gpu/command_buffer/service/gles2_cmd_apply_framebuffer_attachment_cmaa_intel.cc

Index: gpu/command_buffer/service/gles2_cmd_apply_framebuffer_attachment_cmaa_intel.cc
diff --git a/gpu/command_buffer/service/gles2_cmd_apply_framebuffer_attachment_cmaa_intel.cc b/gpu/command_buffer/service/gles2_cmd_apply_framebuffer_attachment_cmaa_intel.cc
new file mode 100644
index 0000000000000000000000000000000000000000..2e499d63ddffd9ac02605b7d0f5afcfe93334598
--- /dev/null
+++ b/gpu/command_buffer/service/gles2_cmd_apply_framebuffer_attachment_cmaa_intel.cc
@@ -0,0 +1,1823 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "gpu/command_buffer/service/gles2_cmd_apply_framebuffer_attachment_cmaa_intel.h"
+
+#include "base/logging.h"
+#include "gpu/command_buffer/service/gles2_cmd_decoder.h"
+#include "ui/gl/gl_gl_api_implementation.h"
+#include "ui/gl/gl_version_info.h"
+
+namespace gpu {
+
+ApplyFramebufferAttachmentCMAAINTELResourceManager::
+    ApplyFramebufferAttachmentCMAAINTELResourceManager()
+    : initialized_(false),
+      textures_initialized_(false),
+      is_in_gamma_correct_mode_(false),
+      supports_usampler_(true),
+      supports_r8_image_(true),
+      supports_r8_read_format_(true),
+      is_gles31_compatible(false),
+      frame_id_(0),
+      width_(0),
+      height_(0),
+      copy_to_framebuffer_shader_(0),
+      copy_to_image_shader_(0),
+      edges0_shader_(0),
+      edges1_shader_(0),
+      edges_combine_shader_(0),
+      process_and_apply_shader_(0),
+      debug_display_edges_shader_(0),
+      cmaa_framebuffer_(0),
+      copy_framebuffer_(0),
+      rgba8_texture_(0),
+      working_color_texture_(0),
+      edges0_texture_(0),
+      edges1_texture_(0),
+      mini4_edge_texture_(0),
+      mini4_edge_depth_texture_(0),
+      edges1_shader_result_texture_float4_slot1_(0),
+      edges1_shader_result_texture_(0),
+      edges_combine_shader_result_texture_float4_slot1_(0),
+      process_and_apply_shader_result_texture_float4_slot1_(0),
+      edges_combine_shader_result_texture_slot2_(0),
+      copy_to_image_shader_outTexture_(0) {}
+
+ApplyFramebufferAttachmentCMAAINTELResourceManager::
+    ~ApplyFramebufferAttachmentCMAAINTELResourceManager() {
+  Destroy();
+}
+
+void ApplyFramebufferAttachmentCMAAINTELResourceManager::Initialize(
+    const gles2::GLES2Decoder* decoder) {
+  is_gles31_compatible = gl::GetGLVersionInfo()->IsAtLeastGLES(3, 1);
+
+  glGenFramebuffersEXT(1, &copy_framebuffer_);
+  glGenTextures(1, &rgba8_texture_);
+
+  copy_to_image_shader_ = CreateProgram("", vert_str_, copy_frag_str_);
+  copy_to_framebuffer_shader_ =
+      CreateProgram("#define OUT_FBO 1\n", vert_str_, copy_frag_str_);
+
+  // Check if RGBA8UI is supported as an FBO colour target with depth.
+  // If not supported, GLSL needs to convert the data to/from float so there is
+  // a small extra cost.
+  {
+    GLuint rgba8ui_texture = 0, depth_texture = 0;
+    glGenTextures(1, &rgba8ui_texture);
+    glBindTexture(GL_TEXTURE_2D, rgba8ui_texture);
+    glTexStorage2DEXT(GL_TEXTURE_2D, 1, GL_RGBA8UI, 4, 4);
+
+    glGenTextures(1, &depth_texture);
+    glBindTexture(GL_TEXTURE_2D, depth_texture);
+    glTexStorage2DEXT(GL_TEXTURE_2D, 1, GL_DEPTH_COMPONENT16, 4, 4);
+
+    // Create the FBO
+    GLuint rgba8ui_framebuffer = 0;
+    glGenFramebuffersEXT(1, &rgba8ui_framebuffer);
+    glBindFramebufferEXT(GL_FRAMEBUFFER, rgba8ui_framebuffer);
+
+    // Bind to the FBO to test support
+    glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
+                              GL_TEXTURE_2D, rgba8ui_texture, 0);
+    glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
+                              GL_TEXTURE_2D, depth_texture, 0);
+    GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER);
+
+    supports_usampler_ = (status == GL_FRAMEBUFFER_COMPLETE);
+
+    glDeleteFramebuffersEXT(1, &rgba8ui_framebuffer);
+    glDeleteTextures(1, &rgba8ui_texture);
+    glDeleteTextures(1, &depth_texture);
+  }
+
+  // Check to see if R8 images are supported
+  // If not supported, images are bound as R32F for write targets, not R8.
+  {
+    GLuint r8_texture = 0;
+    glGenTextures(1, &r8_texture);
+    glBindTexture(GL_TEXTURE_2D, r8_texture);
+    glTexStorage2DEXT(GL_TEXTURE_2D, 1, GL_R8, 4, 4);
+
+    glGetError();  // reset all previous errors
+    glBindImageTextureEXT(0, r8_texture, 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_R8);
+    if (glGetError() != GL_NO_ERROR)
+      supports_r8_image_ = false;
+
+    glDeleteTextures(1, &r8_texture);
+  }
+
+  // Check if R8 GLSL read formats are supported.
+  // If not supported, r32f is used instead.
+  {
+    const char* shader_source =
+        "layout(r8) restrict writeonly uniform highp image2D g_r8Image;     \n"
+        "void main()                                                        \n"
+        "{                                                                  \n"
+        "    imageStore(g_r8Image, ivec2(0, 0), vec4(1.0, 0.0, 0.0, 0.0));  \n"
+        "}                                                                  \n";
+
+    GLuint shader = CreateShader(GL_FRAGMENT_SHADER, "", shader_source);
+    supports_r8_read_format_ = (shader != 0);
+    if (shader != 0) {
+      glDeleteShader(shader);
+    }
+  }
+
+  VLOG(1) << "ApplyFramebufferAttachmentCMAAINTEL: "
+          << "Supports USampler is " << (supports_usampler_ ? "true" : "false");
+  VLOG(1) << "ApplyFramebufferAttachmentCMAAINTEL: "
+          << "Supports R8 Images is "
+          << (supports_r8_image_ ? "true" : "false");
+  VLOG(1) << "ApplyFramebufferAttachmentCMAAINTEL: "
+          << "Supports R8 Read Format is "
+          << (supports_r8_read_format_ ? "true" : "false");
+
+  // Create the shaders
+  std::ostringstream defines, edge1, edge2, combineEdges, blur, displayEdges;
+
+  if (supports_usampler_) {
+    defines << "#define SUPPORTS_USAMPLER2D\n";
+  }
+
+  if (is_in_gamma_correct_mode_) {
+    defines << "#define IN_GAMMA_CORRECT_MODE\n";
+  }
+
+  if (supports_r8_read_format_) {
+    defines << "#define EDGE_READ_FORMAT r8\n";
+  } else {
+    defines << "#define EDGE_READ_FORMAT r32f\n";
+  }
+
+  displayEdges << defines.str() << "#define DISPLAY_EDGES\n";
+  debug_display_edges_shader_ =
+      CreateProgram(displayEdges.str().c_str(), vert_str_, cmaa_frag_str_);
+
+  edge1 << defines.str() << "#define DETECT_EDGES1\n";
+  edges0_shader_ =
+      CreateProgram(edge1.str().c_str(), vert_str_, cmaa_frag_str_);
+
+  edge2 << defines.str() << "#define DETECT_EDGES2\n";
+  edges1_shader_ =
+      CreateProgram(edge2.str().c_str(), vert_str_, cmaa_frag_str_);
+
+  combineEdges << defines.str() << "#define COMBINE_EDGES\n";
+  edges_combine_shader_ =
+      CreateProgram(combineEdges.str().c_str(), vert_str_, cmaa_frag_str_);
+
+  blur << defines.str() << "#define BLUR_EDGES\n";
+  process_and_apply_shader_ =
+      CreateProgram(blur.str().c_str(), vert_str_, cmaa_frag_str_);
+
+  edges1_shader_result_texture_float4_slot1_ =
+      glGetUniformLocation(edges0_shader_, "g_resultTextureFlt4Slot1");
+  edges1_shader_result_texture_ =
+      glGetUniformLocation(edges1_shader_, "g_resultTexture");
+  edges_combine_shader_result_texture_float4_slot1_ =
+      glGetUniformLocation(edges_combine_shader_, "g_resultTextureFlt4Slot1");
+  edges_combine_shader_result_texture_slot2_ =
+      glGetUniformLocation(edges_combine_shader_, "g_resultTextureSlot2");
+  process_and_apply_shader_result_texture_float4_slot1_ = glGetUniformLocation(
+      process_and_apply_shader_, "g_resultTextureFlt4Slot1");
+  copy_to_image_shader_outTexture_ =
+      glGetUniformLocation(copy_to_image_shader_, "outTexture");
+
+  initialized_ = true;
+}
+
+void ApplyFramebufferAttachmentCMAAINTELResourceManager::Destroy() {
+  if (!initialized_)
+    return;
+
+  ReleaseTextures();
+
+  glDeleteProgram(process_and_apply_shader_);
+  glDeleteProgram(edges_combine_shader_);
+  glDeleteProgram(edges1_shader_);
+  glDeleteProgram(edges0_shader_);
+  glDeleteProgram(debug_display_edges_shader_);
+
+  initialized_ = false;
+}
+
+// Apply CMAA(Conservative Morphological Anti-Aliasing) algorithm to the
+// color attachments of currently bound draw framebuffer.
+// Reference GL_INTEL_framebuffer_CMAA for details.
+void ApplyFramebufferAttachmentCMAAINTELResourceManager::
+    ApplyFramebufferAttachmentCMAAINTEL(const gles2::GLES2Decoder* decoder) {
+  if (!initialized_)
+    return;
+
+  GLint last_framebuffer = 0;
+  GLint attachement_type = 0;
+  GLint source_texture = 0;
+  GLint texture_level = 0;
+  GLint width = 0;
+  GLint height = 0;
+  GLint internal_format = 0;
+  GLint max_draw_buffers = 0;
+
+  glGetIntegerv(GL_FRAMEBUFFER_BINDING, &last_framebuffer);
+
+  // Process each color attachment of the current draw framebuffer.
+  glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, last_framebuffer);
+  glGetIntegerv(GL_MAX_DRAW_BUFFERS, &max_draw_buffers);

[piman, 2016/06/13 22:24:43]

Here and below: we already have this value, and all the current state in the
decoder (and child classes). E.g. this would be
decoder->group()->max_draw_buffers()
Below, we can get the attachment information from the decoder's
FramebufferManager etc.

It would be preferable to use those, to avoid the TLS lookups for every GL
calls.

[adrian.belgun, 2016/06/16 14:53:14]

Done, but needed to pass |decoder| without |const| and also a |framebuffer|
pointer.

It's possible to remove the |framebuffer|, but not sure what |client_id| to pass
to |GetFramebuffer|.
https://cs.chromium.org/chromium/src/gpu/command_buffer/service/framebuffer_m...

+  for (int i = 0; i < max_draw_buffers; i++) {
+    glGetFramebufferAttachmentParameterivEXT(
+        GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + i,
+        GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, &attachement_type);
+    if (attachement_type == GL_TEXTURE) {
+      // Get the texture width and height.
+      glGetFramebufferAttachmentParameterivEXT(
+          GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + i,
+          GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, &source_texture);
+      glGetFramebufferAttachmentParameterivEXT(
+          GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + i,
+          GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL, &texture_level);
+      glBindTexture(GL_TEXTURE_2D, source_texture);
+      glGetTexLevelParameteriv(GL_TEXTURE_2D, texture_level, GL_TEXTURE_WIDTH,
+                               &width);
+      glGetTexLevelParameteriv(GL_TEXTURE_2D, texture_level, GL_TEXTURE_HEIGHT,
+                               &height);
+      glGetTexLevelParameteriv(GL_TEXTURE_2D, texture_level,
+                               GL_TEXTURE_INTERNAL_FORMAT, &internal_format);
+
+      // Resize internal structures - only if needed.
+      OnSize(width, height);
+
+      // CMAA internally expects GL_RGBA8 textures.
+      // Process using a GL_RGBA8 copy if this is not the case.
+      bool do_copy = internal_format != GL_RGBA8;
+
+      // Copy source_texture to rgba8_texture_
+      if (do_copy) {
+        CopyTexture(source_texture, rgba8_texture_, false);
+      }
+
+      // CMAA Effect
+      glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, last_framebuffer);
+      if (do_copy) {
+        ApplyCMMAEffectTexture(1.0f / 13.0f, rgba8_texture_, rgba8_texture_);

[piman, 2016/06/13 22:24:43]

Can you move this magic value into its own constant, and maybe document why this
is a good value?

[adrian.belgun, 2016/06/16 14:53:14]

Removed. Was a remnant from an older version. Currently present as a define in
the shader code.

Regarding the actual value, it's empirically derived to give the best effect
quality.
More details here:
https://software.intel.com/en-us/articles/conservative-morphological-anti-ali...

+      } else {
+        ApplyCMMAEffectTexture(1.0f / 13.0f, source_texture, source_texture);
+      }
+
+      // Copy rgba8_texture_ to source_texture
+      if (do_copy) {
+        // Move source_texture to the first color attachment of the copy fbo.
+        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, last_framebuffer);
+        glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + i,
+                                  GL_TEXTURE_2D, 0, 0);
+        glBindFramebufferEXT(GL_FRAMEBUFFER, copy_framebuffer_);
+        glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
+                                  GL_TEXTURE_2D, source_texture, 0);
+
+        CopyTexture(rgba8_texture_, source_texture, true);
+
+        // Restore color attachments
+        glBindFramebufferEXT(GL_FRAMEBUFFER, copy_framebuffer_);
+        glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
+                                  GL_TEXTURE_2D, rgba8_texture_, 0);
+        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, last_framebuffer);
+        glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + i,
+                                  GL_TEXTURE_2D, source_texture, 0);
+      }
+    }
+  }
+
+  // Restore state
+  glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, last_framebuffer);

[piman, 2016/06/13 22:24:43]

This is redundant with RestoreFramebufferBindings below.

[adrian.belgun, 2016/06/16 14:53:14]

Done.

+  decoder->RestoreAllAttributes();
+  decoder->RestoreTextureUnitBindings(0);
+  decoder->RestoreActiveTexture();
+  decoder->RestoreProgramBindings();
+  decoder->RestoreBufferBindings();
+  decoder->RestoreFramebufferBindings();
+  decoder->RestoreGlobalState();
+}
+
+void ApplyFramebufferAttachmentCMAAINTELResourceManager::ApplyCMMAEffectTexture(
+    float edge_detection_threshold,
+    GLuint source_texture,
+    GLuint dest_texture) {
+  frame_id_++;
+
+  GLuint edge_texture_a;
+  GLuint edge_texture_b;
+
+  // Flip flop - One pass clears the texture that needs clearing for the other
+  // one (actually it's only important that it clears the highest bit)
+  if ((frame_id_ % 2) == 0) {
+    edge_texture_a = edges0_texture_;
+    edge_texture_b = edges1_texture_;
+  } else {
+    edge_texture_a = edges1_texture_;
+    edge_texture_b = edges0_texture_;
+  }
+
+  // Setup the main fbo
+  glBindFramebufferEXT(GL_FRAMEBUFFER, cmaa_framebuffer_);
+  glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
+                            mini4_edge_texture_, 0);
+  glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D,
+                            mini4_edge_depth_texture_, 0);
+#if DCHECK_IS_ON()
+  GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER);
+  if (status != GL_FRAMEBUFFER_COMPLETE) {
+    DLOG(ERROR) << "ApplyFramebufferAttachmentCMAAINTEL: "
+                << "Incomplete framebuffer.";
+    Destroy();
+    return;
+  }
+#endif
+
+  // Setup the viewport to match the fbo
+  glViewport(0, 0, (int)((width_ + 1) / 2), (int)((height_ + 1) / 2));

[piman, 2016/06/13 22:24:43]

nit: no need for (int)

[adrian.belgun, 2016/06/16 14:53:14]

Done.

+  glEnable(GL_DEPTH_TEST);
+
+  // Detect edges Pass 0
+  //   - For every pixel detect edges to the right and down and output depth
+  //   mask where edges detected (1 - far, for detected, 0-near for empty
+  //   pixels)
+
+  // Inputs
+  //  g_screenTexture                     source_texture               tex0
+  // Outputs
+  //  gl_FragDepth                        mini4_edge_depth_texture_    fbo.depth
+  //  out uvec4 outEdges                  mini4_edge_texture_          fbo.col
+  //  image2D g_resultTextureFlt4Slot1    working_color_texture_       image1
+  GLenum edge_format = supports_r8_image_ ? GL_R8 : GL_R32F;
+
+  {
+    glUseProgram(edges0_shader_);
+    glUniform1f(0, 1.0f);
+    glUniform2f(1, 1.0f / width_, 1.0f / height_);
+    glDepthMask(GL_TRUE);
+    glDepthFunc(GL_ALWAYS);
+    glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+
+    if (!is_gles31_compatible) {
+      glUniform1i(edges1_shader_result_texture_float4_slot1_, 1);
+    }
+    glBindImageTextureEXT(1, working_color_texture_, 0, GL_FALSE, 0,
+                          GL_WRITE_ONLY, GL_RGBA8);
+
+    glActiveTexture(GL_TEXTURE0);
+    glBindTexture(GL_TEXTURE_2D, source_texture);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+
+    glDrawArrays(GL_TRIANGLES, 0, 3);
+  }
+
+  // Detect edges Pass 1 (finish the previous pass edge processing).
+  // Do the culling of non-dominant local edges (leave mainly locally dominant
+  // edges) and merge Right and Bottom edges into TopRightBottomLeft
+
+  // Inputs
+  //  g_src0Texture4Uint                  mini4_edge_texture_          tex1
+  // Outputs
+  //  image2D g_resultTexture             edge_texture_b               image0
+  {
+    glUseProgram(edges1_shader_);
+    glUniform1f(0, 0.0f);
+    glUniform2f(1, 1.0f / width_, 1.0f / height_);
+    glDepthMask(GL_FALSE);
+    glDepthFunc(GL_LESS);
+    glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
+
+    if (!is_gles31_compatible) {
+      glUniform1i(edges1_shader_result_texture_, 0);
+    }
+    glBindImageTextureEXT(0, edge_texture_b, 0, GL_FALSE, 0, GL_WRITE_ONLY,
+                          edge_format);
+
+    glActiveTexture(GL_TEXTURE1);
+    glBindTexture(GL_TEXTURE_2D, mini4_edge_texture_);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+
+    glDrawArrays(GL_TRIANGLES, 0, 3);
+  }
+
+  //  - Combine RightBottom (.xy) edges from previous pass into
+  //    RightBottomLeftTop (.xyzw) edges and output it into the mask (have to
+  //    fill in the whole buffer including empty ones for the line length
+  //    detection to work correctly).
+  //  - On all pixels with any edge, input buffer into a temporary color buffer
+  //    needed for correct blending in the next pass (other pixels not needed
+  //    so not copied to avoid bandwidth use).
+  //  - On all pixels with 2 or more edges output positive depth mask for the
+  //    next pass.
+
+  // Inputs
+  //  g_src0TextureFlt                    edge_texture_b               tex1 //ps
+  // Outputs
+  //  image2D g_resultTextureSlot2        edge_texture_a               image2
+  //  gl_FragDepth                        mini4_edge_texture_          fbo.depth
+  {
+    // Combine edges: each pixel will now contain info on all (top, right,
+    // bottom, left) edges; also create depth mask as above depth and mark
+    // potential Z sAND also copy source color data but only on edge pixels
+    glUseProgram(edges_combine_shader_);
+    glUniform1f(0, 1.0f);
+    glUniform2f(1, 1.0f / width_, 1.0f / height_);
+    glDepthMask(GL_TRUE);
+    glDepthFunc(GL_ALWAYS);
+    glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
+
+    if (!is_gles31_compatible) {
+      glUniform1i(edges_combine_shader_result_texture_float4_slot1_, 1);
+      glUniform1i(edges_combine_shader_result_texture_slot2_, 2);
+    }
+    glBindImageTextureEXT(1, dest_texture, 0, GL_FALSE, 0, GL_WRITE_ONLY,
+                          GL_RGBA8);
+    glBindImageTextureEXT(2, edge_texture_a, 0, GL_FALSE, 0, GL_WRITE_ONLY,
+                          edge_format);
+
+    glActiveTexture(GL_TEXTURE1);
+    glBindTexture(GL_TEXTURE_2D, edge_texture_b);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+
+    glDrawArrays(GL_TRIANGLES, 0, 3);
+  }
+
+  // Using depth mask and [earlydepthstencil] to work on pixels with 2, 3, 4
+  // edges:
+  //    - First blend simple blur map for 2,3,4 edge pixels
+  //    - Then do the lines (line length counter -should- guarantee no overlap
+  //      with other pixels - pixels with 1 edge are excluded in the previous
+  //      pass and the pixels with 2 parallel edges are excluded in the simple
+  //      blur)
+
+  // Inputs
+  //  g_screenTexture                      working_color_texture_      tex0
+  //  g_src0TextureFlt                     edge_texture_a              tex1 //ps
+  //  sampled
+  // Outputs
+  //  g_resultTextureFlt4Slot1             dest_texture                image1
+  //  gl_FragDepth                         mini4_edge_texture_         fbo.depth
+  {
+    glUseProgram(process_and_apply_shader_);
+    glUniform1f(0, 0.0f);
+    glUniform2f(1, 1.0f / width_, 1.0f / height_);
+    glDepthMask(GL_FALSE);
+    glDepthFunc(GL_LESS);
+    glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
+
+    if (!is_gles31_compatible) {
+      glUniform1i(process_and_apply_shader_result_texture_float4_slot1_, 1);
+    }
+    glBindImageTextureEXT(1, dest_texture, 0, GL_FALSE, 0, GL_WRITE_ONLY,
+                          GL_RGBA8);
+
+    glActiveTexture(GL_TEXTURE0);
+    glBindTexture(GL_TEXTURE_2D, working_color_texture_);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+
+    glActiveTexture(GL_TEXTURE1);
+    glBindTexture(GL_TEXTURE_2D, edge_texture_a);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+
+    glDrawArrays(GL_TRIANGLES, 0, 3);
+  }
+
+  glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+  glDisable(GL_DEPTH_TEST);
+  glDepthMask(GL_FALSE);
+  glActiveTexture(GL_TEXTURE0);
+}
+
+void ApplyFramebufferAttachmentCMAAINTELResourceManager::OnSize(GLint width,
+                                                                GLint height) {
+  if (height_ == height && width_ == width)
+    return;
+
+  ReleaseTextures();
+
+  height_ = height;
+  width_ = width;
+
+  glGenTextures(1, &rgba8_texture_);
+  glBindTexture(GL_TEXTURE_2D, rgba8_texture_);
+  glTexStorage2DEXT(GL_TEXTURE_2D, 1, GL_RGBA8, width, height);
+
+  // Edges texture - R8
+  // OpenGLES has no single component 8/16-bit image support, so needs to be R32
+  // Although CHT does support R8.
+  GLenum edge_format = supports_r8_image_ ? GL_R8 : GL_R32F;
+  glGenTextures(1, &edges0_texture_);
+  glBindTexture(GL_TEXTURE_2D, edges0_texture_);
+  glTexStorage2DEXT(GL_TEXTURE_2D, 1, edge_format, width, height);
+
+  glGenTextures(1, &edges1_texture_);
+  glBindTexture(GL_TEXTURE_2D, edges1_texture_);
+  glTexStorage2DEXT(GL_TEXTURE_2D, 1, edge_format, width, height);
+
+  // Color working texture - RGBA8
+  glGenTextures(1, &working_color_texture_);
+  glBindTexture(GL_TEXTURE_2D, working_color_texture_);
+  glTexStorage2DEXT(GL_TEXTURE_2D, 1, GL_RGBA8, width, height);
+
+  // Half*half compressed 4-edge-per-pixel texture - RGBA8
+  glGenTextures(1, &mini4_edge_texture_);
+  glBindTexture(GL_TEXTURE_2D, mini4_edge_texture_);
+  GLenum format = GL_RGBA8UI;
+  if (!supports_usampler_) {
+    format = GL_RGBA8;
+  }
+  glTexStorage2DEXT(GL_TEXTURE_2D, 1, format, (width + 1) / 2,
+                    (height + 1) / 2);
+
+  // Depth
+  glGenTextures(1, &mini4_edge_depth_texture_);
+  glBindTexture(GL_TEXTURE_2D, mini4_edge_depth_texture_);
+  glTexStorage2DEXT(GL_TEXTURE_2D, 1, GL_DEPTH_COMPONENT16, (width + 1) / 2,
+                    (height + 1) / 2);
+
+  // Create the FBO
+  glGenFramebuffersEXT(1, &cmaa_framebuffer_);
+  glBindFramebufferEXT(GL_FRAMEBUFFER, cmaa_framebuffer_);
+
+  // We need to clear the textures before they are first used.
+  // The algorithm self-clears them later.
+  glViewport(0, 0, (int)width_, (int)height_);

[piman, 2016/06/13 22:24:43]

nit: remove (int)

[adrian.belgun, 2016/06/16 14:53:14]

Done.

+  glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
+
+  glBindFramebufferEXT(GL_FRAMEBUFFER, cmaa_framebuffer_);
+  glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
+                            edges0_texture_, 0);
+  glClear(GL_COLOR_BUFFER_BIT);
+
+  glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
+                            edges1_texture_, 0);
+  glClear(GL_COLOR_BUFFER_BIT);
+
+  textures_initialized_ = true;
+}
+
+void ApplyFramebufferAttachmentCMAAINTELResourceManager::ReleaseTextures() {
+  if (textures_initialized_) {
+    glDeleteFramebuffersEXT(1, &copy_framebuffer_);

[piman, 2016/06/13 22:24:43]

copy_framebuffer_ and rgba8_texture_ are always created, regardless of whether
textures_initialized_ is true (OnSize was called).

[adrian.belgun, 2016/06/16 14:53:14]

Done. Moved copy_framebuffer_ and rgba8_texture_ initialization to OnSize().

+    glDeleteFramebuffersEXT(1, &cmaa_framebuffer_);
+    glDeleteTextures(1, &rgba8_texture_);
+    glDeleteTextures(1, &edges0_texture_);
+    glDeleteTextures(1, &edges1_texture_);
+    glDeleteTextures(1, &mini4_edge_texture_);
+    glDeleteTextures(1, &mini4_edge_depth_texture_);
+    glDeleteTextures(1, &working_color_texture_);
+  }
+  textures_initialized_ = false;
+}
+
+void ApplyFramebufferAttachmentCMAAINTELResourceManager::CopyTexture(
+    GLint source,
+    GLint dest,
+    bool via_fbo) {
+  glViewport(0, 0, width_, height_);
+  glActiveTexture(GL_TEXTURE0);
+  glBindTexture(GL_TEXTURE_2D, source);
+
+  if (!via_fbo) {
+    glUseProgram(copy_to_image_shader_);
+    if (!is_gles31_compatible) {
+      glUniform1i(copy_to_image_shader_outTexture_, 0);
+    }
+    glBindImageTextureEXT(0, dest, 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA8);
+  } else {
+    glDisable(GL_BLEND);

[piman, 2016/06/13 22:24:43]

What about other state such as color mask, scissor, face culling, depth/stencil
test? See e.g. CopyTextureCHROMIUMResourceManager::DoCopyTextureInternal

[adrian.belgun, 2016/06/16 14:53:14]

Done. Added remaining state flags.

+    glUseProgram(copy_to_framebuffer_shader_);
+  }
+
+  glDrawArrays(GL_TRIANGLES, 0, 3);
+  glUseProgram(0);
+  glBindTexture(GL_TEXTURE_2D, 0);
+}
+
+GLuint ApplyFramebufferAttachmentCMAAINTELResourceManager::CreateProgram(
+    const char* defines,
+    const char* vs_source,
+    const char* fs_source) {
+  GLuint program = glCreateProgram();
+
+  GLuint vs = CreateShader(GL_VERTEX_SHADER, defines, vs_source);
+  GLuint fs = CreateShader(GL_FRAGMENT_SHADER, defines, fs_source);
+
+  glAttachShader(program, vs);
+  glDeleteShader(vs);
+  glAttachShader(program, fs);
+  glDeleteShader(fs);
+
+  glLinkProgram(program);
+  GLint linkStatus;

[piman, 2016/06/13 22:24:43]

nit: link_status

[adrian.belgun, 2016/06/16 14:53:14]

Done.

+  glGetProgramiv(program, GL_LINK_STATUS, &linkStatus);
+
+  if (linkStatus == 0) {
+#if DCHECK_IS_ON()
+    GLint infoLogLength;

[piman, 2016/06/13 22:24:43]

nit: info_log_length

[adrian.belgun, 2016/06/16 14:53:14]

Done.

+    glGetProgramiv(program, GL_INFO_LOG_LENGTH, &infoLogLength);
+    std::vector<GLchar> infoLog(infoLogLength);

[piman, 2016/06/13 22:24:43]

nit: info_log

[adrian.belgun, 2016/06/16 14:53:14]

Done.

+    glGetProgramInfoLog(program, static_cast<GLsizei>(infoLog.size()), NULL,
+                        &infoLog[0]);
+    DLOG(ERROR) << "ApplyFramebufferAttachmentCMAAINTEL: "
+                << "program link failed: " << &infoLog[0];
+#endif
+    glDeleteProgram(program);
+    program = 0;
+  }
+
+  return program;
+}
+
+GLuint ApplyFramebufferAttachmentCMAAINTELResourceManager::CreateShader(
+    GLenum type,
+    const char* defines,
+    const char* source) {
+  GLuint shader = glCreateShader(type);
+
+  const char* header_es31 =

[piman, 2016/06/13 22:24:43]

nit: const char header_es31[]

[adrian.belgun, 2016/06/16 14:53:14]

Done.

+      "#version 310 es                                                      \n";
+  const char* header_gl30 =

[piman, 2016/06/13 22:24:43]

nit: const char header_gl30[]

[adrian.belgun, 2016/06/16 14:53:14]

Done.

+      "#version 130                                                         \n"
+      "#extension GL_ARB_shading_language_420pack  : require                \n"
+      "#extension GL_ARB_texture_gather            : require                \n"
+      "#extension GL_ARB_explicit_uniform_location : require                \n"
+      "#extension GL_ARB_explicit_attrib_location  : require                \n"
+      "#extension GL_ARB_shader_image_load_store   : require                \n";
+
+  const char* header = NULL;
+  if (is_gles31_compatible) {
+    header = header_es31;
+  } else {
+    header = header_gl30;
+  }
+
+  const char* sourceArray[4] = {header, defines, "\n", source};

[piman, 2016/06/13 22:24:43]

nit: source_array

[adrian.belgun, 2016/06/16 14:53:14]

Done.

+  glShaderSource(shader, 4, sourceArray, NULL);
+
+  glCompileShader(shader);
+
+  GLint compileResult;

[piman, 2016/06/13 22:24:43]

nit: compile_result

[adrian.belgun, 2016/06/16 14:53:14]

Done.

+  glGetShaderiv(shader, GL_COMPILE_STATUS, &compileResult);
+  if (compileResult == 0) {
+#if DCHECK_IS_ON()
+    GLint infoLogLength;

[piman, 2016/06/13 22:24:43]

nit: info_log_length

[adrian.belgun, 2016/06/16 14:53:14]

Done.

+    glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLogLength);
+    std::vector<GLchar> infoLog(infoLogLength);

[piman, 2016/06/13 22:24:43]

nit: info_log

[adrian.belgun, 2016/06/16 14:53:14]

Done.

+    glGetShaderInfoLog(shader, static_cast<GLsizei>(infoLog.size()), NULL,
+                       &infoLog[0]);
+    DLOG(ERROR) << "ApplyFramebufferAttachmentCMAAINTEL: "
+                << "shader compilation failed: "
+                << (type == GL_VERTEX_SHADER
+                        ? "GL_VERTEX_SHADER"
+                        : (type == GL_FRAGMENT_SHADER ? "GL_FRAGMENT_SHADER"
+                                                      : "UNKNOWN_SHADER"))
+                << " shader compilation failed: " << &infoLog[0];
+#endif
+    glDeleteShader(shader);
+    shader = 0;
+  }
+
+  return shader;
+}
+
+// Shaders used in the CMAA algorithm.
+const char* ApplyFramebufferAttachmentCMAAINTELResourceManager::vert_str_ =
+    "precision highp float;                                                 \n"
+    "layout(location = 0) uniform float g_Depth;                            \n"
+    "// No input data.                                                      \n"
+    "// Verts are autogenerated.                                            \n"
+    "//                                                                     \n"
+    "// vertexID 0,1,2 should generate                                      \n"
+    "// POS: (-1,-1), (+3,-1), (-1,+3)                                      \n"
+    "//                                                                     \n"
+    "// This generates a triangle that completely covers the -1->1 viewport \n"
+    "//                                                                     \n"
+    "void main()                                                            \n"
+    "{                                                                      \n"
+    "   float x = -1.0 + float((gl_VertexID & 1) << 2);                     \n"
+    "   float y = -1.0 + float((gl_VertexID & 2) << 1);                     \n"
+    "   gl_Position = vec4(x, y, g_Depth, 1.0);                             \n"
+    "}                                                                      \n"
+    "                                                                       \n";
+
+const char* ApplyFramebufferAttachmentCMAAINTELResourceManager::cmaa_frag_str_ =
+    "precision highp float;                                                 \n"
+    "precision highp int;                                                   \n"
+    "                                                                       \n"
+    "#define SETTINGS_ALLOW_SHORT_Zs 1                                      \n"
+    "#define EDGE_DETECT_THRESHOLD 13.0f                                    \n"
+    "                                                                       \n"
+    "#define saturate(x) clamp((x), 0.0, 1.0)                               \n"
+    "                                                                       \n"
+    "// bind to location 0                                                  \n"
+    "layout(location = 0) uniform float g_Depth;                            \n"
+    "// bind to a uniform buffer bind point 0                               \n"
+    "layout(location = 1) uniform vec2 g_OneOverScreenSize;                 \n"
+    "#ifndef EDGE_DETECT_THRESHOLD                                          \n"
+    "layout(location = 2) uniform float g_ColorThreshold;                   \n"
+    "#endif                                                                 \n"
+    "                                                                       \n"
+    "#ifdef SUPPORTS_USAMPLER2D                                             \n"
+    "#define USAMPLER usampler2D                                            \n"
+    "#define UVEC4 uvec4                                                    \n"
+    "#define LOAD_UINT(arg) arg                                             \n"
+    "#define STORE_UVEC4(arg) arg                                           \n"
+    "#else                                                                  \n"
+    "#define USAMPLER sampler2D                                             \n"
+    "#define UVEC4 vec4                                                     \n"
+    "#define LOAD_UINT(arg) uint(arg * 255.0f)                              \n"
+    "#define STORE_UVEC4(arg) vec4(float(arg.x) / 255.0f,                 \\\n"
+    "                              float(arg.y) / 255.0f,                 \\\n"
+    "                              float(arg.z) / 255.0f,                 \\\n"
+    "                              float(arg.w) / 255.0f)                   \n"
+    "#endif                                                                 \n"
+    "                                                                       \n"
+    "// bind to texture stage 0/1                                           \n"
+    "layout(binding = 0) uniform highp sampler2D g_screenTexture;           \n"
+    "layout(binding = 1) uniform highp sampler2D g_src0TextureFlt;          \n"
+    "layout(binding = 1) uniform highp USAMPLER g_src0Texture4Uint;         \n"
+    "                                                                       \n"
+    "// bind to image stage 0/1/2                                           \n"
+    "#ifdef GL_ES                                                           \n"
+    "layout(binding = 0, EDGE_READ_FORMAT) restrict writeonly uniform highp \n"
+    "    image2D g_resultTexture;                                           \n"
+    "layout(binding = 1, rgba8) restrict writeonly uniform highp            \n"
+    "    image2D g_resultTextureFlt4Slot1;                                  \n"
+    "layout(binding = 2, EDGE_READ_FORMAT) restrict writeonly uniform highp \n"
+    "    image2D g_resultTextureSlot2;                                      \n"
+    "#else                                                                  \n"
+    "layout(EDGE_READ_FORMAT) restrict writeonly uniform highp              \n"
+    "    image2D g_resultTexture;                                           \n"
+    "layout(rgba8) restrict writeonly uniform highp                         \n"
+    "    image2D g_resultTextureFlt4Slot1;                                  \n"
+    "layout(EDGE_READ_FORMAT) restrict writeonly uniform highp              \n"
+    "    image2D g_resultTextureSlot2;                                      \n"
+    "#endif                                                                 \n"
+    "                                                                       \n"
+    "// Constants                                                           \n"
+    "const vec4 c_lumWeights = vec4(0.2126f, 0.7152f, 0.0722f, 0.0000f);    \n"
+    "                                                                       \n"
+    "#ifdef EDGE_DETECT_THRESHOLD                                           \n"
+    "const float c_ColorThreshold = 1.0f / EDGE_DETECT_THRESHOLD;           \n"
+    "#endif                                                                 \n"
+    "                                                                       \n"
+    "// Must be even number; Will work with ~16 pretty good too for         \n"
+    "// additional performance, or with ~64 for highest quality.            \n"
+    "const int c_maxLineLength = 64;                                        \n"
+    "                                                                       \n"
+    "const vec4 c_edgeDebugColours[5] = vec4[5](vec4(0.5, 0.5, 0.5, 0.4),   \n"
+    "                                           vec4(1.0, 0.1, 1.0, 0.8),   \n"
+    "                                           vec4(0.9, 0.0, 0.0, 0.8),   \n"
+    "                                           vec4(0.0, 0.9, 0.0, 0.8),   \n"
+    "                                           vec4(0.0, 0.0, 0.9, 0.8));  \n"
+    "                                                                       \n"
+    "// this isn't needed if colour UAV is _SRGB but that doesn't work      \n"
+    "// everywhere                                                          \n"
+    "#ifdef IN_GAMMA_CORRECT_MODE                                           \n"
+    "///////////////////////////////////////////////////////////////////////\n"
+    "//                                                                     \n"
+    "// SRGB Helper Functions taken from D3DX_DXGIFormatConvert.inl         \n"
+    "float D3DX_FLOAT_to_SRGB(float val) {                                  \n"
+    "  if (val < 0.0031308f)                                                \n"
+    "    val *= 12.92f;                                                     \n"
+    "  else {                                                               \n"
+    "    val = 1.055f * pow(val, 1.0f / 2.4f) - 0.055f;                     \n"
+    "  }                                                                    \n"
+    "  return val;                                                          \n"
+    "}                                                                      \n"
+    "//                                                                     \n"
+    "vec3 D3DX_FLOAT3_to_SRGB(vec3 val) {                                   \n"
+    "  vec3 outVal;                                                         \n"
+    "  outVal.x = D3DX_FLOAT_to_SRGB(val.x);                                \n"
+    "  outVal.y = D3DX_FLOAT_to_SRGB(val.y);                                \n"
+    "  outVal.z = D3DX_FLOAT_to_SRGB(val.z);                                \n"
+    "  return outVal;                                                       \n"
+    "}                                                                      \n"
+    "//                                                                     \n"
+    "///////////////////////////////////////////////////////////////////////\n"
+    "#endif  // IN_GAMMA_CORRECT_MODE                                       \n"
+    "                                                                       \n"
+    "// how .rgba channels from the edge texture maps to pixel edges:       \n"
+    "//                                                                     \n"
+    "//                   A - 0x08                                          \n"
+    "//              |¯¯¯¯¯¯¯¯¯|                                            \n"
+    "//              |         |                                            \n"
+    "//     0x04 - B |  pixel  | R - 0x01                                   \n"
+    "//              |         |                                            \n"
+    "//              |_________|                                            \n"
+    "//                   G - 0x02                                          \n"
+    "//                                                                     \n"
+    "// (A - there's an edge between us and a pixel above us)               \n"
+    "// (R - there's an edge between us and a pixel to the right)           \n"
+    "// (G - there's an edge between us and a pixel at the bottom)          \n"
+    "// (B - there's an edge between us and a pixel to the left)            \n"
+    "                                                                       \n"
+    "// Expecting values of 1 and 0 only!                                   \n"
+    "uint PackEdge(uvec4 edges) {                                           \n"
+    "  return (edges.x << 0u) | (edges.y << 1u) | (edges.z << 2u) |         \n"
+    "         (edges.w << 3u);                                              \n"
+    "}                                                                      \n"
+    "                                                                       \n"
+    "uvec4 UnpackEdge(uint value) {                                         \n"
+    "  uvec4 ret;                                                           \n"
+    "  ret.x = (value & 0x01u) != 0u ? 1u : 0u;                             \n"
+    "  ret.y = (value & 0x02u) != 0u ? 1u : 0u;                             \n"
+    "  ret.z = (value & 0x04u) != 0u ? 1u : 0u;                             \n"
+    "  ret.w = (value & 0x08u) != 0u ? 1u : 0u;                             \n"
+    "  return ret;                                                          \n"
+    "}                                                                      \n"
+    "                                                                       \n"
+    "uint PackZ(const uvec2 screenPos, const bool invertedZShape) {         \n"
+    "  uint retVal = screenPos.x | (screenPos.y << 15u);                    \n"
+    "  if (invertedZShape)                                                  \n"
+    "    retVal |= (1u << 30u);                                             \n"
+    "  return retVal;                                                       \n"
+    "}                                                                      \n"
+    "                                                                       \n"
+    "void UnpackZ(uint packedZ, out uvec2 screenPos,                        \n"
+    "                           out bool invertedZShape)                    \n"
+    "{                                                                      \n"
+    "  screenPos.x = packedZ & 0x7FFFu;                                     \n"
+    "  screenPos.y = (packedZ >> 15u) & 0x7FFFu;                            \n"
+    "  invertedZShape = (packedZ >> 30u) == 1u;                             \n"
+    "}                                                                      \n"
+    "                                                                       \n"
+    "uint PackZ(const uvec2 screenPos,                                      \n"
+    "           const bool invertedZShape,                                  \n"
+    "           const bool horizontal) {                                    \n"
+    "  uint retVal = screenPos.x | (screenPos.y << 15u);                    \n"
+    "  if (invertedZShape)                                                  \n"
+    "    retVal |= (1u << 30u);                                             \n"
+    "  if (horizontal)                                                      \n"
+    "    retVal |= (1u << 31u);                                             \n"
+    "  return retVal;                                                       \n"
+    "}                                                                      \n"
+    "                                                                       \n"
+    "void UnpackZ(uint packedZ,                                             \n"
+    "             out uvec2 screenPos,                                      \n"
+    "             out bool invertedZShape,                                  \n"
+    "             out bool horizontal) {                                    \n"
+    "  screenPos.x = packedZ & 0x7FFFu;                                     \n"
+    "  screenPos.y = (packedZ >> 15u) & 0x7FFFu;                            \n"
+    "  invertedZShape = (packedZ & (1u << 30u)) != 0u;                      \n"
+    "  horizontal = (packedZ & (1u << 31u)) != 0u;                          \n"
+    "}                                                                      \n"
+    "                                                                       \n"
+    "vec4 PackBlurAAInfo(ivec2 pixelPos, uint shapeType) {                  \n"
+    "  uint packedEdges = uint(                                             \n"
+    "      texelFetch(g_src0TextureFlt, pixelPos, 0).r * 255.5);            \n"
+    "                                                                       \n"
+    "  float retval = float(packedEdges + (shapeType << 4u));               \n"
+    "                                                                       \n"
+    "  return vec4(retval / 255.0);                                         \n"
+    "}                                                                      \n"
+    "                                                                       \n"
+    "void UnpackBlurAAInfo(float packedValue, out uint edges,               \n"
+    "                      out uint shapeType) {                            \n"
+    "  uint packedValueInt = uint(packedValue * 255.5);                     \n"
+    "  edges = packedValueInt & 0xFu;                                       \n"
+    "  shapeType = packedValueInt >> 4u;                                    \n"
+    "}                                                                      \n"
+    "                                                                       \n"
+    "float EdgeDetectColorCalcDiff(vec3 colorA, vec3 colorB) {              \n"
+    "#ifdef IN_BGR_MODE                                                     \n"
+    "  vec3 LumWeights = c_lumWeights.bgr;                                  \n"
+    "#else                                                                  \n"
+    "  vec3 LumWeights = c_lumWeights.rgb;                                  \n"
+    "#endif                                                                 \n"
+    "                                                                       \n"
+    "  return dot(abs(colorA.rgb - colorB.rgb), LumWeights);                \n"
+    "}                                                                      \n"
+    "                                                                       \n"
+    "bool EdgeDetectColor(vec3 colorA, vec3 colorB) {                       \n"
+    "#ifdef EDGE_DETECT_THRESHOLD                                           \n"
+    "  return EdgeDetectColorCalcDiff(colorA, colorB) > c_ColorThreshold;   \n"
+    "#else                                                                  \n"
+    "  return EdgeDetectColorCalcDiff(colorA, colorB) > g_ColorThreshold;   \n"
+    "#endif                                                                 \n"
+    "}                                                                      \n"
+    "                                                                       \n"
+    "void FindLineLength(out int lineLengthLeft,                            \n"
+    "                    out int lineLengthRight,                           \n"
+    "                    ivec2 screenPos,                                   \n"
+    "                    const bool horizontal,                             \n"
+    "                    const bool invertedZShape,                         \n"
+    "                    const ivec2 stepRight) {                           \n"
+    "  // TODO: there must be a cleaner and faster way to get to these -    \n"
+    "  // a precalculated array indexing maybe?                             \n"
+    "  uint maskLeft, bitsContinueLeft, maskRight, bitsContinueRight;       \n"
+    "  {                                                                    \n"
+    "  // Horizontal (vertical is the same, just rotated 90º                \n"
+    "  // counter-clockwise)                                                \n"
+    "  // Inverted Z case:              // Normal Z case:                   \n"
+    "  //   __                          // __                               \n"
+    "  //  X|                           //  X|                              \n"
+    "  // --                            //    --                            \n"
+    "  //                                                                   \n"
+    "    uint maskTraceLeft, maskTraceRight;                                \n"
+    "    uint maskStopLeft, maskStopRight;                                  \n"
+    "    if (horizontal) {                                                  \n"
+    "      if (invertedZShape) {                                            \n"
+    "        maskTraceLeft = 0x02u;  // tracing bottom edge                 \n"
+    "        maskTraceRight = 0x08u; // tracing top edge                    \n"
+    "      } else {                                                         \n"
+    "        maskTraceLeft = 0x08u;  // tracing top edge                    \n"
+    "        maskTraceRight = 0x02u; // tracing bottom edge                 \n"
+    "      }                                                                \n"
+    "      maskStopLeft = 0x01u;  // stop on right edge                     \n"
+    "      maskStopRight = 0x04u; // stop on left edge                      \n"
+    "    } else {                                                           \n"
+    "      if (invertedZShape) {                                            \n"
+    "        maskTraceLeft = 0x01u;  // tracing right edge                  \n"
+    "        maskTraceRight = 0x04u; // tracing left edge                   \n"
+    "      } else {                                                         \n"
+    "        maskTraceLeft = 0x04u;  // tracing left edge                   \n"
+    "        maskTraceRight = 0x01u; // tracing right edge                  \n"
+    "      }                                                                \n"
+    "      maskStopLeft = 0x08u;  // stop on top edge                       \n"
+    "      maskStopRight = 0x02u; // stop on bottom edge                    \n"
+    "    }                                                                  \n"
+    "                                                                       \n"
+    "    maskLeft = maskTraceLeft | maskStopLeft;                           \n"
+    "    bitsContinueLeft = maskTraceLeft;                                  \n"
+    "    maskRight = maskTraceRight | maskStopRight;                        \n"
+    "    bitsContinueRight = maskTraceRight;                                \n"
+    "  }                                                                    \n"
+    "///////////////////////////////////////////////////////////////////////\n"
+    "                                                                       \n"
+    "#ifdef SETTINGS_ALLOW_SHORT_Zs                                         \n"
+    "  int i = 1;                                                           \n"
+    "#else                                                                  \n"
+    "  int i = 2; // starting from 2 because we already know it's at least 2\n"
+    "#endif                                                                 \n"
+    "  for (; i < c_maxLineLength; i++) {                                   \n"
+    "    uint edgeLeft = uint(                                              \n"
+    "        texelFetch(g_src0TextureFlt,                                   \n"
+    "                   ivec2(screenPos.xy - stepRight * i), 0).r * 255.5); \n"
+    "    uint edgeRight = uint(                                             \n"
+    "        texelFetch(g_src0TextureFlt,                                   \n"
+    "                   ivec2(screenPos.xy + stepRight * (i + 1)),          \n"
+    "                   0).r * 255.5);                                      \n"
+    "                                                                       \n"
+    "    // stop on encountering 'stopping' edge (as defined by masks)      \n"
+    "    int stopLeft = (edgeLeft & maskLeft) != bitsContinueLeft ? 1 : 0;  \n"
+    "    int stopRight =                                                    \n"
+    "        (edgeRight & maskRight) != bitsContinueRight ? 1 : 0;          \n"
+    "                                                                       \n"
+    "    if (bool(stopLeft) || bool(stopRight)) {                           \n"
+    "      lineLengthLeft = 1 + i - stopLeft;                               \n"
+    "      lineLengthRight = 1 + i - stopRight;                             \n"
+    "      return;                                                          \n"
+    "    }                                                                  \n"
+    "  }                                                                    \n"
+    "  lineLengthLeft = lineLengthRight = i;                                \n"
+    "  return;                                                              \n"
+    "}                                                                      \n"
+    "                                                                       \n"
+    "void ProcessDetectedZ(ivec2 screenPos, bool horizontal,                \n"
+    "                      bool invertedZShape) {                           \n"
+    "  int lineLengthLeft, lineLengthRight;                                 \n"
+    "                                                                       \n"
+    "  ivec2 stepRight = (horizontal) ? (ivec2(1, 0)) : (ivec2(0, -1));     \n"
+    "  vec2 blendDir = (horizontal) ? (vec2(0, -1)) : (vec2(-1, 0));        \n"
+    "                                                                       \n"
+    "  FindLineLength(lineLengthLeft, lineLengthRight, screenPos,           \n"
+    "                 horizontal, invertedZShape, stepRight);               \n"
+    "                                                                       \n"
+    "  vec2 pixelSize = g_OneOverScreenSize;                                \n"
+    "                                                                       \n"
+    "  float leftOdd = 0.15 * float(lineLengthLeft % 2);                    \n"
+    "  float rightOdd = 0.15 * float(lineLengthRight % 2);                  \n"
+    "                                                                       \n"
+    "  int loopFrom = -int((lineLengthLeft + 1) / 2) + 1;                   \n"
+    "  int loopTo = int((lineLengthRight + 1) / 2);                         \n"
+    "                                                                       \n"
+    "  float totalLength = float(loopTo - loopFrom) + 1.0 - leftOdd -       \n"
+    "                      rightOdd;                                        \n"
+    "                                                                       \n"
+    "  for (int i = loopFrom; i <= loopTo; i++) {                           \n"
+    "    highp ivec2 pixelPos = screenPos + stepRight * i;                  \n"
+    "    vec2 pixelPosFlt = vec2(float(pixelPos.x) + 0.5,                   \n"
+    "                            float(pixelPos.y) + 0.5);                  \n"
+    "                                                                       \n"
+    "#ifdef DEBUG_OUTPUT_AAINFO                                             \n"
+    "    imageStore(g_resultTextureSlot2, pixelPos,                         \n"
+    "               PackBlurAAInfo(pixelPos, 1u));                          \n"
+    "#endif                                                                 \n"
+    "                                                                       \n"
+    "    float m = (float(i) + 0.5 - leftOdd - float(loopFrom)) /           \n"
+    "               totalLength;                                            \n"
+    "    m = saturate(m);                                                   \n"
+    "    float k = m - ((i > 0) ? 1.0 : 0.0);                               \n"
+    "    k = (invertedZShape) ? (-k) : (k);                                 \n"
+    "                                                                       \n"
+    "    vec4 color = textureLod(g_screenTexture,                           \n"
+    "                            (pixelPosFlt + blendDir * k) * pixelSize,  \n"
+    "                            0.0);                                      \n"
+    "                                                                       \n"
+    "#ifdef IN_GAMMA_CORRECT_MODE                                           \n"
+    "    color.rgb = D3DX_FLOAT3_to_SRGB(color.rgb);                        \n"
+    "#endif                                                                 \n"
+    "    imageStore(g_resultTextureFlt4Slot1, pixelPos, color);             \n"
+    "  }                                                                    \n"
+    "}                                                                      \n"
+    "                                                                       \n"
+    "vec4 CalcDbgDisplayColor(const vec4 blurMap) {                         \n"
+    "  vec3 pixelC = vec3(0.0, 0.0, 0.0);                                   \n"
+    "  vec3 pixelL = vec3(0.0, 0.0, 1.0);                                   \n"
+    "  vec3 pixelT = vec3(1.0, 0.0, 0.0);                                   \n"
+    "  vec3 pixelR = vec3(0.0, 1.0, 0.0);                                   \n"
+    "  vec3 pixelB = vec3(0.8, 0.8, 0.0);                                   \n"
+    "                                                                       \n"
+    "  const float centerWeight = 1.0;                                      \n"
+    "  float fromBelowWeight = (1.0 / (1.0 - blurMap.x)) - 1.0;             \n"
+    "  float fromAboveWeight = (1.0 / (1.0 - blurMap.y)) - 1.0;             \n"
+    "  float fromRightWeight = (1.0 / (1.0 - blurMap.z)) - 1.0;             \n"
+    "  float fromLeftWeight = (1.0 / (1.0 - blurMap.w)) - 1.0;              \n"
+    "                                                                       \n"
+    "  float weightSum = centerWeight + dot(vec4(fromBelowWeight,           \n"
+    "                                            fromAboveWeight,           \n"
+    "                                            fromRightWeight,           \n"
+    "                                            fromLeftWeight),           \n"
+    "                                       vec4(1, 1, 1, 1));              \n"
+    "                                                                       \n"
+    "  vec4 pixel;                                                          \n"
+    "                                                                       \n"
+    "  pixel.rgb = pixelC.rgb + fromAboveWeight * pixelT +                  \n"
+    "                           fromBelowWeight * pixelB +                  \n"
+    "                           fromLeftWeight * pixelL +                   \n"
+    "                           fromRightWeight * pixelR;                   \n"
+    "  pixel.rgb /= weightSum;                                              \n"
+    "                                                                       \n"
+    "  pixel.a = dot(pixel.rgb, vec3(1, 1, 1)) * 100.0;                     \n"
+    "                                                                       \n"
+    "  return saturate(pixel);                                              \n"
+    "}                                                                      \n"
+    "                                                                       \n"
+    "#ifdef DETECT_EDGES1                                                   \n"
+    "layout(location = 0) out UVEC4 outEdges;                               \n"
+    "void DetectEdges1() {                                                  \n"
+    "  uvec4 outputEdges;                                                   \n"
+    "  ivec2 screenPosI = ivec2(gl_FragCoord.xy) * ivec2(2, 2);             \n"
+    "                                                                       \n"
+    "  // .rgb contains colour, .a contains flag whether to output it to    \n"
+    "  // working colour texture                                            \n"
+    "  vec4 pixel00 = texelFetch(g_screenTexture, screenPosI.xy, 0);        \n"
+    "  vec4 pixel10 =                                                       \n"
+    "      texelFetchOffset(g_screenTexture, screenPosI.xy, 0, ivec2(1, 0));\n"
+    "  vec4 pixel20 =                                                       \n"
+    "      texelFetchOffset(g_screenTexture, screenPosI.xy, 0, ivec2(2, 0));\n"
+    "  vec4 pixel01 =                                                       \n"
+    "      texelFetchOffset(g_screenTexture, screenPosI.xy, 0, ivec2(0, 1));\n"
+    "  vec4 pixel11 =                                                       \n"
+    "      texelFetchOffset(g_screenTexture, screenPosI.xy, 0, ivec2(1, 1));\n"
+    "  vec4 pixel21 =                                                       \n"
+    "      texelFetchOffset(g_screenTexture, screenPosI.xy, 0, ivec2(2, 1));\n"
+    "  vec4 pixel02 =                                                       \n"
+    "      texelFetchOffset(g_screenTexture, screenPosI.xy, 0, ivec2(0, 2));\n"
+    "  vec4 pixel12 =                                                       \n"
+    "      texelFetchOffset(g_screenTexture, screenPosI.xy, 0, ivec2(1, 2));\n"
+    "                                                                       \n"
+    "  float storeFlagPixel00 = 0.0;                                        \n"
+    "  float storeFlagPixel10 = 0.0;                                        \n"
+    "  float storeFlagPixel20 = 0.0;                                        \n"
+    "  float storeFlagPixel01 = 0.0;                                        \n"
+    "  float storeFlagPixel11 = 0.0;                                        \n"
+    "  float storeFlagPixel21 = 0.0;                                        \n"
+    "  float storeFlagPixel02 = 0.0;                                        \n"
+    "  float storeFlagPixel12 = 0.0;                                        \n"
+    "                                                                       \n"
+    "  vec2 et;                                                             \n"
+    "                                                                       \n"
+    "#ifdef EDGE_DETECT_THRESHOLD                                           \n"
+    "  float threshold = c_ColorThreshold;                                  \n"
+    "#else                                                                  \n"
+    "  float threshold = g_ColorThreshold;                                  \n"
+    "#endif                                                                 \n"
+    "                                                                       \n"
+    "  {                                                                    \n"
+    "    et.x = EdgeDetectColorCalcDiff(pixel00.rgb, pixel10.rgb);          \n"
+    "    et.y = EdgeDetectColorCalcDiff(pixel00.rgb, pixel01.rgb);          \n"
+    "    et = saturate(et - threshold);                                     \n"
+    "    ivec2 eti = ivec2(et * 15.0 + 0.99);                               \n"
+    "    outputEdges.x = uint(eti.x | (eti.y << 4));                        \n"
+    "                                                                       \n"
+    "    storeFlagPixel00 += et.x;                                          \n"
+    "    storeFlagPixel00 += et.y;                                          \n"
+    "    storeFlagPixel10 += et.x;                                          \n"
+    "    storeFlagPixel01 += et.y;                                          \n"
+    "  }                                                                    \n"
+    "                                                                       \n"
+    "  {                                                                    \n"
+    "    et.x = EdgeDetectColorCalcDiff(pixel10.rgb, pixel20.rgb);          \n"
+    "    et.y = EdgeDetectColorCalcDiff(pixel10.rgb, pixel11.rgb);          \n"
+    "    et = saturate(et - threshold);                                     \n"
+    "    ivec2 eti = ivec2(et * 15.0 + 0.99);                               \n"
+    "    outputEdges.y = uint(eti.x | (eti.y << 4));                        \n"
+    "                                                                       \n"
+    "    storeFlagPixel10 += et.x;                                          \n"
+    "    storeFlagPixel10 += et.y;                                          \n"
+    "    storeFlagPixel20 += et.x;                                          \n"
+    "    storeFlagPixel11 += et.y;                                          \n"
+    "  }                                                                    \n"
+    "                                                                       \n"
+    "  {                                                                    \n"
+    "    et.x = EdgeDetectColorCalcDiff(pixel01.rgb, pixel11.rgb);          \n"
+    "    et.y = EdgeDetectColorCalcDiff(pixel01.rgb, pixel02.rgb);          \n"
+    "    et = saturate(et - threshold);                                     \n"
+    "    ivec2 eti = ivec2(et * 15.0 + 0.99);                               \n"
+    "    outputEdges.z = uint(eti.x | (eti.y << 4));                        \n"
+    "                                                                       \n"
+    "    storeFlagPixel01 += et.x;                                          \n"
+    "    storeFlagPixel01 += et.y;                                          \n"
+    "    storeFlagPixel11 += et.x;                                          \n"
+    "    storeFlagPixel02 += et.y;                                          \n"
+    "  }                                                                    \n"
+    "                                                                       \n"
+    "  {                                                                    \n"
+    "    et.x = EdgeDetectColorCalcDiff(pixel11.rgb, pixel21.rgb);          \n"
+    "    et.y = EdgeDetectColorCalcDiff(pixel11.rgb, pixel12.rgb);          \n"
+    "    et = saturate(et - threshold);                                     \n"
+    "    ivec2 eti = ivec2(et * 15.0 + 0.99);                               \n"
+    "    outputEdges.w = uint(eti.x | (eti.y << 4));                        \n"
+    "                                                                       \n"
+    "    storeFlagPixel11 += et.x;                                          \n"
+    "    storeFlagPixel11 += et.y;                                          \n"
+    "    storeFlagPixel21 += et.x;                                          \n"
+    "    storeFlagPixel12 += et.y;                                          \n"
+    "  }                                                                    \n"
+    "                                                                       \n"
+    "  gl_FragDepth = any(bvec4(outputEdges)) ? 1.0 : 0.0;                  \n"
+    "                                                                       \n"
+    "  if (gl_FragDepth != 0.0) {                                           \n"
+    "    if (storeFlagPixel00 != 0.0)                                       \n"
+    "      imageStore(g_resultTextureFlt4Slot1, screenPosI.xy + ivec2(0, 0),\n"
+    "                 pixel00);                                             \n"
+    "    if (storeFlagPixel10 != 0.0)                                       \n"
+    "      imageStore(g_resultTextureFlt4Slot1, screenPosI.xy + ivec2(1, 0),\n"
+    "                 pixel10);                                             \n"
+    "    if (storeFlagPixel20 != 0.0)                                       \n"
+    "      imageStore(g_resultTextureFlt4Slot1, screenPosI.xy + ivec2(2, 0),\n"
+    "                 pixel20);                                             \n"
+    "    if (storeFlagPixel01 != 0.0)                                       \n"
+    "      imageStore(g_resultTextureFlt4Slot1, screenPosI.xy + ivec2(0, 1),\n"
+    "                 pixel01);                                             \n"
+    "    if (storeFlagPixel02 != 0.0)                                       \n"
+    "      imageStore(g_resultTextureFlt4Slot1, screenPosI.xy + ivec2(0, 2),\n"
+    "                 pixel02);                                             \n"
+    "    if (storeFlagPixel11 != 0.0)                                       \n"
+    "      imageStore(g_resultTextureFlt4Slot1, screenPosI.xy + ivec2(1, 1),\n"
+    "                 pixel11);                                             \n"
+    "    if (storeFlagPixel21 != 0.0)                                       \n"
+    "      imageStore(g_resultTextureFlt4Slot1, screenPosI.xy + ivec2(2, 1),\n"
+    "                 pixel21);                                             \n"
+    "    if (storeFlagPixel12 != 0.0)                                       \n"
+    "      imageStore(g_resultTextureFlt4Slot1, screenPosI.xy + ivec2(1, 2),\n"
+    "                 pixel12);                                             \n"
+    "  }                                                                    \n"
+    "  outEdges = STORE_UVEC4(outputEdges);                                 \n"
+    "}                                                                      \n"
+    "#endif  // DETECT_EDGES1                                               \n"
+    "                                                                       \n"
+    "vec2 UnpackThresholds(uint val) {                                      \n"
+    "  return vec2(val & 0x0Fu, val >> 4u) / 15.0f;                         \n"
+    "}                                                                      \n"
+    "                                                                       \n"
+    "uint PruneNonDominantEdges(vec4 edges[3]) {                            \n"
+    "  vec4 maxE4 = vec4(0.0, 0.0, 0.0, 0.0);                               \n"
+    "                                                                       \n"
+    "  float avg = 0.0;                                                     \n"
+    "                                                                       \n"
+    "  for (int i = 0; i < 3; i++) {                                        \n"
+    "    maxE4 = max(maxE4, edges[i]);                                      \n"
+    "                                                                       \n"
+    "    avg = dot(edges[i], vec4(1, 1, 1, 1) / (3.0 * 4.0));               \n"
+    "  }                                                                    \n"
+    "                                                                       \n"
+    "  vec2 maxE2 = max(maxE4.xy, maxE4.zw);                                \n"
+    "  float maxE = max(maxE2.x, maxE2.y);                                  \n"
+    "                                                                       \n"
+    "  float threshold = avg * 0.65 + maxE * 0.35;                          \n"
+    "                                                                       \n"
+    "  // threshold = 0.0001; // this disables non-dominant edge pruning!   \n"
+    "                                                                       \n"
+    "  uint cx = edges[0].x >= threshold ? 1u : 0u;                         \n"
+    "  uint cy = edges[0].y >= threshold ? 1u : 0u;                         \n"
+    "  return PackEdge(uvec4(cx, cy, 0, 0));                                \n"
+    "}                                                                      \n"
+    "                                                                       \n"
+    "void CollectEdges(int offX,                                            \n"
+    "                  int offY,                                            \n"
+    "                  out vec4 edges[3],                                   \n"
+    "                  const uint packedVals[6 * 6]) {                      \n"
+    "  vec2 pixelP0P0 = UnpackThresholds(packedVals[(offX)*6+(offY)]);      \n"
+    "  vec2 pixelP1P0 = UnpackThresholds(packedVals[(offX+1)*6+(offY)]);    \n"
+    "  vec2 pixelP0P1 = UnpackThresholds(packedVals[(offX)*6+(offY+1)]);    \n"
+    "  vec2 pixelM1P0 = UnpackThresholds(packedVals[(offX-1)*6 +(offY)]);   \n"
+    "  vec2 pixelP0M1 = UnpackThresholds(packedVals[(offX)*6+(offY-1)]);    \n"
+    "  vec2 pixelP1M1 = UnpackThresholds(packedVals[(offX+1)*6 +(offY-1)]); \n"
+    "  vec2 pixelM1P1 = UnpackThresholds(packedVals[(offX-1)*6+(offY+1)]);  \n"
+    "                                                                       \n"
+    "  edges[0].x = pixelP0P0.x;                                            \n"
+    "  edges[0].y = pixelP0P0.y;                                            \n"
+    "  edges[0].z = pixelP1P0.x;                                            \n"
+    "  edges[0].w = pixelP1P0.y;                                            \n"
+    "  edges[1].x = pixelP0P1.x;                                            \n"
+    "  edges[1].y = pixelP0P1.y;                                            \n"
+    "  edges[1].z = pixelM1P0.x;                                            \n"
+    "  edges[1].w = pixelM1P0.y;                                            \n"
+    "  edges[2].x = pixelP0M1.x;                                            \n"
+    "  edges[2].y = pixelP0M1.y;                                            \n"
+    "  edges[2].z = pixelP1M1.y;                                            \n"
+    "  edges[2].w = pixelM1P1.x;                                            \n"
+    "}                                                                      \n"
+    "                                                                       \n"
+    "#ifdef DETECT_EDGES2                                                   \n"
+    "layout(early_fragment_tests) in;                                       \n"
+    "void DetectEdges2() {                                                  \n"
+    "  ivec2 screenPosI = ivec2(gl_FragCoord.xy);                           \n"
+    "                                                                       \n"
+    "  // source : edge differences from previous pass                      \n"
+    "  uint packedVals[6 * 6];                                              \n"
+    "                                                                       \n"
+    "  // center pixel (our output)                                         \n"
+    "  UVEC4 packedQ4 = texelFetch(g_src0Texture4Uint, screenPosI.xy, 0);   \n"
+    "  packedVals[(2) * 6 + (2)] = LOAD_UINT(packedQ4.x);                   \n"
+    "  packedVals[(3) * 6 + (2)] = LOAD_UINT(packedQ4.y);                   \n"
+    "  packedVals[(2) * 6 + (3)] = LOAD_UINT(packedQ4.z);                   \n"
+    "  packedVals[(3) * 6 + (3)] = LOAD_UINT(packedQ4.w);                   \n"
+    "                                                                       \n"
+    "  vec4 edges[3];                                                       \n"
+    "  if (bool(packedVals[(2) * 6 + (2)]) ||                               \n"
+    "      bool(packedVals[(3) * 6 + (2)])) {                               \n"
+    "    UVEC4 packedQ1 = texelFetchOffset(g_src0Texture4Uint,              \n"
+    "                                      screenPosI.xy, 0, ivec2(0, -1)); \n"
+    "    packedVals[(2) * 6 + (0)] = LOAD_UINT(packedQ1.x);                 \n"
+    "    packedVals[(3) * 6 + (0)] = LOAD_UINT(packedQ1.y);                 \n"
+    "    packedVals[(2) * 6 + (1)] = LOAD_UINT(packedQ1.z);                 \n"
+    "    packedVals[(3) * 6 + (1)] = LOAD_UINT(packedQ1.w);                 \n"
+    "  }                                                                    \n"
+    "                                                                       \n"
+    "  if (bool(packedVals[(2) * 6 + (2)]) ||                               \n"
+    "      bool(packedVals[(2) * 6 + (3)])) {                               \n"
+    "    UVEC4 packedQ3 = texelFetchOffset(g_src0Texture4Uint,              \n"
+    "                                      screenPosI.xy, 0, ivec2(-1, 0)); \n"
+    "    packedVals[(0) * 6 + (2)] = LOAD_UINT(packedQ3.x);                 \n"
+    "    packedVals[(1) * 6 + (2)] = LOAD_UINT(packedQ3.y);                 \n"
+    "    packedVals[(0) * 6 + (3)] = LOAD_UINT(packedQ3.z);                 \n"
+    "    packedVals[(1) * 6 + (3)] = LOAD_UINT(packedQ3.w);                 \n"
+    "  }                                                                    \n"
+    "                                                                       \n"
+    "  if (bool(packedVals[(2) * 6 + (2)])) {                               \n"
+    "    CollectEdges(2, 2, edges, packedVals);                             \n"
+    "    uint pe = PruneNonDominantEdges(edges);                            \n"
+    "    if (pe != 0u) {                                                    \n"
+    "      imageStore(g_resultTexture, 2 * screenPosI.xy + ivec2(0, 0),     \n"
+    "                 vec4(float(0x80u | pe) / 255.0, 0, 0, 0));            \n"
+    "    }                                                                  \n"
+    "  }                                                                    \n"
+    "                                                                       \n"
+    "  if (bool(packedVals[(3) * 6 + (2)]) ||                               \n"
+    "      bool(packedVals[(3) * 6 + (3)])) {                               \n"
+    "    UVEC4 packedQ5 = texelFetchOffset(g_src0Texture4Uint,              \n"
+    "                                      screenPosI.xy, 0, ivec2(1, 0));  \n"
+    "    packedVals[(4) * 6 + (2)] = LOAD_UINT(packedQ5.x);                 \n"
+    "    packedVals[(5) * 6 + (2)] = LOAD_UINT(packedQ5.y);                 \n"
+    "    packedVals[(4) * 6 + (3)] = LOAD_UINT(packedQ5.z);                 \n"
+    "    packedVals[(5) * 6 + (3)] = LOAD_UINT(packedQ5.w);                 \n"
+    "  }                                                                    \n"
+    "                                                                       \n"
+    "  if (bool(packedVals[(3) * 6 + (2)])) {                               \n"
+    "    UVEC4 packedQ2 = texelFetchOffset(g_src0Texture4Uint,              \n"
+    "                                      screenPosI.xy, 0, ivec2(1, -1)); \n"
+    "    packedVals[(4) * 6 + (0)] = LOAD_UINT(packedQ2.x);                 \n"
+    "    packedVals[(5) * 6 + (0)] = LOAD_UINT(packedQ2.y);                 \n"
+    "    packedVals[(4) * 6 + (1)] = LOAD_UINT(packedQ2.z);                 \n"
+    "    packedVals[(5) * 6 + (1)] = LOAD_UINT(packedQ2.w);                 \n"
+    "                                                                       \n"
+    "    CollectEdges(3, 2, edges, packedVals);                             \n"
+    "    uint pe = PruneNonDominantEdges(edges);                            \n"
+    "    if (pe != 0u) {                                                    \n"
+    "      imageStore(g_resultTexture, 2 * screenPosI.xy + ivec2(1, 0),     \n"
+    "                 vec4(float(0x80u | pe) / 255.0, 0, 0, 0));            \n"
+    "    }                                                                  \n"
+    "  }                                                                    \n"
+    "                                                                       \n"
+    "  if (bool(packedVals[(2) * 6 + (3)]) ||                               \n"
+    "      bool(packedVals[(3) * 6 + (3)])) {                               \n"
+    "    UVEC4 packedQ7 = texelFetchOffset(g_src0Texture4Uint,              \n"
+    "                                      screenPosI.xy, 0, ivec2(0, 1));  \n"
+    "    packedVals[(2) * 6 + (4)] = LOAD_UINT(packedQ7.x);                 \n"
+    "    packedVals[(3) * 6 + (4)] = LOAD_UINT(packedQ7.y);                 \n"
+    "    packedVals[(2) * 6 + (5)] = LOAD_UINT(packedQ7.z);                 \n"
+    "    packedVals[(3) * 6 + (5)] = LOAD_UINT(packedQ7.w);                 \n"
+    "  }                                                                    \n"
+    "                                                                       \n"
+    "  if (bool(packedVals[(2) * 6 + (3)])) {                               \n"
+    "    UVEC4 packedQ6 = texelFetchOffset(g_src0Texture4Uint,              \n"
+    "                                      screenPosI.xy, 0, ivec2(-1, -1));\n"
+    "    packedVals[(0) * 6 + (4)] = LOAD_UINT(packedQ6.x);                 \n"
+    "    packedVals[(1) * 6 + (4)] = LOAD_UINT(packedQ6.y);                 \n"
+    "    packedVals[(0) * 6 + (5)] = LOAD_UINT(packedQ6.z);                 \n"
+    "    packedVals[(1) * 6 + (5)] = LOAD_UINT(packedQ6.w);                 \n"
+    "                                                                       \n"
+    "    CollectEdges(2, 3, edges, packedVals);                             \n"
+    "    uint pe = PruneNonDominantEdges(edges);                            \n"
+    "    if (pe != 0u) {                                                    \n"
+    "      imageStore(g_resultTexture, 2 * screenPosI.xy + ivec2(0, 1),     \n"
+    "                 vec4(float(0x80u | pe) / 255.0, 0, 0, 0));            \n"
+    "    }                                                                  \n"
+    "  }                                                                    \n"
+    "                                                                       \n"
+    "  if (bool(packedVals[(3) * 6 + (3)])) {                               \n"
+    "    CollectEdges(3, 3, edges, packedVals);                             \n"
+    "    uint pe = PruneNonDominantEdges(edges);                            \n"
+    "    if (pe != 0u) {                                                    \n"
+    "      imageStore(g_resultTexture, 2 * screenPosI.xy + ivec2(1, 1),     \n"
+    "                 vec4(float(0x80u | pe) / 255.0, 0, 0, 0));            \n"
+    "    }                                                                  \n"
+    "  }                                                                    \n"
+    "}                                                                      \n"
+    "#endif  // DETECT_EDGES2                                               \n"
+    "                                                                       \n"
+    "#ifdef COMBINE_EDGES                                                   \n"
+    "void CombineEdges() {                                                  \n"
+    "  ivec3 screenPosIBase = ivec3(ivec2(gl_FragCoord.xy) * 2, 0);         \n"
+    "  vec3 screenPosBase = vec3(screenPosIBase);                           \n"
+    "  uint packedEdgesArray[3 * 3];                                        \n"
+    "                                                                       \n"
+    "  // use only if it has the 'prev frame' flag:[sample * 255.0 - 127.5] \n"
+    "  //-> if it has the last bit flag (128), it's going to stay above 0   \n"
+    "  uvec4 sampA = uvec4(                                                 \n"
+    "      textureGatherOffset(g_src0TextureFlt,                            \n"
+    "                          screenPosBase.xy * g_OneOverScreenSize,      \n"
+    "                          ivec2(1, 0)) * 255.0 - 127.5);               \n"
+    "  uvec4 sampB = uvec4(                                                 \n"
+    "      textureGatherOffset(g_src0TextureFlt,                            \n"
+    "                          screenPosBase.xy * g_OneOverScreenSize,      \n"
+    "                          ivec2(0, 1)) * 255.0 - 127.5);               \n"
+    "  uint sampC = uint(                                                   \n"
+    "      texelFetchOffset(g_src0TextureFlt, screenPosIBase.xy, 0,         \n"
+    "                       ivec2(1, 1)).r * 255.0 - 127.5);                \n"
+    "                                                                       \n"
+    "  packedEdgesArray[(0) * 3 + (0)] = 0u;                                \n"
+    "  packedEdgesArray[(1) * 3 + (0)] = sampA.w;                           \n"
+    "  packedEdgesArray[(2) * 3 + (0)] = sampA.z;                           \n"
+    "  packedEdgesArray[(1) * 3 + (1)] = sampA.x;                           \n"
+    "  packedEdgesArray[(2) * 3 + (1)] = sampA.y;                           \n"
+    "  packedEdgesArray[(0) * 3 + (1)] = sampB.w;                           \n"
+    "  packedEdgesArray[(0) * 3 + (2)] = sampB.x;                           \n"
+    "  packedEdgesArray[(1) * 3 + (2)] = sampB.y;                           \n"
+    "  packedEdgesArray[(2) * 3 + (2)] = sampC;                             \n"
+    "                                                                       \n"
+    "  uvec4 pixelsC = uvec4(packedEdgesArray[(1 + 0) * 3 + (1 + 0)],       \n"
+    "                        packedEdgesArray[(1 + 1) * 3 + (1 + 0)],       \n"
+    "                        packedEdgesArray[(1 + 0) * 3 + (1 + 1)],       \n"
+    "                        packedEdgesArray[(1 + 1) * 3 + (1 + 1)]);      \n"
+    "  uvec4 pixelsL = uvec4(packedEdgesArray[(0 + 0) * 3 + (1 + 0)],       \n"
+    "                        packedEdgesArray[(0 + 1) * 3 + (1 + 0)],       \n"
+    "                        packedEdgesArray[(0 + 0) * 3 + (1 + 1)],       \n"
+    "                        packedEdgesArray[(0 + 1) * 3 + (1 + 1)]);      \n"
+    "  uvec4 pixelsU = uvec4(packedEdgesArray[(1 + 0) * 3 + (0 + 0)],       \n"
+    "                        packedEdgesArray[(1 + 1) * 3 + (0 + 0)],       \n"
+    "                        packedEdgesArray[(1 + 0) * 3 + (0 + 1)],       \n"
+    "                        packedEdgesArray[(1 + 1) * 3 + (0 + 1)]);      \n"
+    "                                                                       \n"
+    "  uvec4 outEdge4 =                                                     \n"
+    "      pixelsC | ((pixelsL & 0x01u) << 2u) | ((pixelsU & 0x02u) << 2u); \n"
+    "  vec4 outEdge4Flt = vec4(outEdge4) / 255.0;                           \n"
+    "                                                                       \n"
+    "  imageStore(g_resultTextureSlot2, screenPosIBase.xy + ivec2(0, 0),    \n"
+    "             outEdge4Flt.xxxx);                                        \n"
+    "  imageStore(g_resultTextureSlot2, screenPosIBase.xy + ivec2(1, 0),    \n"
+    "             outEdge4Flt.yyyy);                                        \n"
+    "  imageStore(g_resultTextureSlot2, screenPosIBase.xy + ivec2(0, 1),    \n"
+    "             outEdge4Flt.zzzz);                                        \n"
+    "  imageStore(g_resultTextureSlot2, screenPosIBase.xy + ivec2(1, 1),    \n"
+    "             outEdge4Flt.wwww);                                        \n"
+    "                                                                       \n"
+    "  // uvec4 numberOfEdges4 = uvec4(bitCount(outEdge4));                 \n"
+    "  // gl_FragDepth =                                                    \n"
+    "  //     any(greaterThan(numberOfEdges4, uvec4(1))) ? 1.0 : 0.0;       \n"
+    "                                                                       \n"
+    "  gl_FragDepth =                                                       \n"
+    "      any(greaterThan(outEdge4, uvec4(1))) ? 1.0 : 0.0;                \n"
+    "}                                                                      \n"
+    "#endif  // COMBINE_EDGES                                               \n"
+    "                                                                       \n"
+    "#ifdef BLUR_EDGES                                                      \n"
+    "layout(early_fragment_tests) in;                                       \n"
+    "void BlurEdges() {                                                     \n"
+    "  int _i;                                                              \n"
+    "                                                                       \n"
+    "  ivec3 screenPosIBase = ivec3(ivec2(gl_FragCoord.xy) * 2, 0);         \n"
+    "  vec3 screenPosBase = vec3(screenPosIBase);                           \n"
+    "  uint forFollowUpCount = 0u;                                          \n"
+    "  ivec4 forFollowUpCoords[4];                                          \n"
+    "                                                                       \n"
+    "  uint packedEdgesArray[4 * 4];                                        \n"
+    "                                                                       \n"
+    "  uvec4 sampA = uvec4(                                                 \n"
+    "      textureGatherOffset(g_src0TextureFlt,                            \n"
+    "                          screenPosBase.xy * g_OneOverScreenSize,      \n"
+    "                          ivec2(0, 0)) *255.5);                        \n"
+    "  uvec4 sampB = uvec4(                                                 \n"
+    "      textureGatherOffset(g_src0TextureFlt,                            \n"
+    "                          screenPosBase.xy * g_OneOverScreenSize,      \n"
+    "                          ivec2(2, 0)) *255.5);                        \n"
+    "  uvec4 sampC = uvec4(                                                 \n"
+    "      textureGatherOffset(g_src0TextureFlt,                            \n"
+    "                          screenPosBase.xy * g_OneOverScreenSize,      \n"
+    "                          ivec2(0, 2)) *255.5);                        \n"
+    "  uvec4 sampD = uvec4(                                                 \n"
+    "      textureGatherOffset(g_src0TextureFlt,                            \n"
+    "                          screenPosBase.xy * g_OneOverScreenSize,      \n"
+    "                          ivec2(2, 2)) *255.5);                        \n"
+    "                                                                       \n"
+    "  packedEdgesArray[(0) * 4 + (0)] = sampA.w;                           \n"
+    "  packedEdgesArray[(1) * 4 + (0)] = sampA.z;                           \n"
+    "  packedEdgesArray[(0) * 4 + (1)] = sampA.x;                           \n"
+    "  packedEdgesArray[(1) * 4 + (1)] = sampA.y;                           \n"
+    "  packedEdgesArray[(2) * 4 + (0)] = sampB.w;                           \n"
+    "  packedEdgesArray[(3) * 4 + (0)] = sampB.z;                           \n"
+    "  packedEdgesArray[(2) * 4 + (1)] = sampB.x;                           \n"
+    "  packedEdgesArray[(3) * 4 + (1)] = sampB.y;                           \n"
+    "  packedEdgesArray[(0) * 4 + (2)] = sampC.w;                           \n"
+    "  packedEdgesArray[(1) * 4 + (2)] = sampC.z;                           \n"
+    "  packedEdgesArray[(0) * 4 + (3)] = sampC.x;                           \n"
+    "  packedEdgesArray[(1) * 4 + (3)] = sampC.y;                           \n"
+    "  packedEdgesArray[(2) * 4 + (2)] = sampD.w;                           \n"
+    "  packedEdgesArray[(3) * 4 + (2)] = sampD.z;                           \n"
+    "  packedEdgesArray[(2) * 4 + (3)] = sampD.x;                           \n"
+    "  packedEdgesArray[(3) * 4 + (3)] = sampD.y;                           \n"
+    "                                                                       \n"
+    "  for (_i = 0; _i < 4; _i++) {                                         \n"
+    "    int _x = _i % 2;                                                   \n"
+    "    int _y = _i / 2;                                                   \n"
+    "                                                                       \n"
+    "    ivec3 screenPosI = screenPosIBase + ivec3(_x, _y, 0);              \n"
+    "                                                                       \n"
+    "    uint packedEdgesC = packedEdgesArray[(1 + _x) * 4 + (1 + _y)];     \n"
+    "                                                                       \n"
+    "    uvec4 edges = UnpackEdge(packedEdgesC);                            \n"
+    "    vec4 edgesFlt = vec4(edges);                                       \n"
+    "                                                                       \n"
+    "    float numberOfEdges = dot(edgesFlt, vec4(1, 1, 1, 1));             \n"
+    "    if (numberOfEdges < 2.0)                                           \n"
+    "      continue;                                                        \n"
+    "                                                                       \n"
+    "    float fromRight = edgesFlt.r;                                      \n"
+    "    float fromBelow = edgesFlt.g;                                      \n"
+    "    float fromLeft = edgesFlt.b;                                       \n"
+    "    float fromAbove = edgesFlt.a;                                      \n"
+    "                                                                       \n"
+    "    vec4 xFroms = vec4(fromBelow, fromAbove, fromRight, fromLeft);     \n"
+    "                                                                       \n"
+    "    float blurCoeff = 0.0;                                             \n"
+    "                                                                       \n"
+    "    // These are additional blurs that complement the main line-based  \n"
+    "    // blurring; Unlike line-based, these do not necessarily preserve  \n"
+    "    // the total amount of screen colour as they will take             \n"
+    "    // neighbouring pixel colours and apply them to the one currently  \n"
+    "    // processed.                                                      \n"
+    "                                                                       \n"
+    "    // 1.) L-like shape.                                               \n"
+    "    // For this shape, the total amount of screen colour will be       \n"
+    "    // preserved when this is a part of a (zigzag) diagonal line as the\n"
+    "    // corners from the other side  will do the same and take some of  \n"
+    "    // the current pixel's colour in return.                           \n"
+    "    // However, in the case when this is an actual corner, the pixel's \n"
+    "    // colour will be partially overwritten by it's 2 neighbours.      \n"
+    "    // if( numberOfEdges > 1.0 )                                       \n"
+    "    {                                                                  \n"
+    "      // with value of 0.15, the pixel will retain approx 77% of its   \n"
+    "      // colour and the remaining 23% will come from its 2 neighbours  \n"
+    "      // (which are likely to be blurred too in the opposite direction)\n"
+    "      blurCoeff = 0.08;                                                \n"
+    "                                                                       \n"
+    "      // Only do blending if it's L shape - if we're between two       \n"
+    "      // parallel edges, don't do anything                             \n"
+    "      blurCoeff *= (1.0 - fromBelow * fromAbove) *                     \n"
+    "                   (1.0 - fromRight * fromLeft);                       \n"
+    "    }                                                                  \n"
+    "                                                                       \n"
+    "    // 2.) U-like shape (surrounded with edges from 3 sides)           \n"
+    "    if (numberOfEdges > 2.0) {                                         \n"
+    "      // with value of 0.13, the pixel will retain approx 72% of its   \n"
+    "      // colour and the remaining 28% will be picked from its 3        \n"
+    "      // neighbours (which are unlikely to be blurred too but could be)\n"
+    "      blurCoeff = 0.11;                                                \n"
+    "    }                                                                  \n"
+    "                                                                       \n"
+    "    // 3.) Completely surrounded with edges from all 4 sides           \n"
+    "    if (numberOfEdges > 3.0) {                                         \n"
+    "      // with value of 0.07, the pixel will retain 78% of its colour   \n"
+    "      // and the remaining 22% will come from its 4 neighbours (which  \n"
+    "      // are unlikely to be blurred)                                   \n"
+    "      blurCoeff = 0.05;                                                \n"
+    "    }                                                                  \n"
+    "                                                                       \n"
+    "    if (blurCoeff == 0.0) {                                            \n"
+    "      // this avoids Z search below as well but that's ok because a Z  \n"
+    "      // shape will also always have some blurCoeff                    \n"
+    "      continue;                                                        \n"
+    "    }                                                                  \n"
+    "                                                                       \n"
+    "    vec4 blurMap = xFroms * blurCoeff;                                 \n"
+    "                                                                       \n"
+    "    vec4 pixelC = texelFetch(g_screenTexture, screenPosI.xy, 0);       \n"
+    "                                                                       \n"
+    "    const float centerWeight = 1.0;                                    \n"
+    "    float fromBelowWeight = blurMap.x;                                 \n"
+    "    float fromAboveWeight = blurMap.y;                                 \n"
+    "    float fromRightWeight = blurMap.z;                                 \n"
+    "    float fromLeftWeight  = blurMap.w;                                 \n"
+    "                                                                       \n"
+    "    // this would be the proper math for blending if we were handling  \n"
+    "    // lines (Zs) and mini kernel smoothing here, but since we're doing\n"
+    "    // lines separately, no need to complicate, just tweak the settings\n"
+    "    // float fromBelowWeight = (1.0 / (1.0 - blurMap.x)) - 1.0;        \n"
+    "    // float fromAboveWeight = (1.0 / (1.0 - blurMap.y)) - 1.0;        \n"
+    "    // float fromRightWeight = (1.0 / (1.0 - blurMap.z)) - 1.0;        \n"
+    "    // float fromLeftWeight  = (1.0 / (1.0 - blurMap.w)) - 1.0;        \n"
+    "                                                                       \n"
+    "    float fourWeightSum = dot(blurMap, vec4(1, 1, 1, 1));              \n"
+    "    float allWeightSum = centerWeight + fourWeightSum;                 \n"
+    "                                                                       \n"
+    "    vec4 color = vec4(0, 0, 0, 0);                                     \n"
+    "    if (fromLeftWeight > 0.0) {                                        \n"
+    "      vec3 pixelL = texelFetchOffset(g_screenTexture, screenPosI.xy, 0,\n"
+    "                                     ivec2(-1, 0)).rgb;                \n"
+    "      color.rgb += fromLeftWeight * pixelL;                            \n"
+    "    }                                                                  \n"
+    "    if (fromAboveWeight > 0.0) {                                       \n"
+    "      vec3 pixelT = texelFetchOffset(g_screenTexture, screenPosI.xy, 0,\n"
+    "                                     ivec2(0, -1)).rgb;                \n"
+    "      color.rgb += fromAboveWeight * pixelT;                           \n"
+    "    }                                                                  \n"
+    "    if (fromRightWeight > 0.0) {                                       \n"
+    "      vec3 pixelR = texelFetchOffset(g_screenTexture, screenPosI.xy, 0,\n"
+    "                                     ivec2(1, 0)).rgb;                 \n"
+    "      color.rgb += fromRightWeight * pixelR;                           \n"
+    "    }                                                                  \n"
+    "    if (fromBelowWeight > 0.0) {                                       \n"
+    "      vec3 pixelB = texelFetchOffset(g_screenTexture, screenPosI.xy, 0,\n"
+    "                                     ivec2(0, 1)).rgb;                 \n"
+    "      color.rgb += fromBelowWeight * pixelB;                           \n"
+    "    }                                                                  \n"
+    "                                                                       \n"
+    "    color /= fourWeightSum + 0.0001;                                   \n"
+    "    color.a = 1.0 - centerWeight / allWeightSum;                       \n"
+    "                                                                       \n"
+    "    color.rgb = mix(pixelC.rgb, color.rgb, color.a).rgb;               \n"
+    "#ifdef IN_GAMMA_CORRECT_MODE                                           \n"
+    "    color.rgb = D3DX_FLOAT3_to_SRGB(color.rgb);                        \n"
+    "#endif                                                                 \n"
+    "                                                                       \n"
+    "#ifdef DEBUG_OUTPUT_AAINFO                                             \n"
+    "    imageStore(g_resultTextureSlot2, screenPosI.xy,                    \n"
+    "               PackBlurAAInfo(screenPosI.xy, uint(numberOfEdges)));    \n"
+    "#endif                                                                 \n"
+    "    imageStore(g_resultTextureFlt4Slot1, screenPosI.xy,                \n"
+    "               vec4(color.rgb, pixelC.a));                             \n"
+    "                                                                       \n"
+    "    if (numberOfEdges == 2.0) {                                        \n"
+    "      uint packedEdgesL = packedEdgesArray[(0 + _x) * 4 + (1 + _y)];   \n"
+    "      uint packedEdgesT = packedEdgesArray[(1 + _x) * 4 + (0 + _y)];   \n"
+    "      uint packedEdgesR = packedEdgesArray[(2 + _x) * 4 + (1 + _y)];   \n"
+    "      uint packedEdgesB = packedEdgesArray[(1 + _x) * 4 + (2 + _y)];   \n"
+    "                                                                       \n"
+    "      bool isHorizontalA = ((packedEdgesC) == (0x01u | 0x02u)) &&      \n"
+    "         ((packedEdgesR & (0x01u | 0x08u)) == (0x08u));                \n"
+    "      bool isHorizontalB = ((packedEdgesC) == (0x01u | 0x08u)) &&      \n"
+    "         ((packedEdgesR & (0x01u | 0x02u)) == (0x02u));                \n"
+    "                                                                       \n"
+    "      bool isHCandidate = isHorizontalA || isHorizontalB;              \n"
+    "                                                                       \n"
+    "      bool isVerticalA = ((packedEdgesC) == (0x08u | 0x01u)) &&        \n"
+    "         ((packedEdgesT & (0x08u | 0x04u)) == (0x04u));                \n"
+    "      bool isVerticalB = ((packedEdgesC) == (0x08u | 0x04u)) &&        \n"
+    "         ((packedEdgesT & (0x08u | 0x01u)) == (0x01u));                \n"
+    "      bool isVCandidate = isVerticalA || isVerticalB;                  \n"
+    "                                                                       \n"
+    "      bool isCandidate = isHCandidate || isVCandidate;                 \n"
+    "                                                                       \n"
+    "      if (!isCandidate)                                                \n"
+    "        continue;                                                      \n"
+    "                                                                       \n"
+    "      bool horizontal = isHCandidate;                                  \n"
+    "                                                                       \n"
+    "      // what if both are candidates? do additional pruning (still not \n"
+    "      // 100% but gets rid of worst case errors)                       \n"
+    "      if (isHCandidate && isVCandidate)                                \n"
+    "        horizontal =                                                   \n"
+    "           (isHorizontalA && ((packedEdgesL & 0x02u) == 0x02u)) ||     \n"
+    "           (isHorizontalB && ((packedEdgesL & 0x08u) == 0x08u));       \n"
+    "                                                                       \n"
+    "      ivec2 offsetC;                                                   \n"
+    "      uint packedEdgesM1P0;                                            \n"
+    "      uint packedEdgesP1P0;                                            \n"
+    "      if (horizontal) {                                                \n"
+    "        packedEdgesM1P0 = packedEdgesL;                                \n"
+    "        packedEdgesP1P0 = packedEdgesR;                                \n"
+    "        offsetC = ivec2(2, 0);                                         \n"
+    "      } else {                                                         \n"
+    "        packedEdgesM1P0 = packedEdgesB;                                \n"
+    "        packedEdgesP1P0 = packedEdgesT;                                \n"
+    "        offsetC = ivec2(0, -2);                                        \n"
+    "      }                                                                \n"
+    "                                                                       \n"
+    "      uvec4 edgesM1P0 = UnpackEdge(packedEdgesM1P0);                   \n"
+    "      uvec4 edgesP1P0 = UnpackEdge(packedEdgesP1P0);                   \n"
+    "      uvec4 edgesP2P0 = UnpackEdge(uint(texelFetch(                    \n"
+    "         g_src0TextureFlt, screenPosI.xy + offsetC, 0).r * 255.5));    \n"
+    "                                                                       \n"
+    "      uvec4 arg0;                                                      \n"
+    "      uvec4 arg1;                                                      \n"
+    "      uvec4 arg2;                                                      \n"
+    "      uvec4 arg3;                                                      \n"
+    "      bool arg4;                                                       \n"
+    "                                                                       \n"
+    "      if (horizontal) {                                                \n"
+    "        arg0 = uvec4(edges);                                           \n"
+    "        arg1 = edgesM1P0;                                              \n"
+    "        arg2 = edgesP1P0;                                              \n"
+    "        arg3 = edgesP2P0;                                              \n"
+    "        arg4 = true;                                                   \n"
+    "      } else {                                                         \n"
+    "        // Reuse the same code for vertical (used for horizontal above)\n"
+    "        // but rotate input data 90º counter-clockwise, so that:       \n"
+    "        // left     becomes     bottom                                 \n"
+    "        // top      becomes     left                                   \n"
+    "        // right    becomes     top                                    \n"
+    "        // bottom   becomes     right                                  \n"
+    "                                                                       \n"
+    "        // we also have to rotate edges, thus .argb                    \n"
+    "        arg0 = uvec4(edges.argb);                                      \n"
+    "        arg1 = edgesM1P0.argb;                                         \n"
+    "        arg2 = edgesP1P0.argb;                                         \n"
+    "        arg3 = edgesP2P0.argb;                                         \n"
+    "        arg4 = false;                                                  \n"
+    "      }                                                                \n"
+    "                                                                       \n"
+    "      {                                                                \n"
+    "        ivec2 screenPos = screenPosI.xy;                               \n"
+    "        uvec4 _edges = arg0;                                           \n"
+    "        uvec4 _edgesM1P0 = arg1;                                       \n"
+    "        uvec4 _edgesP1P0 = arg2;                                       \n"
+    "        uvec4 _edgesP2P0 = arg3;                                       \n"
+    "        bool horizontal = arg4;                                        \n"
+    "        // Inverted Z case:                                            \n"
+    "        //   __                                                        \n"
+    "        //  X|                                                         \n"
+    "        // ¯¯                                                          \n"
+    "        bool isInvertedZ = false;                                      \n"
+    "        bool isNormalZ = false;                                        \n"
+    "        {                                                              \n"
+    "#ifndef SETTINGS_ALLOW_SHORT_Zs                                        \n"
+    "          // (1u-_edges.a) constraint can be removed; it was added for \n"
+    "          // some rare cases                                           \n"
+    "          uint isZShape = _edges.r * _edges.g * _edgesM1P0.g *         \n"
+    "             _edgesP1P0.a *_edgesP2P0.a * (1u - _edges.b) *            \n"
+    "              (1u - _edgesP1P0.r) * (1u - _edges.a) *                  \n"
+    "              (1u - _edgesP1P0.g);                                     \n"
+    "#else                                                                  \n"
+    "          uint isZShape = _edges.r * _edges.g * _edgesP1P0.a *         \n"
+    "              (1u - _edges.b) * (1u - _edgesP1P0.r) * (1u - _edges.a) *\n"
+    "                          (1u - _edgesP1P0.g);                         \n"
+    "          isZShape *= (_edgesM1P0.g + _edgesP2P0.a);                   \n"
+    "                          // and at least one of these need to be there\n"
+    "#endif                                                                 \n"
+    "          if (isZShape > 0u) {                                         \n"
+    "            isInvertedZ = true;                                        \n"
+    "          }                                                            \n"
+    "        }                                                              \n"
+    "                                                                       \n"
+    "        // Normal Z case:                                              \n"
+    "        // __                                                          \n"
+    "        //  X|                                                         \n"
+    "        //   ¯¯                                                        \n"
+    "        {                                                              \n"
+    "#ifndef SETTINGS_ALLOW_SHORT_Zs                                        \n"
+    "          uint isZShape = _edges.r * _edges.a * _edgesM1P0.a *         \n"
+    "              _edgesP1P0.g * _edgesP2P0.g * (1u - _edges.b) *          \n"
+    "              (1u - _edgesP1P0.r) * (1u - _edges.g) *                  \n"
+    "              (1u - _edgesP1P0.a);                                     \n"
+    "#else                                                                  \n"
+    "          uint isZShape = _edges.r * _edges.a * _edgesP1P0.g *         \n"
+    "              (1u - _edges.b) * (1u - _edgesP1P0.r) * (1u - _edges.g) *\n"
+    "              (1u - _edgesP1P0.a);                                     \n"
+    "          isZShape *=                                                  \n"
+    "              (_edgesM1P0.a + _edgesP2P0.g);                           \n"
+    "                          // and at least one of these need to be there\n"
+    "#endif                                                                 \n"
+    "                                                                       \n"
+    "          if (isZShape > 0u) {                                         \n"
+    "            isNormalZ = true;                                          \n"
+    "          }                                                            \n"
+    "        }                                                              \n"
+    "                                                                       \n"
+    "        bool isZ = isInvertedZ || isNormalZ;                           \n"
+    "        if (isZ) {                                                     \n"
+    "          forFollowUpCoords[forFollowUpCount++] =                      \n"
+    "              ivec4(screenPosI.xy, horizontal, isInvertedZ);           \n"
+    "        }                                                              \n"
+    "      }                                                                \n"
+    "    }                                                                  \n"
+    "  }                                                                    \n"
+    "                                                                       \n"
+    "  // This code below is the only potential bug with this algorithm :   \n"
+    "  // it HAS to be executed after the simple shapes above. It used to be\n"
+    "  // executed as separate compute shader (by storing the packed        \n"
+    "  // 'forFollowUpCoords' in an append buffer and  consuming it later)  \n"
+    "  // but the whole thing (append/consume buffers, using CS) appears to \n"
+    "  // be too inefficient on most hardware.                              \n"
+    "  // However, it seems to execute fairly efficiently here and without  \n"
+    "  // any issues, although there is no 100% guarantee that this code    \n"
+    "  // below will execute across all pixels (it has a c_maxLineLength    \n"
+    "  // wide kernel) after other shaders processing same pixels have done \n"
+    "  // solving simple shapes. It appears to work regardless, across all  \n"
+    "  // hardware; pixels with 1-edge or two opposing edges are ignored by \n"
+    "  // simple  shapes anyway and other shapes stop the long line         \n"
+    "  // algorithm from executing the only danger appears to be simple     \n"
+    "  // shape L's colliding with Z shapes from neighbouring pixels but I  \n"
+    "  // couldn't reproduce any problems on any hardware.                  \n"
+    "  for (uint _i = 0u; _i < forFollowUpCount; _i++) {                    \n"
+    "    ivec4 data = forFollowUpCoords[_i];                                \n"
+    "    ProcessDetectedZ(data.xy, bool(data.z), bool(data.w));             \n"
+    "  }                                                                    \n"
+    "}                                                                      \n"
+    "#endif  // BLUR_EDGES                                                  \n"
+    "                                                                       \n"
+    "#ifdef DISPLAY_EDGES                                                   \n"
+    "layout(location = 0) out vec4 color;                                   \n"
+    "layout(location = 1) out vec4 hasEdges;                                \n"
+    "void DisplayEdges() {                                                  \n"
+    "  ivec2 screenPosI = ivec2(gl_FragCoord.xy);                           \n"
+    "                                                                       \n"
+    "  uint packedEdges, shapeType;                                         \n"
+    "  UnpackBlurAAInfo(texelFetch(g_src0TextureFlt, screenPosI, 0).r,      \n"
+    "                   packedEdges, shapeType);                            \n"
+    "                                                                       \n"
+    "  vec4 edges = vec4(UnpackEdge(packedEdges));                          \n"
+    "  if (any(greaterThan(edges.xyzw, vec4(0)))) {                         \n"
+    "#ifdef IN_BGR_MODE                                                     \n"
+    "    color = c_edgeDebugColours[shapeType].bgra;                        \n"
+    "#else                                                                  \n"
+    "    color = c_edgeDebugColours[shapeType];                             \n"
+    "#endif                                                                 \n"
+    "    hasEdges = vec4(1.0);                                              \n"
+    "  } else {                                                             \n"
+    "    color = vec4(0);                                                   \n"
+    "    hasEdges = vec4(0.0);                                              \n"
+    "  }                                                                    \n"
+    "}                                                                      \n"
+    "#endif  // DISPLAY_EDGES                                               \n"
+    "                                                                       \n"
+    "void main() {                                                          \n"
+    "#ifdef DETECT_EDGES1                                                   \n"
+    "  DetectEdges1();                                                      \n"
+    "#endif                                                                 \n"
+    "#if defined DETECT_EDGES2                                              \n"
+    "  DetectEdges2();                                                      \n"
+    "#endif                                                                 \n"
+    "#if defined COMBINE_EDGES                                              \n"
+    "  CombineEdges();                                                      \n"
+    "#endif                                                                 \n"
+    "#if defined BLUR_EDGES                                                 \n"
+    "  BlurEdges();                                                         \n"
+    "#endif                                                                 \n"
+    "#if defined DISPLAY_EDGES                                              \n"
+    "  DisplayEdges();                                                      \n"
+    "#endif                                                                 \n"
+    "}                                                                      \n";
+
+const char* ApplyFramebufferAttachmentCMAAINTELResourceManager::copy_frag_str_ =
+    "precision highp float;                                                 \n"
+    "layout(binding = 0) uniform highp sampler2D inTexture;                 \n"
+    "layout(location = 0) out vec4 outColor;                                \n"
+    "#ifdef GL_ES                                                           \n"
+    "layout(binding = 0, rgba8) restrict writeonly uniform highp            \n"
+    "                                                   image2D outTexture; \n"
+    "#else                                                                  \n"
+    "layout(rgba8) restrict writeonly uniform highp image2D outTexture;     \n"
+    "#endif                                                                 \n"
+    "                                                                       \n"
+    "void main() {                                                          \n"
+    "  ivec2 screenPosI = ivec2( gl_FragCoord.xy );                         \n"
+    "  vec4 pixel = texelFetch(inTexture, screenPosI, 0);                   \n"
+    "#ifdef OUT_FBO                                                         \n"
+    "  outColor = pixel;                                                    \n"
+    "#else                                                                  \n"
+    "  imageStore(outTexture, screenPosI, pixel);                           \n"
+    "#endif                                                                 \n"
+    "}                                                                      \n";
+
+}  // namespace gpu