automate more GL state handling

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 919 matching lines @@
                           int height,
                           bool is_texture_immutable) OVERRIDE;
 
   // Restore all GL state that affects clearing.
   void RestoreClearState();
 
   // Remembers the state of some capabilities.
   // Returns: true if glEnable/glDisable should actually be called.
   bool SetCapabilityState(GLenum cap, bool enabled);
 
+  // Initalizes all the glEnable/glDisable settings.
+  void InitCapabilities();
+
+  // Initializes all the state.
+  void InitState();
+
   // Check that the currently bound framebuffers are valid.
   // Generates GL error if not.
   bool CheckBoundFramebuffersValid(const char* func_name);
 
   // Check if a framebuffer meets our requirements.
   bool CheckFramebufferValid(
       FramebufferManager::FramebufferInfo* framebuffer,
       GLenum target,
       const char* func_name);
 
@@ skipping 14 matching lines @@
   // does not overflow the uniform.
   bool PrepForSetUniformByLocation(
       GLint fake_location, const char* function_name,
       GLint* real_location, GLenum* type, GLsizei* count);
 
   // Gets the service id for any simulated backbuffer fbo.
   GLuint GetBackbufferServiceId();
 
   // Helper for glGetBooleanv, glGetFloatv and glGetIntegerv
   bool GetHelper(GLenum pname, GLint* params, GLsizei* num_written);
+  // Same as GetHealper except for auto-generated state.

[apatrick_chromium, 2012/10/29 19:50:03]

GetHealper -> GetHelper

+  bool GetState(GLenum pname, GLint* params, GLsizei* num_written);
 
   // Wrapper for glCreateProgram
   bool CreateProgramHelper(GLuint client_id);
 
   // Wrapper for glCreateShader
   bool CreateShaderHelper(GLenum type, GLuint client_id);
 
   // Wrapper for glActiveTexture
   void DoActiveTexture(GLenum texture_unit);
 
@@ skipping 29 matching lines @@
   // Wrapper for glBufferSubData.
   void DoBufferSubData(
     GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid * data);
 
   // Wrapper for glCheckFramebufferStatus
   GLenum DoCheckFramebufferStatus(GLenum target);
 
   // Wrapper for glClear
   error::Error DoClear(GLbitfield mask);
 
-  // Wrappers for clear and mask settings functions.
-  void DoStencilMask(GLuint mask);
-  void DoStencilMaskSeparate(GLenum face, GLuint mask);
-  void DoStencilFunc(GLenum func, GLint ref, GLuint mask);
-  void DoStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask);
-  void DoStencilOp(GLenum fail, GLenum zfail, GLenum zpass);
-  void DoStencilOpSeparate(
-      GLenum face, GLenum fail, GLenum zfail, GLenum zpass);
-
   // Wrappers for various state.
-  void DoBlendEquation(GLenum mode);
-  void DoBlendFunc(GLenum sfactor, GLenum dfactor);
   void DoDepthRangef(GLclampf znear, GLclampf zfar);
   void DoHint(GLenum target, GLenum mode);
   void DoSampleCoverage (GLclampf value, GLboolean invert);
 
   // Wrapper for glCompileShader.
   void DoCompileShader(GLuint shader);
 
   // Helper for DeleteSharedIdsCHROMIUM commands.
   void DoDeleteSharedIdsCHROMIUM(
       GLuint namespace_id, GLsizei n, const GLuint* ids);
@@ skipping 628 matching lines @@
   }
   glBindFramebufferEXT(GL_FRAMEBUFFER, targetid);
 }
 
 ScopedResolvedFrameBufferBinder::~ScopedResolvedFrameBufferBinder() {
   if (!resolve_and_bind_)
     return;
 
   ScopedGLErrorSuppressor suppressor(decoder_);
   decoder_->RestoreCurrentFramebufferBindings();
-  if (decoder_->state_.enable_scissor_test) {
+  if (decoder_->state_.enable_flags.scissor_test) {
     glEnable(GL_SCISSOR_TEST);
   }
 }
 
 ScopedTextureUploadTimer::ScopedTextureUploadTimer(GLES2DecoderImpl* decoder)
     : decoder_(decoder),
       begin_time_(base::TimeTicks::HighResNow()) {
 }
 
 ScopedTextureUploadTimer::~ScopedTextureUploadTimer() {
@@ skipping 539 matching lines @@
   has_robustness_extension_ =
       context->HasExtension("GL_ARB_robustness") ||
       context->HasExtension("GL_EXT_robustness");
 
   if (!InitializeShaderTranslator()) {
     return false;
   }
 
   state_.viewport_width = size.width();
   state_.viewport_height = size.height();
-  glViewport(
-      state_.viewport_x, state_.viewport_y,
-      state_.viewport_width, state_.viewport_height);
 
   GLint viewport_params[4] = { 0 };
   glGetIntegerv(GL_MAX_VIEWPORT_DIMS, viewport_params);
   state_.viewport_max_width = viewport_params[0];
   state_.viewport_max_height = viewport_params[1];
 
   state_.scissor_width = state_.viewport_width;
   state_.scissor_height = state_.viewport_height;
 
   // Set all the default state because some GL drivers get it wrong.
+  InitCapabilities();
+  InitState();
   glActiveTexture(GL_TEXTURE0 + state_.active_texture_unit);
-  EnableDisable(GL_BLEND, state_.enable_blend);
-  glBlendColor(
-      state_.blend_color_red,
-      state_.blend_color_green,
-      state_.blend_color_blue,
-      state_.blend_color_alpha);
-  glBlendFunc(
-      state_.blend_source_rgb,
-      state_.blend_dest_rgb);
-  glBlendFuncSeparate(
-      state_.blend_source_rgb,
-      state_.blend_dest_rgb,
-      state_.blend_source_alpha,
-      state_.blend_dest_alpha);
-  glBlendEquation(
-      state_.blend_equation_rgb);
-  glBlendEquationSeparate(
-      state_.blend_equation_rgb, state_.blend_equation_alpha);
-  glClearColor(
-      state_.color_clear_red, state_.color_clear_green, state_.color_clear_blue,
-      state_.color_clear_alpha);
-  glColorMask(
-      state_.color_mask_red, state_.color_mask_green, state_.color_mask_blue,
-      state_.color_mask_alpha);
-  EnableDisable(GL_CULL_FACE, state_.enable_cull_face);
-  glCullFace(state_.cull_mode);
-  glClearDepth(state_.depth_clear);
-  glDepthFunc(state_.depth_func);
-  glDepthRange(state_.z_near, state_.z_far);
-  EnableDisable(GL_DEPTH_TEST, state_.enable_depth_test);
-  EnableDisable(GL_DITHER, state_.enable_dither);
-  glFrontFace(state_.front_face);
   glHint(GL_GENERATE_MIPMAP_HINT, state_.hint_generate_mipmap);
-  glLineWidth(state_.line_width);
   glPixelStorei(GL_PACK_ALIGNMENT, state_.pack_alignment);
-  glPolygonOffset(state_.polygon_offset_factor, state_.polygon_offset_units);
-  EnableDisable(GL_POLYGON_OFFSET_FILL, state_.enable_polygon_offset_fill);
-  EnableDisable(
-      GL_SAMPLE_ALPHA_TO_COVERAGE, state_.enable_sample_alpha_to_coverage);
-  EnableDisable(GL_SAMPLE_COVERAGE, state_.enable_sample_coverage);
-  glSampleCoverage(state_.sample_coverage_value, state_.sample_coverage_invert);
-  glScissor(
-      state_.scissor_x, state_.scissor_y,
-      state_.scissor_width, state_.scissor_height);
-  EnableDisable(GL_SCISSOR_TEST, state_.enable_scissor_test);
-  EnableDisable(GL_STENCIL_TEST, state_.enable_stencil_test);
-  glClearStencil(state_.stencil_clear);
-  glStencilFuncSeparate(
-      GL_FRONT,
-      state_.stencil_front_func,
-      state_.stencil_front_ref,
-      state_.stencil_front_mask);
-  glStencilFuncSeparate(
-      GL_BACK,
-      state_.stencil_back_func,
-      state_.stencil_back_ref,
-      state_.stencil_back_mask);
-  glStencilOpSeparate(
-      GL_FRONT,
-      state_.stencil_front_fail_op,
-      state_.stencil_front_z_fail_op,
-      state_.stencil_front_z_pass_op);
-  glStencilOpSeparate(
-      GL_BACK,
-      state_.stencil_back_fail_op,
-      state_.stencil_back_z_fail_op,
-      state_.stencil_back_z_pass_op);
-  glStencilMaskSeparate(GL_FRONT, state_.stencil_front_writemask);
-  glStencilMaskSeparate(GL_BACK, state_.stencil_back_writemask);
   glPixelStorei(GL_UNPACK_ALIGNMENT, state_.unpack_alignment);
 
   DoBindBuffer(GL_ARRAY_BUFFER, 0);
   DoBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
   DoBindFramebuffer(GL_FRAMEBUFFER, 0);
   DoBindRenderbuffer(GL_RENDERBUFFER, 0);
 
   // AMD and Intel drivers on Mac OS apparently get gl_PointCoord
   // backward from the spec and this setting makes them work
   // correctly. rdar://problem/11883495
@@ skipping 1057 matching lines @@
 }
 
 void GLES2DecoderImpl::ApplyDirtyState() {
   if (clear_state_dirty_) {
     glColorMask(
         state_.color_mask_red, state_.color_mask_green, state_.color_mask_blue,
         state_.color_mask_alpha &&
             BoundFramebufferHasColorAttachmentWithAlpha());
     bool have_depth = BoundFramebufferHasDepthAttachment();
     glDepthMask(state_.depth_mask && have_depth);
-    EnableDisable(GL_DEPTH_TEST, state_.enable_depth_test && have_depth);
+    EnableDisable(GL_DEPTH_TEST, state_.enable_flags.depth_test && have_depth);
     bool have_stencil = BoundFramebufferHasStencilAttachment();
     glStencilMaskSeparate(
         GL_FRONT, have_stencil ? state_.stencil_front_writemask : 0);
     glStencilMaskSeparate(
         GL_BACK, have_stencil ? state_.stencil_back_writemask : 0);
-    EnableDisable(GL_STENCIL_TEST, state_.enable_stencil_test && have_stencil);
-    EnableDisable(GL_CULL_FACE, state_.enable_cull_face);
-    EnableDisable(GL_SCISSOR_TEST, state_.enable_scissor_test);
-    EnableDisable(GL_BLEND, state_.enable_blend);
+    EnableDisable(
+        GL_STENCIL_TEST, state_.enable_flags.stencil_test && have_stencil);
+    EnableDisable(GL_CULL_FACE, state_.enable_flags.cull_face);
+    EnableDisable(GL_SCISSOR_TEST, state_.enable_flags.scissor_test);
+    EnableDisable(GL_BLEND, state_.enable_flags.blend);
     clear_state_dirty_ = false;
   }
 }
 
 void GLES2DecoderImpl::BindAndApplyTextureParameters(
     TextureManager::TextureInfo* info) {
   glBindTexture(info->target(), info->service_id());
   glTexParameteri(info->target(), GL_TEXTURE_MIN_FILTER, info->min_filter());
   glTexParameteri(info->target(), GL_TEXTURE_MAG_FILTER, info->mag_filter());
   glTexParameteri(info->target(), GL_TEXTURE_WRAP_S, info->wrap_s());
@@ skipping 233 matching lines @@
         }
         return true;
       case GL_MAX_VERTEX_UNIFORM_VECTORS:
         *num_written = 1;
         if (params) {
           *params = group_->max_vertex_uniform_vectors();
         }
         return true;
       }
   }
