Attaching an image to many color attachment points is unsupported

gpu/command_buffer/service/framebuffer_manager.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/framebuffer_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/logging.h"
@@ skipping 71 matching lines @@
 
   bool IsTextureAttachment() const override { return false; }
   bool IsRenderbufferAttachment() const override { return true; }
 
   bool IsTexture(TextureRef* /* texture */) const override { return false; }
 
   bool IsRenderbuffer(Renderbuffer* renderbuffer) const override {
     return renderbuffer_.get() == renderbuffer;
   }
 
+  bool IsSameAttachment(const Attachment* attachment) const override {
+    if (attachment->IsRenderbufferAttachment()) {
+      const RenderbufferAttachment* other =
+          reinterpret_cast<const RenderbufferAttachment*>(attachment);
+      return IsRenderbuffer(other->renderbuffer());
+    }
+    return false;
+  }
+
   bool Is3D() const override { return false; }
 
   bool CanRenderTo(const FeatureInfo*) const override { return true; }
 
   void DetachFromFramebuffer(Framebuffer* framebuffer) const override {
     // Nothing to do for renderbuffers.
   }
 
   bool IsLayerValid() const override { return true; }
 
@@ skipping 111 matching lines @@
     return texture_ref_->texture()->IsLevelPartiallyCleared(target_, level_);
   }
 
   bool IsTextureAttachment() const override { return true; }
   bool IsRenderbufferAttachment() const override { return false; }
 
   bool IsTexture(TextureRef* texture) const override {
     return texture == texture_ref_.get();
   }
 
+  bool IsSameAttachment(const Attachment* attachment) const override {
+    if (attachment->IsTextureAttachment()) {
+      const TextureAttachment* other =
+          reinterpret_cast<const TextureAttachment*>(attachment);
+      return IsTexture(other->texture()) &&
+          layer_ == other->layer() &&
+          target_ == other->target() &&
+          level_ == other->level();
+    }
+    return false;
+  }
+
   bool IsRenderbuffer(Renderbuffer* /* renderbuffer */) const override {
     return false;
   }
 
   bool Is3D() const override {
     return (target_ == GL_TEXTURE_3D || target_ == GL_TEXTURE_2D_ARRAY);
   }
 
   TextureRef* texture() const {
     return texture_ref_.get();
@@ skipping 471 matching lines @@
       } else if (attachment->samples() != samples) {
         // It's possible that the specified samples isn't the actual samples a
         // GL implementation uses, but we always return INCOMPLETE_MULTISAMPLE
         // here to ensure consistent behaviors across platforms.
         return GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE;
       }
     }
     if (!attachment->CanRenderTo(feature_info)) {
       return GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT;
     }
+
+    // In WebGL 2.0, attaching an image to more than one color attachment point
+    // should return FRAMEBUFFER_UNSUPPORTED.
+    if (feature_info->context_type() == CONTEXT_TYPE_WEBGL2) {

[qiankun, 2016/07/20 08:53:33]

Is it right only for webgl 2 context? I think gles should not apply this
restriction.

[Zhenyao Mo, 2016/07/20 13:55:44]

We need to apply it to ES3 contexts as well.  If they are on top of D3D9, this
limit will apply.

You should remove the if condition here, since this should apply in ES2 / WEBGL1
for EXT_draw_buffers extension cases - we will need to update the WebGL
extension spec also.

[qiankun, 2016/07/20 15:03:26]

I see. You told me to update extension case before. I will do it tomorrow.
So, we still need to check if EXT_draw_buffers extension is available for ES2? 
ES2 doesn't have this limitation. Right?

[Zhenyao Mo, 2016/07/20 16:12:48]

On the command buffer side, we don't need to check for the extension.  If it's
not there, then there will be no more than one color attachment, and this check
should just pass. This is not on a perf critical path, so this is OK.

+      if (it->first >= GL_COLOR_ATTACHMENT0 &&
+          it->first < GL_COLOR_ATTACHMENT0 + manager_->max_color_attachments_) {
+        for (GLenum i = it->first + 1;
+             i < GL_COLOR_ATTACHMENT0 + manager_->max_color_attachments_; i++) {
+          const Attachment* other = GetAttachment(i);
+          if (other && attachment->IsSameAttachment(other)) {
+            return GL_FRAMEBUFFER_UNSUPPORTED;
+          }
+        }
+      }
+    }
   }
 
   // This does not mean the framebuffer is actually complete. It just means our
   // checks passed.
   return GL_FRAMEBUFFER_COMPLETE;
 }
 
 GLenum Framebuffer::GetStatus(
     TextureManager* texture_manager, GLenum target) const {
   if (!manager_->GetFramebufferComboCompleteCache()) {
@@ skipping 280 matching lines @@
 
 bool FramebufferManager::IsComplete(
     Framebuffer* framebuffer) {
   DCHECK(framebuffer);
   return framebuffer->framebuffer_complete_state_count_id() ==
       framebuffer_state_change_count_;
 }
 
 }  // namespace gles2
 }  // namespace gpu