Updating texture validation to account for sampler objects in ES3

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 1892 matching lines @@
   // and allow context preemption and GPU watchdog checks in GpuScheduler().
   void ExitCommandProcessingEarly() { commands_to_process_ = 0; }
 
   void ProcessPendingReadPixels(bool did_finish);
   void FinishReadPixels(const cmds::ReadPixels& c, GLuint buffer);
 
   void DoBindFragmentInputLocationCHROMIUM(GLuint program_id,
                                            GLint location,
                                            const std::string& name);
 
+  const SamplerState& GetSamplerStateForTextureUnit(GLenum target, GLuint unit);
+
   // Generate a member function prototype for each command in an automated and
   // typesafe way.
 #define GLES2_CMD_OP(name) \
   Error Handle##name(uint32 immediate_data_size, const void* data);
 
   GLES2_COMMAND_LIST(GLES2_CMD_OP)
 
   #undef GLES2_CMD_OP
 
   // The GL context this decoder renders to on behalf of the client.
@@ skipping 180 matching lines @@
     uint16 arg_count;  // How many arguments are expected for this command.
   };
 
   // A table of CommandInfo for all the commands.
   static const CommandInfo command_info[kNumCommands - kStartPoint];
 
   bool force_shader_name_hashing_for_test;
 
   GLfloat line_width_range_[2];
 
