Move special DEPTH_STENCIL attachment logic from command buffers to WebGL1

gpu/command_buffer/service/gles2_cmd_decoder.cc

 // Copyright (c) 2012 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_decoder.h"
 
 #include <limits.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
@@ skipping 5846 matching lines @@
       break;
   }
 
   if (!dirty)
     return;
 
   // Marks each one of them as not cleared.
   for (GLsizei i = 0; i < validated_count; ++i) {
     if (framebuffer) {
       if (validated_attachments[i] == GL_DEPTH_STENCIL_ATTACHMENT) {
-        // TODO(qiankun.miao@intel.com): We should only mark DEPTH and STENCIL
-        // attachments as cleared when command buffer handles DEPTH_STENCIL
-        // well. http://crbug.com/630568
         framebuffer->MarkAttachmentAsCleared(renderbuffer_manager(),
                                              texture_manager(),
                                              GL_DEPTH_ATTACHMENT,
                                              false);
         framebuffer->MarkAttachmentAsCleared(renderbuffer_manager(),
                                              texture_manager(),
                                              GL_STENCIL_ATTACHMENT,
                                              false);
-        framebuffer->MarkAttachmentAsCleared(renderbuffer_manager(),
-                                             texture_manager(),
-                                             GL_DEPTH_STENCIL_ATTACHMENT,
-                                             false);
       } else {
         framebuffer->MarkAttachmentAsCleared(renderbuffer_manager(),
                                              texture_manager(),
                                              validated_attachments[i],
                                              false);
       }
     } else {
       switch (validated_attachments[i]) {
         case GL_COLOR_EXT:
           backbuffer_needs_clear_bits_ |= GL_COLOR_BUFFER_BIT;
@@ skipping 1228 matching lines @@
   if (client_renderbuffer_id) {
     renderbuffer = GetRenderbuffer(client_renderbuffer_id);
     if (!renderbuffer) {
       LOCAL_SET_GL_ERROR(
           GL_INVALID_OPERATION,
           "glFramebufferRenderbuffer", "unknown renderbuffer");
       return;
     }
     service_id = renderbuffer->service_id();
   }
+  std::vector<GLenum> attachments;
+  if (attachment == GL_DEPTH_STENCIL_ATTACHMENT) {
+    attachments.push_back(GL_DEPTH_ATTACHMENT);
+    attachments.push_back(GL_STENCIL_ATTACHMENT);
+  } else {
+    attachments.push_back(attachment);
+  }
   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("glFramebufferRenderbuffer");
-  if (attachment == GL_DEPTH_STENCIL_ATTACHMENT) {
+  for (GLenum attachment_point : attachments) {
     glFramebufferRenderbufferEXT(
-        target, GL_DEPTH_ATTACHMENT, renderbuffertarget, service_id);
-    glFramebufferRenderbufferEXT(
-        target, GL_STENCIL_ATTACHMENT, renderbuffertarget, service_id);
-  } else {
-    glFramebufferRenderbufferEXT(
-        target, attachment, renderbuffertarget, service_id);
-  }
-  GLenum error = LOCAL_PEEK_GL_ERROR("glFramebufferRenderbuffer");
-  if (error == GL_NO_ERROR) {
-    framebuffer->AttachRenderbuffer(attachment, renderbuffer);
+        target, attachment_point, renderbuffertarget, service_id);
+    GLenum error = LOCAL_PEEK_GL_ERROR("glFramebufferRenderbuffer");
+    if (error == GL_NO_ERROR) {
+      framebuffer->AttachRenderbuffer(attachment_point, renderbuffer);
+    }
   }
   if (framebuffer == framebuffer_state_.bound_draw_framebuffer.get()) {
     framebuffer_state_.clear_state_dirty = true;
   }
   OnFboChanged();
 }
 
 void GLES2DecoderImpl::DoDisable(GLenum cap) {
   if (SetCapabilityState(cap, false)) {
     if (cap == GL_PRIMITIVE_RESTART_FIXED_INDEX &&
@@ skipping 67 matching lines @@
     glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
     state_.SetDeviceColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
     clear_bits |= GL_COLOR_BUFFER_BIT;
 
     if (SupportsDrawBuffers()) {
       reset_draw_buffers =
           framebuffer->PrepareDrawBuffersForClearingUninitializedAttachments();
     }
   }
 
-  if (framebuffer->HasUnclearedAttachment(GL_STENCIL_ATTACHMENT) ||
-      framebuffer->HasUnclearedAttachment(GL_DEPTH_STENCIL_ATTACHMENT)) {
+  if (framebuffer->HasUnclearedAttachment(GL_STENCIL_ATTACHMENT)) {
     glClearStencil(0);
     state_.SetDeviceStencilMaskSeparate(GL_FRONT, kDefaultStencilMask);
     state_.SetDeviceStencilMaskSeparate(GL_BACK, kDefaultStencilMask);
     clear_bits |= GL_STENCIL_BUFFER_BIT;
   }
 
-  if (framebuffer->HasUnclearedAttachment(GL_DEPTH_ATTACHMENT) ||
-      framebuffer->HasUnclearedAttachment(GL_DEPTH_STENCIL_ATTACHMENT)) {
+  if (framebuffer->HasUnclearedAttachment(GL_DEPTH_ATTACHMENT)) {
     glClearDepth(1.0f);
     state_.SetDeviceDepthMask(GL_TRUE);
     clear_bits |= GL_DEPTH_BUFFER_BIT;
   }
 
   if (clear_bits) {
     if (!cleared_int_renderbuffers &&
         target == GL_READ_FRAMEBUFFER && draw_framebuffer != framebuffer) {
       // TODO(zmo): There is no guarantee that an FBO that is complete on the
       // READ attachment will be complete as a DRAW attachment.
@@ skipping 125 matching lines @@
           target, attachments[ii], textarget, service_id, level);
     } else {
       if (features().use_img_for_multisampled_render_to_texture) {
         glFramebufferTexture2DMultisampleIMG(
             target, attachments[ii], textarget, service_id, level, samples);
       } else {
         glFramebufferTexture2DMultisampleEXT(
             target, attachments[ii], textarget, service_id, level, samples);
       }
     }
-  }
-  GLenum error = LOCAL_PEEK_GL_ERROR(name);
-  if (error == GL_NO_ERROR) {
-    framebuffer->AttachTexture(attachment, texture_ref, textarget, level,
-         samples);
+    GLenum error = LOCAL_PEEK_GL_ERROR(name);
+    if (error == GL_NO_ERROR) {
+      framebuffer->AttachTexture(attachments[ii], texture_ref, textarget, level,
+                                 samples);
+    }
   }
   if (framebuffer == framebuffer_state_.bound_draw_framebuffer.get()) {
     framebuffer_state_.clear_state_dirty = true;
   }
 
   OnFboChanged();
 }
 
 void GLES2DecoderImpl::DoFramebufferTextureLayer(
     GLenum target, GLenum attachment, GLuint client_texture_id,
@@ skipping 29 matching lines @@
         return;
     }
     if (!texture_manager()->ValidForTarget(texture_target, level,
                                            0, 0, layer)) {
       LOCAL_SET_GL_ERROR(
           GL_INVALID_VALUE, function_name, "invalid level or layer");
       return;
     }
   }
   glFramebufferTextureLayer(target, attachment, service_id, level, layer);
-  framebuffer->AttachTextureLayer(
-      attachment, texture_ref, texture_target, level, layer);
+  if (attachment == GL_DEPTH_STENCIL_ATTACHMENT) {
+    framebuffer->AttachTextureLayer(
+        GL_DEPTH_ATTACHMENT, texture_ref, texture_target, level, layer);
+    framebuffer->AttachTextureLayer(
+        GL_STENCIL_ATTACHMENT, texture_ref, texture_target, level, layer);
+  } else {
+    framebuffer->AttachTextureLayer(
+        attachment, texture_ref, texture_target, level, layer);
+  }
   if (framebuffer == framebuffer_state_.bound_draw_framebuffer.get()) {
     framebuffer_state_.clear_state_dirty = true;
   }
 }
 
 void GLES2DecoderImpl::DoGetFramebufferAttachmentParameteriv(
     GLenum target, GLenum attachment, GLenum pname, GLint* params) {
   const char kFunctionName[] = "glGetFramebufferAttachmentParameteriv";
   Framebuffer* framebuffer = GetFramebufferInfoForTarget(target);
   if (!framebuffer) {
@@ skipping 35 matching lines @@
           attachment = GL_DEPTH_ATTACHMENT;
           break;
         case GL_STENCIL:
           attachment = GL_STENCIL_ATTACHMENT;
           break;
         default:
           NOTREACHED();
           break;
       }
     }
+  } else {
+    if (attachment == GL_DEPTH_STENCIL_ATTACHMENT) {
+      const Framebuffer::Attachment* depth =
+          framebuffer->GetAttachment(GL_DEPTH_ATTACHMENT);
+      const Framebuffer::Attachment* stencil =
+          framebuffer->GetAttachment(GL_STENCIL_ATTACHMENT);
+      if ((!depth && !stencil) ||
+          (depth && stencil && depth->IsSameAttachment(stencil))) {
+        attachment = GL_DEPTH_ATTACHMENT;
+      } else {
+        LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, kFunctionName,
+                           "depth and stencil attachment mismatch");
+        return;
+      }
+    }
   }
   if (pname == GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_SAMPLES_EXT &&
       features().use_img_for_multisampled_render_to_texture) {
     pname = GL_TEXTURE_SAMPLES_IMG;
   }
   if (pname == GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME) {
     DCHECK(framebuffer);
     // If we query from the driver, it will be service ID; however, we need to
     // return the client ID here.
     const Framebuffer::Attachment* attachment_object =
@@ skipping 89 matching lines @@
   // and draw framebuffe is default framebuffer, but the other is fbo, they
   // always have no identical image.
   if (!read_framebuffer && !draw_framebuffer) {
     is_feedback_loop = FeedbackLoopTrue;
   } else if (!read_framebuffer || !draw_framebuffer) {
     is_feedback_loop = FeedbackLoopFalse;
   } else {
     DCHECK(read_framebuffer && draw_framebuffer);
     if ((mask & GL_DEPTH_BUFFER_BIT) != 0) {
       const Framebuffer::Attachment* depth_buffer_read =
-          read_framebuffer->GetDepthAttachment();
+          read_framebuffer->GetAttachment(GL_DEPTH_ATTACHMENT);
       const Framebuffer::Attachment* depth_buffer_draw =
-          draw_framebuffer->GetDepthAttachment();
+          draw_framebuffer->GetAttachment(GL_DEPTH_ATTACHMENT);
       if (!depth_buffer_draw || !depth_buffer_read) {
         mask &= ~GL_DEPTH_BUFFER_BIT;
       } else if (depth_buffer_draw->IsSameAttachment(depth_buffer_read)) {
         is_feedback_loop = FeedbackLoopTrue;
       }
     }
     if ((mask & GL_STENCIL_BUFFER_BIT) != 0) {
       const Framebuffer::Attachment* stencil_buffer_read =
-          read_framebuffer->GetStencilAttachment();
+          read_framebuffer->GetAttachment(GL_STENCIL_ATTACHMENT);
       const Framebuffer::Attachment* stencil_buffer_draw =
-          draw_framebuffer->GetStencilAttachment();
+          draw_framebuffer->GetAttachment(GL_STENCIL_ATTACHMENT);
       if (!stencil_buffer_draw || !stencil_buffer_read) {
         mask &= ~GL_STENCIL_BUFFER_BIT;
       } else if (stencil_buffer_draw->IsSameAttachment(stencil_buffer_read)) {
         is_feedback_loop = FeedbackLoopTrue;
       }
     }
     if (!mask)
       return;
   }
 
@@ skipping 10515 matching lines @@
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "base/macros.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu