command_buffer: Implement EXT_blend_func_extended

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 <cmath>
@@ skipping 1252 matching lines @@
   // Creates a vertex attrib manager for the given vertex array.
   scoped_refptr<VertexAttribManager> CreateVertexAttribManager(
       GLuint client_id,
       GLuint service_id,
       bool client_visible) {
     return vertex_array_manager()->CreateVertexAttribManager(
         client_id, service_id, group_->max_vertex_attribs(), client_visible);
   }
 
   void DoBindAttribLocation(GLuint client_id, GLuint index, const char* name);
+
+  error::Error DoBindFragDataLocation(GLuint program_id,
+                                      GLuint colorName,
+                                      const char* name);
+
+  error::Error DoBindFragDataLocationIndexed(GLuint program_id,
+                                             GLuint colorName,
+                                             GLuint index,
+                                             const char* name);
+
   void DoBindUniformLocationCHROMIUM(
       GLuint client_id, GLint location, const char* name);
 
   error::Error GetAttribLocationHelper(
       GLuint client_id, uint32 location_shm_id, uint32 location_shm_offset,
       const std::string& name_str);
 
   error::Error GetUniformLocationHelper(
       GLuint client_id, uint32 location_shm_id, uint32 location_shm_offset,
       const std::string& name_str);
 
   error::Error GetFragDataLocationHelper(
       GLuint client_id, uint32 location_shm_id, uint32 location_shm_offset,
       const std::string& name_str);
 
+  error::Error GetFragDataIndexHelper(GLuint program_id,
+                                      uint32 index_shm_id,
+                                      uint32 index_shm_offset,
+                                      const std::string& name_str);
+
   // Wrapper for glShaderSource.
   void DoShaderSource(
       GLuint client_id, GLsizei count, const char** data, const GLint* length);
 
   // Wrapper for glTransformFeedbackVaryings.
   void DoTransformFeedbackVaryings(
       GLuint client_program_id, GLsizei count, const char* const* varyings,
       GLenum buffer_mode);
 
   // Clear any textures used by the current program.
@@ skipping 1955 matching lines @@
   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 = group_->max_draw_buffers();
   resources.MaxExpressionComplexity = 256;
   resources.MaxCallStackDepth = 256;
+  resources.MaxDualSourceDrawBuffers = group_->max_dual_source_draw_buffers();
 
   GLint range[2] = { 0, 0 };
   GLint precision = 0;
   GetShaderPrecisionFormatImpl(GL_FRAGMENT_SHADER, GL_HIGH_FLOAT,
                                range, &precision);
   resources.FragmentPrecisionHigh =
       PrecisionMeetsSpecForHighpFloat(range[0], range[1], precision);
 
   if (IsWebGLContext()) {
     resources.OES_standard_derivatives = derivatives_explicitly_enabled_;
@@ skipping 12 matching lines @@
     resources.OES_EGL_image_external =
         features().oes_egl_image_external ? 1 : 0;
     resources.EXT_draw_buffers =
         features().ext_draw_buffers ? 1 : 0;
     resources.EXT_frag_depth =
         features().ext_frag_depth ? 1 : 0;
     resources.EXT_shader_texture_lod =
         features().ext_shader_texture_lod ? 1 : 0;
     resources.NV_draw_buffers =
         features().nv_draw_buffers ? 1 : 0;
+    resources.EXT_blend_func_extended =
+        features().ext_blend_func_extended ? 1 : 0;
   }
 
   ShShaderSpec shader_spec;
   switch (context_type_) {
     case ContextGroup::CONTEXT_TYPE_WEBGL1:
       shader_spec = SH_WEBGL_SPEC;
       break;
     case ContextGroup::CONTEXT_TYPE_WEBGL2:
       shader_spec = SH_WEBGL2_SPEC;
       break;
@@ skipping 2148 matching lines @@
           *params = 0;
         }
       }
       return true;
     case GL_BIND_GENERATES_RESOURCE_CHROMIUM:
       *num_written = 1;
       if (params) {
         params[0] = group_->bind_generates_resource() ? 1 : 0;
       }
       return true;
+    case GL_MAX_DUAL_SOURCE_DRAW_BUFFERS:
+      *num_written = 1;
+      if (params) {
+        params[0] = group_->max_dual_source_draw_buffers();
+      }
+      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
@@ skipping 160 matching lines @@
     return error::kInvalidArguments;
   }
   std::string name_str;
   if (!bucket->GetAsString(&name_str)) {
     return error::kInvalidArguments;
   }
   DoBindAttribLocation(program, index, name_str.c_str());
   return error::kNoError;
 }
 
+error::Error GLES2DecoderImpl::DoBindFragDataLocation(GLuint program_id,
+                                                      GLuint colorName,
+                                                      const char* name) {
+  if (!unsafe_es3_apis_enabled())
+    return error::kUnknownCommand;
+
+  const char kFunctionName[] = "glBindFragDataLocationEXT";
+  if (!StringIsValidForGLES(name)) {
+    LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, kFunctionName, "Invalid character");
+    return error::kNoError;
+  }
+  if (ProgramManager::IsInvalidPrefix(name, strlen(name))) {
+    LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, kFunctionName, "reserved prefix");
+    return error::kNoError;
+  }
+  if (colorName >= group_->max_draw_buffers()) {
+    LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, kFunctionName,
+                       "colorName out of range");
+    return error::kNoError;
+  }
+  Program* program = GetProgramInfoNotShader(program_id, kFunctionName);
+  if (!program) {
+    return error::kNoError;
+  }
+  DCHECK(!IsWebGLContext());
+  // Note: the name is passed directly, since names are never hashed for
+  // non-WebGL context. Also the
+  // potential built-in names can not be controlled by the client, since they
+  // will be overridden if
+  // used.
+  glBindFragDataLocation(program->service_id(), colorName, name);
+  return error::kNoError;
+}
+error::Error GLES2DecoderImpl::HandleBindFragDataLocationEXTBucket(
+    uint32 immediate_data_size,
+    const void* cmd_data) {
+  const gles2::cmds::BindFragDataLocationEXTBucket& c =
+      *static_cast<const gles2::cmds::BindFragDataLocationEXTBucket*>(cmd_data);
+  GLuint program = static_cast<GLuint>(c.program);
+  GLuint colorNumber = static_cast<GLint>(c.colorNumber);
+  Bucket* bucket = GetBucket(c.name_bucket_id);
+  if (!bucket || bucket->size() == 0) {
+    return error::kInvalidArguments;
+  }
+  std::string name_str;
+  if (!bucket->GetAsString(&name_str)) {
+    return error::kInvalidArguments;
+  }
+  return DoBindFragDataLocation(program, colorNumber, name_str.c_str());
+}
+
+error::Error GLES2DecoderImpl::DoBindFragDataLocationIndexed(GLuint program_id,
+                                                             GLuint colorName,
+                                                             GLuint index,
+                                                             const char* name) {
+  if (!unsafe_es3_apis_enabled())
+    return error::kUnknownCommand;
+
+  const char kFunctionName[] = "glBindFragDataLocationIndexEXT";
+  if (!StringIsValidForGLES(name)) {
+    LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, kFunctionName, "Invalid character");
+    return error::kNoError;
+  }
+  if (ProgramManager::IsInvalidPrefix(name, strlen(name))) {
+    LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, kFunctionName, "reserved prefix");
+    return error::kNoError;
+  }
+  if ((index == 0 && colorName >= group_->max_draw_buffers()) ||
+      (index == 1 && colorName >= group_->max_dual_source_draw_buffers())) {
+    LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, kFunctionName,
+                       "colorName out of range for the color index");
+    return error::kNoError;
+  }
+  Program* program = GetProgramInfoNotShader(program_id, kFunctionName);
+  if (!program) {
+    return error::kNoError;
+  }
+  DCHECK(!IsWebGLContext());
+  // Note: the name is passed directly, since names are never hashed for
+  // non-WebGL context. Also the
+  // potential built-in names can not be controlled by the client, since they
+  // will be overridden if
+  // used.
+  glBindFragDataLocationIndexed(program->service_id(), colorName, index, name);
+  return error::kNoError;
+}
+
+error::Error GLES2DecoderImpl::HandleBindFragDataLocationIndexedEXTBucket(
+    uint32 immediate_data_size,
+    const void* cmd_data) {
+  const gles2::cmds::BindFragDataLocationIndexedEXTBucket& c =
+      *static_cast<const gles2::cmds::BindFragDataLocationIndexedEXTBucket*>(
+          cmd_data);
+  GLuint program = static_cast<GLuint>(c.program);
+  GLuint colorNumber = static_cast<GLint>(c.colorNumber);
+  GLuint index = static_cast<GLint>(c.index);
+  Bucket* bucket = GetBucket(c.name_bucket_id);
+  if (!bucket || bucket->size() == 0) {
+    return error::kInvalidArguments;
+  }
+  std::string name_str;
+  if (!bucket->GetAsString(&name_str)) {
+    return error::kInvalidArguments;
+  }
+  return DoBindFragDataLocationIndexed(program, colorNumber, index,
+                                       name_str.c_str());
+}
+
 void GLES2DecoderImpl::DoBindUniformLocationCHROMIUM(
     GLuint program_id, GLint location, const char* name) {
   if (!StringIsValidForGLES(name)) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE,
         "glBindUniformLocationCHROMIUM", "Invalid character");
     return;
   }
   if (ProgramManager::IsInvalidPrefix(name, strlen(name))) {
     LOCAL_SET_GL_ERROR(
@@ skipping 3534 matching lines @@
     result->SetNumResults(count);
   } else {
     LOCAL_SET_GL_ERROR(error, "GetUniformIndices", "");
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::GetFragDataLocationHelper(
     GLuint client_id, uint32 location_shm_id, uint32 location_shm_offset,
     const std::string& name_str) {
+  const char kFunctionName[] = "glGetFragDataLocation";
   GLint* location = GetSharedMemoryAs<GLint*>(
       location_shm_id, location_shm_offset, sizeof(GLint));
   if (!location) {
     return error::kOutOfBounds;
   }
   // Require the client to init this incase the context is lost and we are no
   // longer executing commands.
   if (*location != -1) {
     return error::kGenericError;
   }
-  Program* program = GetProgramInfoNotShader(
-      client_id, "glGetFragDataLocation");
+  Program* program = GetProgramInfoNotShader(client_id, kFunctionName);
   if (!program) {
     return error::kNoError;
   }
-  *location = glGetFragDataLocation(program->service_id(), name_str.c_str());
+  if (!program->IsValid()) {
+    LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, kFunctionName,
+                       "program not linked");
+    return error::kNoError;
+  }

[Mark Kilgard, 2015/08/28 19:53:24]

yes, good to add this link check here

+
+  *location = program->GetFragDataLocation(name_str);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetFragDataLocation(
     uint32 immediate_data_size,
     const void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
   const gles2::cmds::GetFragDataLocation& c =
       *static_cast<const gles2::cmds::GetFragDataLocation*>(cmd_data);
   Bucket* bucket = GetBucket(c.name_bucket_id);
   if (!bucket) {
     return error::kInvalidArguments;
   }
   std::string name_str;
   if (!bucket->GetAsString(&name_str)) {
     return error::kInvalidArguments;
   }
   return GetFragDataLocationHelper(
       c.program, c.location_shm_id, c.location_shm_offset, name_str);
 }
 
+error::Error GLES2DecoderImpl::GetFragDataIndexHelper(
+    GLuint program_id,
+    uint32 index_shm_id,
+    uint32 index_shm_offset,
+    const std::string& name_str) {
+  const char kFunctionName[] = "glGetFragDataIndexEXT";
+  GLint* index =
+      GetSharedMemoryAs<GLint*>(index_shm_id, index_shm_offset, sizeof(GLint));
+  if (!index) {
+    return error::kOutOfBounds;
+  }
+  // Require the client to init this incase the context is lost and we are no
+  // longer executing commands.
+  if (*index != -1) {
+    return error::kGenericError;
+  }
+  Program* program = GetProgramInfoNotShader(program_id, kFunctionName);
+  if (!program) {
+    return error::kNoError;
+  }
+  if (!program->IsValid()) {
+    LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, kFunctionName,
+                       "program not linked");
+    return error::kNoError;
+  }
+
+  *index = program->GetFragDataIndex(name_str);
+  return error::kNoError;
+}
+
+error::Error GLES2DecoderImpl::HandleGetFragDataIndexEXT(
+    uint32 immediate_data_size,
+    const void* cmd_data) {
+  if (!unsafe_es3_apis_enabled())
+    return error::kUnknownCommand;
+  const gles2::cmds::GetFragDataIndexEXT& c =
+      *static_cast<const gles2::cmds::GetFragDataIndexEXT*>(cmd_data);
+  Bucket* bucket = GetBucket(c.name_bucket_id);
+  if (!bucket) {
+    return error::kInvalidArguments;
+  }
+  std::string name_str;
+  if (!bucket->GetAsString(&name_str)) {
+    return error::kInvalidArguments;
+  }
+  return GetFragDataIndexHelper(c.program, c.index_shm_id, c.index_shm_offset,
+
+                                name_str);
+}
+
 error::Error GLES2DecoderImpl::HandleGetUniformBlockIndex(
     uint32 immediate_data_size, const void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
   const gles2::cmds::GetUniformBlockIndex& c =
       *static_cast<const gles2::cmds::GetUniformBlockIndex*>(cmd_data);
   Bucket* bucket = GetBucket(c.name_bucket_id);
   if (!bucket) {
     return error::kInvalidArguments;
   }
@@ skipping 6219 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