Revert "gpu, cmaa: copy RGBA8 texture via glCopyTexSubImage2D() instead of imageStore()."

gpu/command_buffer/service/gles2_cmd_apply_framebuffer_attachment_cmaa_intel.cc

 // 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/framebuffer_manager.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "ui/gl/gl_context.h"
@@ skipping 10 matching lines @@
     : 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),
-      edges0_shader_result_rgba_texture_slot1_(0),
-      edges0_shader_target_texture_slot2_(0),
-      edges1_shader_result_edge_texture_(0),
-      process_and_apply_shader_result_rgba_texture_slot1_(0),
-      edges_combine_shader_result_edge_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(
     gles2::GLES2Decoder* decoder) {
   DCHECK(decoder);
   is_gles31_compatible_ =
       decoder->GetGLContext()->GetVersionInfo()->IsAtLeastGLES(3, 1);
 
+  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);
@@ skipping 95 matching lines @@
       CreateProgram(edge2.str().c_str(), vert_str_, cmaa_frag_c_str);
 
   combineEdges << defines.str() << "#define COMBINE_EDGES\n";
   edges_combine_shader_ =
       CreateProgram(combineEdges.str().c_str(), vert_str_, cmaa_frag_c_str);
 
   blur << defines.str() << "#define BLUR_EDGES\n";
   process_and_apply_shader_ =
       CreateProgram(blur.str().c_str(), vert_str_, cmaa_frag_c_str);
 
-  edges0_shader_result_rgba_texture_slot1_ =
-      glGetUniformLocation(edges0_shader_, "g_resultRGBATextureSlot1");
-  edges0_shader_target_texture_slot2_ =
-      glGetUniformLocation(edges0_shader_, "g_targetTextureSlot2");
-  edges1_shader_result_edge_texture_ =
-      glGetUniformLocation(edges1_shader_, "g_resultEdgeTexture");
-  edges_combine_shader_result_edge_texture_ =
-      glGetUniformLocation(edges_combine_shader_, "g_resultEdgeTexture");
-  process_and_apply_shader_result_rgba_texture_slot1_ = glGetUniformLocation(
-      process_and_apply_shader_, "g_resultRGBATextureSlot1");
+  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(copy_to_image_shader_);
+  glDeleteProgram(copy_to_framebuffer_shader_);
   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(gles2::GLES2Decoder* decoder,
                                         gles2::Framebuffer* framebuffer) {
   DCHECK(decoder);
   DCHECK(initialized_);
   if (!framebuffer)
     return;
 
-  glDisable(GL_SCISSOR_TEST);
-  glDisable(GL_STENCIL_TEST);
-  glDisable(GL_CULL_FACE);
-  glDisable(GL_BLEND);
+  GLuint last_framebuffer = framebuffer->service_id();
 
   // Process each color attachment of the current draw framebuffer.
   uint32_t max_draw_buffers = decoder->GetContextGroup()->max_draw_buffers();
   for (uint32_t i = 0; i < max_draw_buffers; i++) {
     const gles2::Framebuffer::Attachment* attachment =
         framebuffer->GetAttachment(GL_COLOR_ATTACHMENT0 + i);
     if (attachment && attachment->IsTextureAttachment()) {
       // Get the texture info.
       GLuint source_texture_client_id = attachment->object_name();
       GLuint source_texture = 0;
       if (!decoder->GetServiceTextureId(source_texture_client_id,
                                         &source_texture))
         continue;
       GLsizei width = attachment->width();
       GLsizei height = attachment->height();
       GLenum internal_format = attachment->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) {
-        ApplyCMAAEffectTexture(source_texture, rgba8_texture_, do_copy);
+        ApplyCMAAEffectTexture(rgba8_texture_, rgba8_texture_);
       } else {
-        ApplyCMAAEffectTexture(source_texture, source_texture, do_copy);
+        ApplyCMAAEffectTexture(source_texture, source_texture);
       }
 
       // Copy rgba8_texture_ to source_texture
       if (do_copy) {
-        // copy_framebuffer_ always binds rgba8_texture_
+        // 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_);
-        CopyTexture(source_texture);
+        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);
       }
-      decoder->RestoreTextureState(source_texture);
     }
   }
 
   // Restore state
   decoder->RestoreAllAttributes();
   decoder->RestoreTextureUnitBindings(0);
   decoder->RestoreTextureUnitBindings(1);
   decoder->RestoreActiveTexture();
   decoder->RestoreProgramBindings();
   decoder->RestoreBufferBindings();
   decoder->RestoreFramebufferBindings();
   decoder->RestoreGlobalState();
 }
 
 void ApplyFramebufferAttachmentCMAAINTELResourceManager::ApplyCMAAEffectTexture(
     GLuint source_texture,
-    GLuint dest_texture,
-    bool do_copy) {
+    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_;
@@ skipping 25 matching lines @@
   // 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_resultRGBATextureSlot1    working_color_texture_       image1
+  //  image2D g_resultTextureFlt4Slot1    working_color_texture_       image1
   GLenum edge_format = supports_r8_image_ ? GL_R8 : GL_R32F;
 
   {
     glUseProgram(edges0_shader_);
     glUniform2f(0, 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(edges0_shader_result_rgba_texture_slot1_, 1);
-      glUniform1i(edges0_shader_target_texture_slot2_, 2);
+      glUniform1i(edges1_shader_result_texture_float4_slot1_, 1);
     }
     glBindImageTextureEXT(1, working_color_texture_, 0, GL_FALSE, 0,
                           GL_WRITE_ONLY, GL_RGBA8);
-    if (do_copy) {
-      glUniform1i(2, GL_TRUE);
-      glBindImageTextureEXT(2, dest_texture, 0, GL_FALSE, 0, GL_WRITE_ONLY,
-                            GL_RGBA8);
-    } else {
-      glUniform1i(2, GL_FALSE);
-    }
 
     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_resultEdgeTexture         edge_texture_b               image0
+  //  image2D g_resultTexture             edge_texture_b               image0
   {
     glUseProgram(edges1_shader_);
     glUniform2f(0, 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_edge_texture_, 0);
+      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.
   //  - 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_resultEdgeTexture         edge_texture_a               image2
+  //  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 mark depth 1 value on all pixels with any edge
     // and also copy source color data but only on edge pixels
     glUseProgram(edges_combine_shader_);
     glUniform2f(0, 1.0f / width_, 1.0f / height_);
     glDepthMask(GL_TRUE);
     glDepthFunc(GL_LESS);
     glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
 
     if (!is_gles31_compatible_) {
-      glUniform1i(edges_combine_shader_result_edge_texture_, 0);
+      glUniform1i(edges_combine_shader_result_texture_slot2_, 2);
     }
-    glBindImageTextureEXT(0, edge_texture_a, 0, GL_FALSE, 0, GL_WRITE_ONLY,
+    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_resultRGBATextureSlot1             dest_texture                image1
+  //  g_resultTextureFlt4Slot1             dest_texture                image1
   //  gl_FragDepth                         mini4_edge_texture_         fbo.depth
   {
     glUseProgram(process_and_apply_shader_);
     glUniform2f(0, 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_rgba_texture_slot1_, 1);
+      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);
@@ skipping 17 matching lines @@
 
   ReleaseTextures();
 
   height_ = height;
   width_ = width;
 
   glGenFramebuffersEXT(1, &copy_framebuffer_);
   glGenTextures(1, &rgba8_texture_);
   glBindTexture(GL_TEXTURE_2D, rgba8_texture_);
   glTexStorage2DEXT(GL_TEXTURE_2D, 1, GL_RGBA8, width, height);
-  glBindFramebufferEXT(GL_FRAMEBUFFER, copy_framebuffer_);
-  glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
-                            rgba8_texture_, 0);
 
   // 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_);
@@ skipping 50 matching lines @@
     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 dest) {
+    GLint source,
+    GLint dest,
+    bool via_fbo) {
+  glViewport(0, 0, width_, height_);
   glActiveTexture(GL_TEXTURE0);
-  glBindTexture(GL_TEXTURE_2D, dest);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+  glBindTexture(GL_TEXTURE_2D, source);
 
-  glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, width_, height_);
+  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_DEPTH_TEST);
+    glDisable(GL_STENCIL_TEST);
+    glDisable(GL_CULL_FACE);
+    glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+    glDepthMask(GL_FALSE);
+    glDisable(GL_BLEND);
+    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);
@@ skipping 104 matching lines @@
 
     \n#define SETTINGS_ALLOW_SHORT_Zs 1\n
     \n#define EDGE_DETECT_THRESHOLD 13.0f\n
     \n#define saturate(x) clamp((x), 0.0, 1.0)\n
 
     // bind to a uniform buffer bind point 0
     layout(location = 0) uniform vec2 g_OneOverScreenSize;
     \n#ifndef EDGE_DETECT_THRESHOLD\n
     layout(location = 1) uniform float g_ColorThreshold;
     \n#endif\n