+  SamplerState default_sampler_state_;
+
   DISALLOW_COPY_AND_ASSIGN(GLES2DecoderImpl);
 };
 
 const GLES2DecoderImpl::CommandInfo GLES2DecoderImpl::command_info[] = {
 #define GLES2_CMD_OP(name)                                   \
   {                                                          \
     &GLES2DecoderImpl::Handle##name, cmds::name::kArgFlags,  \
         cmds::name::cmd_flags,                               \
         sizeof(cmds::name) / sizeof(CommandBufferEntry) - 1, \
   }                                                          \
@@ skipping 5526 matching lines @@
           "GLES2DecoderImpl::DoCopyTexImageIfNeeded", GetErrorState());
       glBindTexture(textarget, texture->service_id());
       DoCopyTexImage(texture, textarget, image);
       RestoreCurrentTextureBindings(&state_, textarget);
     }
   }
 }
 
 bool GLES2DecoderImpl::PrepareTexturesForRender() {
   DCHECK(state_.current_program.get());
-  if (!texture_manager()->HaveUnrenderableTextures() &&
-      !texture_manager()->HaveImages()) {
+  if (!texture_manager()->HaveImages()) {

[Zhenyao Mo, 2015/12/14 22:48:33]

This is wrong.  Now we can't short cut here as we don't know unrenderable
texture count.

[Ken Russell (switch to Gerrit), 2015/12/14 23:22:44]

Could this be updated so that at least ES 2.0 contexts can still short-cut these
checks if there aren't any unrenderable textures in the texture manager?

[Zhenyao Mo, 2015/12/14 23:58:17]

Now that we could possibly share textures among ES2/ES3 context through mailbox,
we really can't decide until render time.  Unless we have RENDERABLE_ES2 and
HaveUnrenderableTexturesES2(), but then all the designs to unify ES2/ES3 texture
handling will be lost.  Assuming the ultimate step is to upgrade the compositor
to also ES3, this shortcut is short-lived anyway.

What do you think?

[Ken Russell (switch to Gerrit), 2015/12/15 00:27:20]

It's a good point. As long as these checks are only being done for the textures
consumed by the active program, I guess it sounds OK to remove the
short-circuit. We need to be careful to not regress per-draw-call performance.

     return true;
   }
   bool textures_set = false;
   const Program::SamplerIndices& sampler_indices =
      state_.current_program->sampler_indices();
   for (size_t ii = 0; ii < sampler_indices.size(); ++ii) {
     const Program::UniformInfo* uniform_info =
         state_.current_program->GetUniformInfo(sampler_indices[ii]);
     DCHECK(uniform_info);
     for (size_t jj = 0; jj < uniform_info->texture_units.size(); ++jj) {
       GLuint texture_unit_index = uniform_info->texture_units[jj];
       if (texture_unit_index < state_.texture_units.size()) {
         TextureUnit& texture_unit = state_.texture_units[texture_unit_index];
         TextureRef* texture_ref =
             texture_unit.GetInfoForSamplerType(uniform_info->type).get();
         GLenum textarget = GetBindTargetForSamplerType(uniform_info->type);
-        if (!texture_ref || !texture_manager()->CanRender(texture_ref)) {
+        const SamplerState& sampler_state = GetSamplerStateForTextureUnit(
+            uniform_info->type, texture_unit_index);
+        if (!texture_ref ||
+            !texture_manager()->CanRenderWithSampler(
+                texture_ref, sampler_state)) {
           textures_set = true;
           glActiveTexture(GL_TEXTURE0 + texture_unit_index);
           glBindTexture(
               textarget,
               texture_manager()->black_texture_id(uniform_info->type));
           if (!texture_ref) {
             LOCAL_RENDER_WARNING(
                 std::string("there is no texture bound to the unit ") +
                 base::UintToString(texture_unit_index));
           } else {
@@ skipping 35 matching lines @@
   for (size_t ii = 0; ii < sampler_indices.size(); ++ii) {
     const Program::UniformInfo* uniform_info =
         state_.current_program->GetUniformInfo(sampler_indices[ii]);
     DCHECK(uniform_info);
     for (size_t jj = 0; jj < uniform_info->texture_units.size(); ++jj) {
       GLuint texture_unit_index = uniform_info->texture_units[jj];
       if (texture_unit_index < state_.texture_units.size()) {
         TextureUnit& texture_unit = state_.texture_units[texture_unit_index];
         TextureRef* texture_ref =
             texture_unit.GetInfoForSamplerType(uniform_info->type).get();
-        if (!texture_ref || !texture_manager()->CanRender(texture_ref)) {
+        const SamplerState& sampler_state = GetSamplerStateForTextureUnit(
+            uniform_info->type, texture_unit_index);
+        if (!texture_ref ||
+            !texture_manager()->CanRenderWithSampler(
+                texture_ref, sampler_state)) {
           glActiveTexture(GL_TEXTURE0 + texture_unit_index);
           // Get the texture_ref info that was previously bound here.
           texture_ref = texture_unit.bind_target == GL_TEXTURE_2D
                             ? texture_unit.bound_texture_2d.get()
                             : texture_unit.bound_texture_cube_map.get();
           glBindTexture(texture_unit.bind_target,
                         texture_ref ? texture_ref->service_id() : 0);
           continue;
         }
       }
@@ skipping 7905 matching lines @@
   if (location < 0 ||
       static_cast<uint32>(location) >= group_->max_varying_vectors() * 4) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, kFunctionName,
                        "location out of range");
     return;
   }
 
   program->SetFragmentInputLocationBinding(name, location);
 }
 
+const SamplerState& GLES2DecoderImpl::GetSamplerStateForTextureUnit(
+    GLenum target, GLuint unit) {
+  if (features().enable_samplers) {
+    Sampler* sampler = state_.sampler_units[unit].get();
+    if (sampler)
+      return sampler->sampler_state();
+  }
+  TextureUnit& texture_unit = state_.texture_units[unit];
+  TextureRef* texture_ref = texture_unit.GetInfoForSamplerType(target).get();
+  if (texture_ref)
+    return texture_ref->texture()->sampler_state();
+
+  return default_sampler_state_;
+}
+
 error::Error GLES2DecoderImpl::HandleBindFragmentInputLocationCHROMIUMBucket(
     uint32 immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::BindFragmentInputLocationCHROMIUMBucket& c =
       *static_cast<const gles2::cmds::BindFragmentInputLocationCHROMIUMBucket*>(
           cmd_data);
   if (!features().chromium_path_rendering) {
     return error::kUnknownCommand;
   }
 
@@ skipping 116 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