Implement EXT_draw_buffers WebGL extention support in command buffer.

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 "base/logging.h"
 #include "base/stringprintf.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/renderbuffer_manager.h"
 #include "gpu/command_buffer/service/texture_manager.h"
@@ skipping 57 matching lines @@
   }
 
   virtual bool CanRenderTo() const OVERRIDE {
     return true;
   }
 
   virtual void DetachFromFramebuffer() const OVERRIDE {
     // Nothing to do for renderbuffers.
   }
 
-  virtual bool ValidForAttachmentType(GLenum attachment_type) OVERRIDE {
+  virtual bool ValidForAttachmentType(
+      GLenum attachment_type, uint32 max_color_attachments) OVERRIDE {
     uint32 need = GLES2Util::GetChannelsNeededForAttachmentType(
-        attachment_type);
+        attachment_type, max_color_attachments);
     uint32 have = GLES2Util::GetChannelsForFormat(internal_format());
     return (need & have) != 0;
   }
 
   Renderbuffer* renderbuffer() const {
     return renderbuffer_.get();
   }
 
   virtual void AddToSignature(
       TextureManager* texture_manager, std::string* signature) const OVERRIDE {
@@ skipping 71 matching lines @@
   }
 
   virtual bool CanRenderTo() const OVERRIDE {
     return texture_->CanRenderTo();
   }
 
   virtual void DetachFromFramebuffer() const OVERRIDE {
     texture_->DetachFromFramebuffer();
   }
 
-  virtual bool ValidForAttachmentType(GLenum attachment_type) OVERRIDE {
+  virtual bool ValidForAttachmentType(
+      GLenum attachment_type, uint32 max_color_attachments) OVERRIDE {
     GLenum type = 0;
     GLenum internal_format = 0;
     if (!texture_->GetLevelType(target_, level_, &type, &internal_format)) {
       return false;
     }
     uint32 need = GLES2Util::GetChannelsNeededForAttachmentType(
-        attachment_type);
+        attachment_type, max_color_attachments);
     uint32 have = GLES2Util::GetChannelsForFormat(internal_format);
     return (need & have) != 0;
   }
 
   virtual void AddToSignature(
       TextureManager* texture_manager, std::string* signature) const OVERRIDE {
     DCHECK(signature);
     texture_manager->AddToSignature(texture_, target_, level_, signature);
   }
 
  protected:
   virtual ~TextureAttachment() {}
 
  private:
   scoped_refptr<Texture> texture_;
   GLenum target_;
   GLint level_;
 
   DISALLOW_COPY_AND_ASSIGN(TextureAttachment);
 };
 
-FramebufferManager::FramebufferManager()
+FramebufferManager::FramebufferManager(
+    uint32 max_draw_buffers, uint32 max_color_attachments)
     : framebuffer_state_change_count_(1),
       framebuffer_count_(0),
-      have_context_(true) {
+      have_context_(true),
+      max_draw_buffers_(max_draw_buffers),
+      max_color_attachments_(max_color_attachments) {
+  DCHECK_GT(max_draw_buffers_, 0u);
+  DCHECK_GT(max_color_attachments_, 0u);
 }
 
 FramebufferManager::~FramebufferManager() {
   DCHECK(framebuffers_.empty());
   // If this triggers, that means something is keeping a reference to a
   // Framebuffer belonging to this.
   CHECK_EQ(framebuffer_count_, 0u);
 }
 
 void Framebuffer::MarkAsDeleted() {
@@ skipping 32 matching lines @@
 }
 
 Framebuffer::Framebuffer(
     FramebufferManager* manager, GLuint service_id)
     : manager_(manager),
       deleted_(false),
       service_id_(service_id),
       has_been_bound_(false),
       framebuffer_complete_state_count_id_(0) {
   manager->StartTracking(this);
+  DCHECK_GT(manager->max_draw_buffers_, 0u);
+  draw_buffers_.reset(new GLenum[manager->max_draw_buffers_]);
+  draw_buffers_[0] = GL_COLOR_ATTACHMENT0;
+  for (uint32 i = 1; i < manager->max_draw_buffers_; ++i)
+    draw_buffers_[i] = GL_NONE;
 }
 
 Framebuffer::~Framebuffer() {
   if (manager_) {
     if (manager_->have_context_) {
       GLuint id = service_id();
       glDeleteFramebuffersEXT(1, &id);
     }
     manager_->StopTracking(this);
     manager_ = NULL;
@@ skipping 63 matching lines @@
   if (attachments_.empty()) {
     return GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT;
   }
 
   GLsizei width = -1;
   GLsizei height = -1;
   for (AttachmentMap::const_iterator it = attachments_.begin();
        it != attachments_.end(); ++it) {
     GLenum attachment_type = it->first;
     Attachment* attachment = it->second;
-    if (!attachment->ValidForAttachmentType(attachment_type)) {
+    if (!attachment->ValidForAttachmentType(
+            attachment_type, manager_->max_color_attachments_)) {
       return GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT;
     }
     if (width < 0) {
       width = attachment->width();
       height = attachment->height();
       if (width == 0 || height == 0) {
         return GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT;
       }
     } else {
       if (attachment->width() != width || attachment->height() != height) {
@@ skipping 44 matching lines @@
   for (AttachmentMap::const_iterator it = attachments_.begin();
        it != attachments_.end(); ++it) {
     Attachment* attachment = it->second;
     if (!attachment->cleared()) {
       return false;
     }
   }
   return true;
 }
 
+GLenum Framebuffer::GetDrawBuffer(GLenum draw_buffer) const {
+  GLsizei index = static_cast<GLsizei>(
+      draw_buffer - GL_DRAW_BUFFER0_ARB);
+  CHECK(index >= 0 &&
+        index < static_cast<GLsizei>(manager_->max_draw_buffers_));
+  return draw_buffers_[index];
+}
+
+void Framebuffer::SetDrawBuffers(GLsizei n, const GLenum* bufs) {
+  DCHECK(n <= static_cast<GLsizei>(manager_->max_draw_buffers_));
+  for (GLsizei i = 0; i < n; ++i)
+    draw_buffers_[i] = bufs[i];
+}
+
 void Framebuffer::UnbindRenderbuffer(
     GLenum target, Renderbuffer* renderbuffer) {
   bool done;
   do {
     done = true;
     for (AttachmentMap::const_iterator it = attachments_.begin();
          it != attachments_.end(); ++it) {
       Attachment* attachment = it->second;
       if (attachment->IsRenderbuffer(renderbuffer)) {
         // TODO(gman): manually detach renderbuffer.
@@ skipping 34 matching lines @@
 void FramebufferManager::RemoveFramebuffer(GLuint client_id) {
   FramebufferMap::iterator it = framebuffers_.find(client_id);
   if (it != framebuffers_.end()) {
     it->second->MarkAsDeleted();
     framebuffers_.erase(it);
   }
 }
 
 void Framebuffer::AttachRenderbuffer(
     GLenum attachment, Renderbuffer* renderbuffer) {
-  DCHECK(attachment == GL_COLOR_ATTACHMENT0 ||
-         attachment == GL_DEPTH_ATTACHMENT ||
-         attachment == GL_STENCIL_ATTACHMENT ||
-         attachment == GL_DEPTH_STENCIL_ATTACHMENT);
   const Attachment* a = GetAttachment(attachment);
   if (a)
     a->DetachFromFramebuffer();
   if (renderbuffer) {
     attachments_[attachment] = scoped_refptr<Attachment>(
         new RenderbufferAttachment(renderbuffer));
   } else {
     attachments_.erase(attachment);
   }
   framebuffer_complete_state_count_id_ = 0;
 }
 
 void Framebuffer::AttachTexture(
     GLenum attachment, Texture* texture, GLenum target,
     GLint level) {
-  DCHECK(attachment == GL_COLOR_ATTACHMENT0 ||
-         attachment == GL_DEPTH_ATTACHMENT ||
-         attachment == GL_STENCIL_ATTACHMENT ||
-         attachment == GL_DEPTH_STENCIL_ATTACHMENT);
   const Attachment* a = GetAttachment(attachment);
   if (a)
     a->DetachFromFramebuffer();
   if (texture) {
     attachments_[attachment] = scoped_refptr<Attachment>(
         new TextureAttachment(texture, target, level));
     texture->AttachToFramebuffer();
   } else {
     attachments_.erase(attachment);
   }
@@ skipping 44 matching lines @@
     Framebuffer* framebuffer) {
   DCHECK(framebuffer);
   return framebuffer->framebuffer_complete_state_count_id() ==
       framebuffer_state_change_count_;
 }
 
 }  // namespace gles2
 }  // namespace gpu