-    \n#ifdef DETECT_EDGES1\n
-    layout(location = 2) uniform int g_DoCopy;
-    \n#endif\n
 
     \n#ifdef SUPPORTS_USAMPLER2D\n
     \n#define USAMPLER usampler2D\n
     \n#define UVEC4 uvec4\n
     \n#define LOAD_UINT(arg) arg\n
     \n#define STORE_UVEC4(arg) arg\n
     \n#else\n
     \n#define USAMPLER sampler2D\n
     \n#define UVEC4 vec4\n
     \n#define LOAD_UINT(arg) uint(arg * 255.0f)\n
     \n#define STORE_UVEC4(arg) vec4(float(arg.x) / 255.0f,
                                     float(arg.y) / 255.0f,
                                     float(arg.z) / 255.0f,
                                     float(arg.w) / 255.0f)\n
     \n#endif\n
 
     // bind to texture stage 0/1
     layout(binding = 0) uniform highp sampler2D g_screenTexture;
     layout(binding = 1) uniform highp sampler2D g_src0TextureFlt;
     layout(binding = 1) uniform highp USAMPLER g_src0Texture4Uint;
 
     // bind to image stage 0/1/2
     \n#ifdef GL_ES\n
     layout(binding = 0, EDGE_READ_FORMAT) restrict writeonly uniform highp
-        image2D g_resultEdgeTexture;
+        image2D g_resultTexture;
     layout(binding = 1, rgba8) restrict writeonly uniform highp
-        image2D g_resultRGBATextureSlot1;
-    layout(binding = 2, rgba8) restrict writeonly uniform highp
-        image2D g_targetTextureSlot2;
+        image2D g_resultTextureFlt4Slot1;
+    layout(binding = 2, EDGE_READ_FORMAT) restrict writeonly uniform highp
+        image2D g_resultTextureSlot2;
     \n#else\n
     layout(EDGE_READ_FORMAT) restrict writeonly uniform highp
-        image2D g_resultEdgeTexture;
+        image2D g_resultTexture;
     layout(rgba8) restrict writeonly uniform highp
-        image2D g_resultRGBATextureSlot1;
-    layout(rgba8) restrict writeonly uniform highp
-        image2D g_targetTextureSlot2;
+        image2D g_resultTextureFlt4Slot1;
+    layout(EDGE_READ_FORMAT) restrict writeonly uniform highp
+        image2D g_resultTextureSlot2;
     \n#endif\n
 
     // Constants
     const vec4 c_lumWeights = vec4(0.2126f, 0.7152f, 0.0722f, 0.0000f);
 
     \n#ifdef EDGE_DETECT_THRESHOLD\n
     const float c_ColorThreshold = 1.0f / EDGE_DETECT_THRESHOLD;
     \n#endif\n
 
     // Must be even number; Will work with ~16 pretty good too for