+  if (GetState(pname, params, num_written)) {
+    return true;
+  }
   switch (pname) {
     case GL_MAX_VIEWPORT_DIMS:
       if (offscreen_target_frame_buffer_.get()) {
         *num_written = 2;
         if (params) {
           params[0] = renderbuffer_manager()->max_renderbuffer_size();
           params[1] = renderbuffer_manager()->max_renderbuffer_size();
         }
         return true;
       }
@@ skipping 15 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_COLOR_WRITEMASK:
-      *num_written = 4;
-      if (params) {
-        params[0] = state_.color_mask_red;
-        params[1] = state_.color_mask_green;
-        params[2] = state_.color_mask_blue;
-        params[3] = state_.color_mask_alpha;
-      }
-      return true;
-    case GL_DEPTH_WRITEMASK:
-      *num_written = 1;
-      if (params) {
-        params[0] = state_.depth_mask;
-      }
-      return true;
-    case GL_STENCIL_BACK_WRITEMASK:
-      *num_written = 1;
-      if (params) {
-        params[0] = state_.stencil_back_writemask;
-      }
-      return true;
-    case GL_STENCIL_WRITEMASK:
-      *num_written = 1;
-      if (params) {
-        params[0] = state_.stencil_front_writemask;
-      }
-      return true;
-    case GL_DEPTH_TEST:
-      *num_written = 1;
-      if (params) {
-        params[0] = state_.enable_depth_test;
-      }
-      return true;
-    case GL_STENCIL_TEST:
-      *num_written = 1;
-      if (params) {
-        params[0] = state_.enable_stencil_test;
-      }
-      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 591 matching lines @@
       target, attachment, renderbuffertarget, service_id);
   GLenum error = PeekGLError();
   if (error == GL_NO_ERROR) {
     framebuffer_info->AttachRenderbuffer(attachment, info);
   }
   if (framebuffer_info == state_.bound_draw_framebuffer) {
     clear_state_dirty_ = true;
   }
 }
 
-bool GLES2DecoderImpl::SetCapabilityState(GLenum cap, bool enabled) {
-  switch (cap) {
-    case GL_BLEND:
-      state_.enable_blend = enabled;
-      return true;
-    case GL_CULL_FACE:
-      state_.enable_cull_face = enabled;
-      return true;
-    case GL_SCISSOR_TEST:
-      state_.enable_scissor_test = enabled;
-      return true;
-    case GL_DEPTH_TEST: {
-      if (state_.enable_depth_test != enabled) {
-        state_.enable_depth_test = enabled;
-        clear_state_dirty_ = true;
-      }
-      return false;
-    }
-    case GL_STENCIL_TEST:
-      if (state_.enable_stencil_test != enabled) {
-        state_.enable_stencil_test = enabled;
-        clear_state_dirty_ = true;
-      }
-      return false;
-    case GL_POLYGON_OFFSET_FILL:
-      state_.enable_polygon_offset_fill = enabled;
-    case GL_DITHER:
-      state_.enable_dither = enabled;
-    case GL_SAMPLE_ALPHA_TO_COVERAGE:
-      state_.enable_sample_alpha_to_coverage = enabled;
-    case GL_SAMPLE_COVERAGE:
-      state_.enable_sample_coverage = enabled;
-    default:
-      return true;
-  }
-}
-
 void GLES2DecoderImpl::DoDisable(GLenum cap) {
   if (SetCapabilityState(cap, false)) {
     glDisable(cap);
   }
 }
 
 void GLES2DecoderImpl::DoEnable(GLenum cap) {
   if (SetCapabilityState(cap, true)) {
     glEnable(cap);
   }
 }
 
-bool GLES2DecoderImpl::DoIsEnabled(GLenum cap) {
-  switch (cap) {
-    case GL_BLEND:
-      return state_.enable_blend;
-    case GL_CULL_FACE:
-      return state_.enable_cull_face;
-    case GL_SCISSOR_TEST:
-      return state_.enable_scissor_test;
-    case GL_DEPTH_TEST:
-      return state_.enable_depth_test;
-    case GL_STENCIL_TEST:
-      return state_.enable_stencil_test;
-    case GL_POLYGON_OFFSET_FILL:
-      return state_.enable_polygon_offset_fill;
-    case GL_DITHER:
-      return state_.enable_dither;
-    case GL_SAMPLE_ALPHA_TO_COVERAGE:
-      return state_.enable_sample_alpha_to_coverage;
-    case GL_SAMPLE_COVERAGE:
-      return state_.enable_sample_coverage;
-    default:
-      return glIsEnabled(cap) != 0;
-  }
-}
-
 void GLES2DecoderImpl::DoDepthRangef(GLclampf znear, GLclampf zfar) {
   state_.z_near = std::min(1.0f, std::max(0.0f, znear));
   state_.z_far = std::min(1.0f, std::max(0.0f, zfar));
   glDepthRange(znear, zfar);
 }
 
-void GLES2DecoderImpl::DoStencilMask(GLuint mask) {
-  state_.stencil_front_writemask = mask;
-  state_.stencil_back_writemask = mask;
-  clear_state_dirty_ = true;
-}
-
-void GLES2DecoderImpl::DoStencilMaskSeparate(GLenum face, GLuint mask) {
-  if (face == GL_FRONT || face == GL_FRONT_AND_BACK) {
-    state_.stencil_front_writemask = mask;
-  }
-  if (face == GL_BACK || face == GL_FRONT_AND_BACK) {
-    state_.stencil_back_writemask = mask;
-  }
-  clear_state_dirty_ = true;
-}
-
-void GLES2DecoderImpl::DoStencilFunc(GLenum func, GLint ref, GLuint mask) {
-  state_.stencil_front_func = func;
-  state_.stencil_front_ref = ref;
-  state_.stencil_front_mask = mask;
-  state_.stencil_back_func = func;
-  state_.stencil_back_ref = ref;
-  state_.stencil_back_mask = mask;
-  glStencilFunc(func, ref, mask);
-}
-
-void GLES2DecoderImpl::DoStencilFuncSeparate(
-    GLenum face, GLenum func, GLint ref, GLuint mask) {
-  if (face == GL_FRONT || face == GL_FRONT_AND_BACK) {
-    state_.stencil_front_func = func;
-    state_.stencil_front_ref = ref;
-    state_.stencil_front_mask = mask;
-  }
-  if (face == GL_BACK || face == GL_FRONT_AND_BACK) {
-    state_.stencil_back_func = func;
-    state_.stencil_back_ref = ref;
-    state_.stencil_back_mask = mask;
-  }
-  glStencilFuncSeparate(face, func, ref, mask);
-}
-
-void GLES2DecoderImpl::DoStencilOp(
-    GLenum fail, GLenum zfail, GLenum zpass) {
-  state_.stencil_front_fail_op = fail;
-  state_.stencil_front_z_fail_op = zfail;
-  state_.stencil_front_z_pass_op = zpass;
-  state_.stencil_back_fail_op = fail;
-  state_.stencil_back_z_fail_op = zfail;
-  state_.stencil_back_z_pass_op = zpass;
-  glStencilOp(fail, zfail, zpass);
-}
-
-void GLES2DecoderImpl::DoStencilOpSeparate(
-    GLenum face, GLenum fail, GLenum zfail, GLenum zpass) {
-  if (face == GL_FRONT || face == GL_FRONT_AND_BACK) {
-    state_.stencil_front_fail_op = fail;
-    state_.stencil_front_z_fail_op = zfail;
-    state_.stencil_front_z_pass_op = zpass;
-  }
-  if (face == GL_BACK || face == GL_FRONT_AND_BACK) {
-    state_.stencil_back_fail_op = fail;
-    state_.stencil_back_z_fail_op = zfail;
-    state_.stencil_back_z_pass_op = zpass;
-  }
-  glStencilOpSeparate(face, fail, zfail, zpass);
-}
-
-void GLES2DecoderImpl::DoBlendEquation(GLenum mode) {
-  state_.blend_equation_rgb = mode;
-  state_.blend_equation_alpha = mode;
-  glBlendEquation(mode);
-}
-
-void GLES2DecoderImpl::DoBlendFunc(GLenum sfactor, GLenum dfactor) {
-  state_.blend_source_rgb = sfactor;
-  state_.blend_dest_rgb = dfactor;
-  state_.blend_source_alpha = sfactor;
-  state_.blend_dest_alpha = dfactor;
-  glBlendFunc(sfactor, dfactor);
-}
-
 void GLES2DecoderImpl::DoHint(GLenum target, GLenum mode) {
   switch (target) {
     case GL_GENERATE_MIPMAP_HINT:
       state_.hint_generate_mipmap = mode;
       break;
     case GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES:
       state_.hint_fragment_shader_derivative = mode;
       break;
     default:
       NOTREACHED();
@@ skipping 60 matching lines @@
   }
 }
 
 void GLES2DecoderImpl::RestoreClearState() {
   clear_state_dirty_ = true;
   glClearColor(
       state_.color_clear_red, state_.color_clear_green, state_.color_clear_blue,
       state_.color_clear_alpha);
   glClearStencil(state_.stencil_clear);
   glClearDepth(state_.depth_clear);
-  if (state_.enable_scissor_test) {
+  if (state_.enable_flags.scissor_test) {
     glEnable(GL_SCISSOR_TEST);
   }
 }
 
 GLenum GLES2DecoderImpl::DoCheckFramebufferStatus(GLenum target) {
   FramebufferManager::FramebufferInfo* framebuffer =
       GetFramebufferInfoForTarget(target);
   if (!framebuffer) {
     return GL_FRAMEBUFFER_COMPLETE;
   }
@@ skipping 4935 matching lines @@
       GL_RGBA, GL_UNSIGNED_BYTE, false);
 }
 
 // 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