WebGL 2: make sure VertexAttrib type match the corresponding attrib type in shader

gpu/command_buffer/service/program_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/program_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 99 matching lines @@
   if (hit == varyings.end())
     return false;
   return hit->second.isInvariant;
 }
 
 uint32_t ComputeOffset(const void* start, const void* position) {
   return static_cast<const uint8_t*>(position) -
          static_cast<const uint8_t*>(start);
 }
 
-ShaderVariableBaseType FragmentOutputTypeToBaseType(GLenum type) {
+ShaderVariableBaseType InputOutputTypeToBaseType(bool is_input, GLenum type) {
   switch (type) {
     case GL_INT:
     case GL_INT_VEC2:
     case GL_INT_VEC3:
     case GL_INT_VEC4:
       return SHADER_VARIABLE_INT;
     case GL_UNSIGNED_INT:
     case GL_UNSIGNED_INT_VEC2:
     case GL_UNSIGNED_INT_VEC3:
     case GL_UNSIGNED_INT_VEC4:
       return SHADER_VARIABLE_UINT;
     case GL_FLOAT:
     case GL_FLOAT_VEC2:
     case GL_FLOAT_VEC3:
     case GL_FLOAT_VEC4:
       return SHADER_VARIABLE_FLOAT;
+    case GL_FLOAT_MAT2:
+    case GL_FLOAT_MAT3:
+    case GL_FLOAT_MAT4:
+    case GL_FLOAT_MAT2x3:
+    case GL_FLOAT_MAT3x2:
+    case GL_FLOAT_MAT2x4:
+    case GL_FLOAT_MAT4x2:
+    case GL_FLOAT_MAT3x4:
+    case GL_FLOAT_MAT4x3:
+      DCHECK(is_input);
+      return SHADER_VARIABLE_FLOAT;
     default:
       NOTREACHED();
       return SHADER_VARIABLE_UNDEFINED_TYPE;
   }
 }
 
 }  // anonymous namespace.
 
 Program::UniformInfo::UniformInfo()
     : size(0),
@@ skipping 162 matching lines @@
   attrib_infos_.clear();
   uniform_infos_.clear();
   uniform_locations_.clear();
   fragment_input_infos_.clear();
   fragment_input_locations_.clear();
   program_output_infos_.clear();
   sampler_indices_.clear();
   attrib_location_to_index_map_.clear();
   fragment_output_type_mask_ = 0u;
   fragment_output_written_mask_ = 0u;
+  vertex_input_base_type_mask_.clear();
+  vertex_input_type_written_mask_.clear();
 }
 
 void Program::UpdateFragmentOutputBaseTypes() {
   fragment_output_type_mask_ = 0u;
   fragment_output_written_mask_ = 0u;
   Shader* fragment_shader =
       attached_shaders_[ShaderTypeToIndex(GL_FRAGMENT_SHADER)].get();
   DCHECK(fragment_shader);
   for (auto const& output : fragment_shader->output_variable_list()) {
     int location = output.location;
@@ skipping 15 matching lines @@
       // TODO(zmo): This does not work with glBindFragDataLocationIndexed.
       // crbug.com/628010
       // For example:
       //    glBindFragDataLocationIndexed(program, loc, 0, "FragData0");
       //    glBindFragDataLocationIndexed(program, loc, 1, "FragData1");
       // The program links OK, but both calling glGetFragDataLocation on both
       // "FragData0" and "FragData1" returns 0.
       int shift_bits = ii * 2;
       fragment_output_written_mask_ |= 0x3 << shift_bits;
       fragment_output_type_mask_ |=
-          FragmentOutputTypeToBaseType(output.type) << shift_bits;
+          InputOutputTypeToBaseType(false, output.type) << shift_bits;
     }
   }
 }
 
+void Program::UpdateVertexInputBaseTypes() {
+  max_vertex_attribs_ = manager_->max_vertex_attribs();
+  uint32_t packed_size = max_vertex_attribs_ / 16;
+  packed_size += (max_vertex_attribs_ % 16 == 0) ? 0 : 1;
+  vertex_input_base_type_mask_.resize(packed_size);
+  vertex_input_type_written_mask_.resize(packed_size);
+
+  for (uint32_t ii = 0; ii < packed_size; ++ii) {
+    vertex_input_type_written_mask_[ii] = 0u;
+    vertex_input_base_type_mask_[ii] = 0u;
+  }
+
+  for (size_t ii = 0; ii < attrib_infos_.size(); ++ii) {
+    DCHECK(ii < max_vertex_attribs_);
+    const VertexAttrib& input = attrib_infos_[ii];
+    if (ProgramManager::HasBuiltInPrefix(input.name)) {
+      continue;
+    }
+    int shift_bits = (input.location % 16) * 2;
+      vertex_input_type_written_mask_[ii / 16] |= 0x3 << shift_bits;
+      vertex_input_base_type_mask_[ii / 16] |=
+          InputOutputTypeToBaseType(true, input.type) << shift_bits;
+  }
+}
+
 void Program::UpdateUniformBlockSizeInfo() {
   switch (feature_info().context_type()) {
     case CONTEXT_TYPE_OPENGLES2:
     case CONTEXT_TYPE_WEBGL1:
       // Uniform blocks do not exist in ES2.
       return;
     default:
       break;
   }
 
@@ skipping 247 matching lines @@
       DVLOG(1) << ii++ << ": loc = " << info.element_locations[0]
                << ", size = " << info.size
                << ", type = " << GLES2Util::GetStringEnum(info.type)
                << ", name = " << info.name;
     }
   }
 
   UpdateFragmentInputs();
   UpdateProgramOutputs();
   UpdateFragmentOutputBaseTypes();
+  UpdateVertexInputBaseTypes();
   UpdateUniformBlockSizeInfo();
 
   valid_ = true;
 }
 
 void Program::UpdateUniforms() {
   // Reserve each client-bound uniform location. This way unbound uniforms will
   // not be allocated to locations that user expects bound uniforms to be, even
   // if the expected uniforms are optimized away by the driver.
   for (const auto& binding : bind_uniform_location_map_) {
@@ skipping 1733 matching lines @@
     manager_->StopTracking(this);
     manager_ = NULL;
   }
 }
 
 ProgramManager::ProgramManager(
     ProgramCache* program_cache,
     uint32_t max_varying_vectors,
     uint32_t max_draw_buffers,
     uint32_t max_dual_source_draw_buffers,
+    uint32_t max_vertex_attribs,
     const GpuPreferences& gpu_preferences,
     FeatureInfo* feature_info)
     : program_count_(0),
       have_context_(true),
       program_cache_(program_cache),
       max_varying_vectors_(max_varying_vectors),
       max_draw_buffers_(max_draw_buffers),
       max_dual_source_draw_buffers_(max_dual_source_draw_buffers),
+      max_vertex_attribs_(max_vertex_attribs),
       gpu_preferences_(gpu_preferences),
       feature_info_(feature_info) {}
 
 ProgramManager::~ProgramManager() {
   DCHECK(programs_.empty());
 }
 
 void ProgramManager::Destroy(bool have_context) {
   have_context_ = have_context;
   programs_.clear();
@@ skipping 95 matching lines @@
   DCHECK(program);
   program->ClearUniforms(&zero_);
 }
 
 int32_t ProgramManager::MakeFakeLocation(int32_t index, int32_t element) {
   return index + element * 0x10000;
 }
 
 }  // namespace gles2
 }  // namespace gpu