@@ skipping 238 matching lines @@
 
       float totalLength = float(loopTo - loopFrom) + 1.0 - leftOdd -
                           rightOdd;
 
       for (int i = loopFrom; i <= loopTo; i++) {
         highp ivec2 pixelPos = screenPos + stepRight * i;
         vec2 pixelPosFlt = vec2(float(pixelPos.x) + 0.5,
                                 float(pixelPos.y) + 0.5);
 
     \n#ifdef DEBUG_OUTPUT_AAINFO\n
-        imageStore(g_resultEdgeTexture, pixelPos,
+        imageStore(g_resultTextureSlot2, pixelPos,
                    PackBlurAAInfo(pixelPos, 1u));
     \n#endif\n
 
         float m = (float(i) + 0.5 - leftOdd - float(loopFrom)) /
                    totalLength;
         m = saturate(m);
         float k = m - ((i > 0) ? 1.0 : 0.0);
         k = (invertedZShape) ? (k) : (-k);
 
         vec4 color = textureLod(g_screenTexture,
                                 (pixelPosFlt + blendDir * k) * pixelSize,
                                 0.0);
 
     \n#ifdef IN_GAMMA_CORRECT_MODE\n
         color.rgb = D3DX_FLOAT3_to_SRGB(color.rgb);
     \n#endif\n
-        imageStore(g_resultRGBATextureSlot1, pixelPos, color);
+        imageStore(g_resultTextureFlt4Slot1, pixelPos, color);
       }
     }
 
     vec4 CalcDbgDisplayColor(const vec4 blurMap) {
       vec3 pixelC = vec3(0.0, 0.0, 0.0);
       vec3 pixelL = vec3(0.0, 0.0, 1.0);
       vec3 pixelT = vec3(1.0, 0.0, 0.0);
       vec3 pixelR = vec3(0.0, 1.0, 0.0);
       vec3 pixelB = vec3(0.8, 0.8, 0.0);
 
@@ skipping 39 matching lines @@
           texelFetchOffset(g_screenTexture, screenPosI.xy, 0, ivec2(0, 1));
       vec4 pixel11 =
           texelFetchOffset(g_screenTexture, screenPosI.xy, 0, ivec2(1, 1));
       vec4 pixel21 =
           texelFetchOffset(g_screenTexture, screenPosI.xy, 0, ivec2(2, 1));
       vec4 pixel02 =
           texelFetchOffset(g_screenTexture, screenPosI.xy, 0, ivec2(0, 2));
       vec4 pixel12 =
           texelFetchOffset(g_screenTexture, screenPosI.xy, 0, ivec2(1, 2));
 
-      if (g_DoCopy == 1) {
-        imageStore(g_targetTextureSlot2, screenPosI.xy + ivec2(0, 0), pixel00);
-        imageStore(g_targetTextureSlot2, screenPosI.xy + ivec2(1, 0), pixel10);
-        imageStore(g_targetTextureSlot2, screenPosI.xy + ivec2(0, 1), pixel01);
-        imageStore(g_targetTextureSlot2, screenPosI.xy + ivec2(1, 1), pixel11);
-      }
-
       float storeFlagPixel00 = 0.0;
       float storeFlagPixel10 = 0.0;
       float storeFlagPixel20 = 0.0;
       float storeFlagPixel01 = 0.0;
       float storeFlagPixel11 = 0.0;
       float storeFlagPixel21 = 0.0;
       float storeFlagPixel02 = 0.0;
       float storeFlagPixel12 = 0.0;
 
       vec2 et;
@@ skipping 53 matching lines @@
         storeFlagPixel11 += et.x;
         storeFlagPixel11 += et.y;
         storeFlagPixel21 += et.x;
         storeFlagPixel12 += et.y;
       }
 
       gl_FragDepth = any(bvec4(outputEdges)) ? 1.0 : 0.0;
 
       if (gl_FragDepth != 0.0) {
         if (storeFlagPixel00 != 0.0)
-          imageStore(g_resultRGBATextureSlot1, screenPosI.xy + ivec2(0, 0),
+          imageStore(g_resultTextureFlt4Slot1, screenPosI.xy + ivec2(0, 0),
                      pixel00);
         if (storeFlagPixel10 != 0.0)
-          imageStore(g_resultRGBATextureSlot1, screenPosI.xy + ivec2(1, 0),
+          imageStore(g_resultTextureFlt4Slot1, screenPosI.xy + ivec2(1, 0),
                      pixel10);
         if (storeFlagPixel20 != 0.0)
-          imageStore(g_resultRGBATextureSlot1, screenPosI.xy + ivec2(2, 0),
+          imageStore(g_resultTextureFlt4Slot1, screenPosI.xy + ivec2(2, 0),
                      pixel20);
         if (storeFlagPixel01 != 0.0)
-          imageStore(g_resultRGBATextureSlot1, screenPosI.xy + ivec2(0, 1),
+          imageStore(g_resultTextureFlt4Slot1, screenPosI.xy + ivec2(0, 1),
                      pixel01);
         if (storeFlagPixel02 != 0.0)
-          imageStore(g_resultRGBATextureSlot1, screenPosI.xy + ivec2(0, 2),
+          imageStore(g_resultTextureFlt4Slot1, screenPosI.xy + ivec2(0, 2),
                      pixel02);
         if (storeFlagPixel11 != 0.0)
-          imageStore(g_resultRGBATextureSlot1, screenPosI.xy + ivec2(1, 1),
+          imageStore(g_resultTextureFlt4Slot1, screenPosI.xy + ivec2(1, 1),
                      pixel11);
         if (storeFlagPixel21 != 0.0)
-          imageStore(g_resultRGBATextureSlot1, screenPosI.xy + ivec2(2, 1),
+          imageStore(g_resultTextureFlt4Slot1, screenPosI.xy + ivec2(2, 1),
                      pixel21);
         if (storeFlagPixel12 != 0.0)
-          imageStore(g_resultRGBATextureSlot1, screenPosI.xy + ivec2(1, 2),
+          imageStore(g_resultTextureFlt4Slot1, screenPosI.xy + ivec2(1, 2),
                      pixel12);
       }
       outEdges = STORE_UVEC4(outputEdges);
     }
     \n#endif\n  // DETECT_EDGES1
 
     vec2 UnpackThresholds(uint val) {
       return vec2(val & 0x0Fu, val >> 4u) / 15.0f;
     }
 
@@ skipping 84 matching lines @@
         packedVals[(0) * 6 + (2)] = LOAD_UINT(packedQ3.x);
         packedVals[(1) * 6 + (2)] = LOAD_UINT(packedQ3.y);
         packedVals[(0) * 6 + (3)] = LOAD_UINT(packedQ3.z);
         packedVals[(1) * 6 + (3)] = LOAD_UINT(packedQ3.w);
       }
 
       if (bool(packedVals[(2) * 6 + (2)])) {
         CollectEdges(2, 2, edges, packedVals);
         uint pe = PackEdge(PruneNonDominantEdges(edges));
         if (pe != 0u) {
-          imageStore(g_resultEdgeTexture, 2 * screenPosI.xy + ivec2(0, 0),
+          imageStore(g_resultTexture, 2 * screenPosI.xy + ivec2(0, 0),
                      vec4(float(0x80u | pe) / 255.0, 0, 0, 0));
         }
       }
 
       if (bool(packedVals[(3) * 6 + (2)]) ||
           bool(packedVals[(3) * 6 + (3)])) {
         UVEC4 packedQ5 = texelFetchOffset(g_src0Texture4Uint,
                                           screenPosI.xy, 0, ivec2(1, 0));
         packedVals[(4) * 6 + (2)] = LOAD_UINT(packedQ5.x);
         packedVals[(5) * 6 + (2)] = LOAD_UINT(packedQ5.y);
         packedVals[(4) * 6 + (3)] = LOAD_UINT(packedQ5.z);
         packedVals[(5) * 6 + (3)] = LOAD_UINT(packedQ5.w);
       }
 
       if (bool(packedVals[(3) * 6 + (2)])) {
         UVEC4 packedQ2 = texelFetchOffset(g_src0Texture4Uint,
                                           screenPosI.xy, 0, ivec2(1, -1));
         packedVals[(4) * 6 + (0)] = LOAD_UINT(packedQ2.x);
         packedVals[(5) * 6 + (0)] = LOAD_UINT(packedQ2.y);
         packedVals[(4) * 6 + (1)] = LOAD_UINT(packedQ2.z);
         packedVals[(5) * 6 + (1)] = LOAD_UINT(packedQ2.w);
 
         CollectEdges(3, 2, edges, packedVals);
         uvec4 dominant_edges = PruneNonDominantEdges(edges);
         // The rightmost edge of the texture is not edge.
         // Note: texelFetch() on out of range gives an undefined value.
         uint pe = PackEdge(dominant_edges * uvec4(notTopRight.x, 1, 1, 1));
         if (pe != 0u) {
-          imageStore(g_resultEdgeTexture, 2 * screenPosI.xy + ivec2(1, 0),
+          imageStore(g_resultTexture, 2 * screenPosI.xy + ivec2(1, 0),
                      vec4(float(0x80u | pe) / 255.0, 0, 0, 0));
         }
       }
 
       if (bool(packedVals[(2) * 6 + (3)]) ||
           bool(packedVals[(3) * 6 + (3)])) {
         UVEC4 packedQ7 = texelFetchOffset(g_src0Texture4Uint,
                                           screenPosI.xy, 0, ivec2(0, 1));
         packedVals[(2) * 6 + (4)] = LOAD_UINT(packedQ7.x);
         packedVals[(3) * 6 + (4)] = LOAD_UINT(packedQ7.y);
         packedVals[(2) * 6 + (5)] = LOAD_UINT(packedQ7.z);
         packedVals[(3) * 6 + (5)] = LOAD_UINT(packedQ7.w);
       }
 
       if (bool(packedVals[(2) * 6 + (3)])) {
         UVEC4 packedQ6 = texelFetchOffset(g_src0Texture4Uint,
                                           screenPosI.xy, 0, ivec2(-1, -1));
         packedVals[(0) * 6 + (4)] = LOAD_UINT(packedQ6.x);
         packedVals[(1) * 6 + (4)] = LOAD_UINT(packedQ6.y);
         packedVals[(0) * 6 + (5)] = LOAD_UINT(packedQ6.z);
         packedVals[(1) * 6 + (5)] = LOAD_UINT(packedQ6.w);
 
         CollectEdges(2, 3, edges, packedVals);
         uvec4 dominant_edges = PruneNonDominantEdges(edges);
         uint pe = PackEdge(dominant_edges * uvec4(1, notTopRight.y, 1, 1));
         if (pe != 0u) {
-          imageStore(g_resultEdgeTexture, 2 * screenPosI.xy + ivec2(0, 1),
+          imageStore(g_resultTexture, 2 * screenPosI.xy + ivec2(0, 1),
                      vec4(float(0x80u | pe) / 255.0, 0, 0, 0));
         }
       }
 
       if (bool(packedVals[(3) * 6 + (3)])) {
         CollectEdges(3, 3, edges, packedVals);
         uvec4 dominant_edges = PruneNonDominantEdges(edges);
         uint pe = PackEdge(dominant_edges * uvec4(notTopRight, 1, 1));
         if (pe != 0u) {
-          imageStore(g_resultEdgeTexture, 2 * screenPosI.xy + ivec2(1, 1),
+          imageStore(g_resultTexture, 2 * screenPosI.xy + ivec2(1, 1),
                      vec4(float(0x80u | pe) / 255.0, 0, 0, 0));
         }
       }
     }
     \n#endif\n  // DETECT_EDGES2
 
     \n#ifdef COMBINE_EDGES\n
     void CombineEdges() {
       ivec3 screenPosIBase = ivec3(ivec2(gl_FragCoord.xy) * 2, 0);
       vec3 screenPosBase = vec3(screenPosIBase);
@@ skipping 37 matching lines @@
                             packedEdgesArray[(0 + 1) * 3 + (1 + 1)]);
       uvec4 pixelsU = uvec4(packedEdgesArray[(1 + 0) * 3 + (0 + 0)],
                             packedEdgesArray[(1 + 1) * 3 + (0 + 0)],
                             packedEdgesArray[(1 + 0) * 3 + (0 + 1)],
                             packedEdgesArray[(1 + 1) * 3 + (0 + 1)]);
 
       uvec4 outEdge4 =
           pixelsC | ((pixelsL & 0x01u) << 2u) | ((pixelsU & 0x02u) << 2u);
       vec4 outEdge4Flt = vec4(outEdge4) / 255.0;
 
-      imageStore(g_resultEdgeTexture, screenPosIBase.xy + ivec2(0, 0),
+      imageStore(g_resultTextureSlot2, screenPosIBase.xy + ivec2(0, 0),
                  outEdge4Flt.xxxx);
-      imageStore(g_resultEdgeTexture, screenPosIBase.xy + ivec2(1, 0),
+      imageStore(g_resultTextureSlot2, screenPosIBase.xy + ivec2(1, 0),
                  outEdge4Flt.yyyy);
-      imageStore(g_resultEdgeTexture, screenPosIBase.xy + ivec2(0, 1),
+      imageStore(g_resultTextureSlot2, screenPosIBase.xy + ivec2(0, 1),
                  outEdge4Flt.zzzz);
-      imageStore(g_resultEdgeTexture, screenPosIBase.xy + ivec2(1, 1),
+      imageStore(g_resultTextureSlot2, screenPosIBase.xy + ivec2(1, 1),
                  outEdge4Flt.wwww);
 
       // uvec4 numberOfEdges4 = uvec4(bitCount(outEdge4));
       // gl_FragDepth =
       //     any(greaterThan(numberOfEdges4, uvec4(1))) ? 1.0 : 0.0;
 
       gl_FragDepth =
           any(greaterThan(outEdge4, uvec4(1))) ? 1.0 : 0.0;
     }
     \n#endif\n  // COMBINE_EDGES
@@ skipping 233 matching lines @@
         }
 
         color /= fourWeightSum + 0.0001;
 
         color = mix(color, pixelC, centerWeight / allWeightSum);
     \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_resultEdgeTexture, screenPosI.xy,
+        imageStore(g_resultTextureSlot2, screenPosI.xy,
                    PackBlurAAInfo(screenPosI.xy, numberOfEdges));
     \n#endif\n
-        imageStore(g_resultRGBATextureSlot1, screenPosI.xy, color);
+        imageStore(g_resultTextureFlt4Slot1, screenPosI.xy, color);
 
         if (numberOfEdges == 2u) {
           uint packedEdgesL = packedEdgesArray[(0 + _x) * 4 + (1 + _y)];
           uint packedEdgesB = packedEdgesArray[(1 + _x) * 4 + (0 + _y)];
           uint packedEdgesR = packedEdgesArray[(2 + _x) * 4 + (1 + _y)];
           uint packedEdgesT = packedEdgesArray[(1 + _x) * 4 + (2 + _y)];
 
           bool isHorizontalA = ((packedEdgesC) == (0x01u | 0x02u)) &&
              ((packedEdgesR & 0x08u) == 0x08u);
           bool isHorizontalB = ((packedEdgesC) == (0x01u | 0x08u)) &&
@@ skipping 189 matching lines @@
       CombineEdges();
     \n#endif\n
     \n#if defined BLUR_EDGES\n
       BlurEdges();
     \n#endif\n
     \n#if defined DISPLAY_EDGES\n
       DisplayEdges();
     \n#endif\n
     }
   );
+
+const char
+  ApplyFramebufferAttachmentCMAAINTELResourceManager::copy_frag_str_[] =
+    SHADER(
+      precision highp float;
+      layout(binding = 0) uniform highp sampler2D inTexture;
+      layout(location = 0) out vec4 outColor;
+      \n#ifdef GL_ES\n
+      layout(binding = 0, rgba8) restrict writeonly uniform highp
+                                                     image2D outTexture;
+      \n#else\n
+      layout(rgba8) restrict writeonly uniform highp image2D outTexture;
+      \n#endif\n
+
+      void main() {
+        ivec2 screenPosI = ivec2( gl_FragCoord.xy );
+        vec4 pixel = texelFetch(inTexture, screenPosI, 0);
+      \n#ifdef OUT_FBO\n
+        outColor = pixel;
+      \n#else\n
+        imageStore(outTexture, screenPosI, pixel);
+      \n#endif\n
+      }
+    );
 /* clang-format on */
 
 }  // namespace gles2
 }  // namespace gpu