Implement EXT_draw_buffers WebGL extention support in command buffer.

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 <stdio.h>
 
 #include <algorithm>
 #include <list>
@@ skipping 907 matching lines @@
 
   void DoBindTexImage2DCHROMIUM(
       GLenum target,
       GLint image_id);
   void DoReleaseTexImage2DCHROMIUM(
       GLenum target,
       GLint image_id);
 
   void DoTraceEndCHROMIUM(void);
 
+  void DoDrawBuffersEXT(GLsizei count, const GLenum* bufs);
+
   // Creates a Program for the given program.
   Program* CreateProgram(
       GLuint client_id, GLuint service_id) {
     return program_manager()->CreateProgram(client_id, service_id);
   }
 
   // Gets the program info for the given program. Returns NULL if none exists.
   Program* GetProgram(GLuint client_id) {
     return program_manager()->GetProgram(client_id);
   }
@@ skipping 1652 matching lines @@
   resources.MaxVertexAttribs = group_->max_vertex_attribs();
   resources.MaxVertexUniformVectors =
       group_->max_vertex_uniform_vectors();
   resources.MaxVaryingVectors = group_->max_varying_vectors();
   resources.MaxVertexTextureImageUnits =
       group_->max_vertex_texture_image_units();
   resources.MaxCombinedTextureImageUnits = group_->max_texture_units();
   resources.MaxTextureImageUnits = group_->max_texture_image_units();
   resources.MaxFragmentUniformVectors =
       group_->max_fragment_uniform_vectors();
-  resources.MaxDrawBuffers = 1;
+  resources.MaxDrawBuffers = group_->max_draw_buffers();
 
 #if (ANGLE_SH_VERSION >= 110)
   GLint range[2];
   GLint precision = 0;
   GetShaderPrecisionFormatImpl(GL_FRAGMENT_SHADER, GL_HIGH_FLOAT,
                                range, &precision);
   resources.FragmentPrecisionHigh = ((range[0] >= 62) &&
                                      (range[1] >= 62) &&
                                      (precision >= 16));
 #endif
 
   if (force_webgl_glsl_validation_) {
     resources.OES_standard_derivatives = derivatives_explicitly_enabled_;
   } else {
     resources.OES_standard_derivatives =
         features().oes_standard_derivatives ? 1 : 0;
     resources.ARB_texture_rectangle =
         features().arb_texture_rectangle ? 1 : 0;
     resources.OES_EGL_image_external =
         features().oes_egl_image_external ? 1 : 0;
+    resources.EXT_draw_buffers =
+        features().ext_draw_buffers ? 1 : 0;
   }
 
   ShShaderSpec shader_spec = force_webgl_glsl_validation_ ||
       force_webgl_glsl_validation_ ? SH_WEBGL_SPEC : SH_GLES2_SPEC;
   if (shader_spec == SH_WEBGL_SPEC && features().enable_shader_name_hashing)
 #if !defined(ANGLE_SH_VERSION) || ANGLE_SH_VERSION < 108
     resources.HashFunction = &CityHashForAngle;
 #else
     resources.HashFunction = &CityHash64;
 #endif
@@ skipping 1489 matching lines @@
       if (params) {
         params[0] = texture_manager()->MaxSizeForTarget(GL_TEXTURE_2D);
       }
       return true;
     case GL_MAX_CUBE_MAP_TEXTURE_SIZE:
       *num_written = 1;
       if (params) {
         params[0] = texture_manager()->MaxSizeForTarget(GL_TEXTURE_CUBE_MAP);
       }
       return true;
+    case GL_MAX_COLOR_ATTACHMENTS_EXT:
+      *num_written = 1;
+      if (params) {
+        params[0] = group_->max_color_attachments();
+      }
+      return true;
+    case GL_MAX_DRAW_BUFFERS_ARB:
+      *num_written = 1;
+      if (params) {
+        params[0] = group_->max_draw_buffers();
+      }
+      return true;
     case GL_ALPHA_BITS:
       *num_written = 1;
       if (params) {
         GLint v = 0;
         glGetIntegerv(GL_ALPHA_BITS, &v);
         params[0] = BoundFramebufferHasColorAttachmentWithAlpha() ? v : 0;
       }
       return true;
     case GL_DEPTH_BITS:
       *num_written = 1;
@@ skipping 212 matching lines @@
         params[0] = unpack_premultiply_alpha_;
       }
       return true;
     case GL_UNPACK_UNPREMULTIPLY_ALPHA_CHROMIUM:
       *num_written = 1;
       if (params) {
         params[0] = unpack_unpremultiply_alpha_;
       }
       return true;
     default:
+      if (pname >= GL_DRAW_BUFFER0_ARB &&
+          pname < GL_DRAW_BUFFER0_ARB + group_->max_draw_buffers()) {
+        *num_written = 1;
+        if (params) {
+          Framebuffer* framebuffer =
+              GetFramebufferInfoForTarget(GL_FRAMEBUFFER);
+          if (framebuffer) {
+            params[0] = framebuffer->GetDrawBuffer(pname);
+          } else {  // backbuffer
+            params[0] = group_->GetDrawBuffer(pname);
+            if (params[0] == static_cast<GLint>(
+                    pname - GL_DRAW_BUFFER0_ARB + GL_COLOR_ATTACHMENT0)) {
+              params[0] = GL_BACK;
+            } else {
+              DCHECK(params[0] == GL_NONE);
+            }
+          }
+        }
+        return true;
+      }
       *num_written = util_.GLGetNumValuesReturned(pname);
       return false;
   }
 }
 
 bool GLES2DecoderImpl::GetNumValuesReturnedForGLGet(
     GLenum pname, GLsizei* num_values) {
   if (state_.GetStateAsGLint(pname, NULL, num_values)) {
     return true;
   }
@@ skipping 5735 matching lines @@
   if (gpu_tracer_->CurrentName().empty()) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         "glTraceEndCHROMIUM", "no trace begin found");
     return;
   }
   TRACE_EVENT_COPY_ASYNC_END0("gpu", gpu_tracer_->CurrentName().c_str(), this);
   gpu_tracer_->End();
 }
 
+void GLES2DecoderImpl::DoDrawBuffersEXT(
+    GLsizei count, const GLenum* bufs) {
+  if (count > static_cast<GLsizei>(group_->max_draw_buffers())) {
+    LOCAL_SET_GL_ERROR(
+        GL_INVALID_VALUE,
+        "glDrawBuffersEXT", "greater than GL_MAX_DRAW_BUFFERS_EXT");
+    return;
+  }
+
+  Framebuffer* framebuffer = GetFramebufferInfoForTarget(GL_FRAMEBUFFER);
+  if (framebuffer) {
+    for (GLsizei i = 0; i < count; ++i) {
+      if (bufs[i] != static_cast<GLenum>(GL_COLOR_ATTACHMENT0 + i) &&
+          bufs[i] != GL_NONE) {
+        LOCAL_SET_GL_ERROR(
+            GL_INVALID_OPERATION,
+            "glDrawBuffersEXT",
+            "bufs[i] not GL_NONE or GL_COLOR_ATTACHMENTi_EXT");
+        return;
+      }
+    }
+    glDrawBuffersARB(count, bufs);
+    framebuffer->SetDrawBuffers(count, bufs);
+  } else {  // backbuffer
+    for (GLsizei i = 0; i < count; ++i) {
+      if (bufs[i] != GL_BACK && bufs[i] != GL_NONE) {
+        LOCAL_SET_GL_ERROR(
+            GL_INVALID_OPERATION,
+            "glDrawBuffersEXT", "bufs[i] not GL_NONE or GL_BACK");
+        return;
+      }
+    }
+    scoped_array<GLenum> mapped_bufs;
+    const GLenum* my_bufs = bufs;
+    if (GetBackbufferServiceId() != 0) {  // emulated backbuffer
+      mapped_bufs.reset(new GLenum(count));
+      my_bufs = mapped_bufs.get();
+      for (GLsizei i = 0; i < count; ++i) {
+        if (bufs[i] == GL_BACK)

[greggman, 2013/03/14 00:51:10]

It's this correct. I thought the only valid values for DrawBuffers on fbo 0 are

 bufs[0] == GL_NONE || bufs[0] == GL_BACK

and all other bufs have to be GL_NONE

no? 

[Zhenyao Mo, 2013/03/14 01:49:34]

Done.

+          mapped_bufs[i] = static_cast<GLenum>(GL_COLOR_ATTACHMENT0 + i);
+        else
+          mapped_bufs[i] = bufs[i];
+      }
+    }
+    glDrawBuffersARB(count, my_bufs);
+    group_->SetDrawBuffers(count, bufs);
+  }
+}
+
 bool GLES2DecoderImpl::ValidateAsyncTransfer(
     const char* function_name,
     Texture* texture,
     GLenum target,
     GLint level,
     const void * data) {
   // We only support async uploads to 2D textures for now.
   if (GL_TEXTURE_2D != target) {
     LOCAL_SET_GL_ERROR_INVALID_ENUM(function_name, target, "target");
     return false;
@@ skipping 212 matching lines @@
   return error::kNoError;
 }
 
 // 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 "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu