gpu/command_buffer/service/context_state_impl_autogen.h

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 // This file is auto-generated from
   6 // gpu/command_buffer/build_gles2_cmd_buffer.py
   7 // It's formatted by clang-format using chromium coding style:
   8 //    clang-format -i -style=chromium filename
   9 // DO NOT EDIT!
  10
  11 // It is included by context_state.cc
  12 #ifndef GPU_COMMAND_BUFFER_SERVICE_CONTEXT_STATE_IMPL_AUTOGEN_H_
  13 #define GPU_COMMAND_BUFFER_SERVICE_CONTEXT_STATE_IMPL_AUTOGEN_H_
  14
  15 ContextState::EnableFlags::EnableFlags()
  16     : blend(false),
  17       cached_blend(false),
  18       cull_face(false),
  19       cached_cull_face(false),
  20       depth_test(false),
  21       cached_depth_test(false),
  22       dither(true),
  23       cached_dither(true),
  24       polygon_offset_fill(false),
  25       cached_polygon_offset_fill(false),
  26       sample_alpha_to_coverage(false),
  27       cached_sample_alpha_to_coverage(false),
  28       sample_coverage(false),
  29       cached_sample_coverage(false),
  30       scissor_test(false),
  31       cached_scissor_test(false),
  32       stencil_test(false),
  33       cached_stencil_test(false) {
  34 }
  35
  36 void ContextState::Initialize() {
  37   blend_color_red = 0.0f;
  38   blend_color_green = 0.0f;
  39   blend_color_blue = 0.0f;
  40   blend_color_alpha = 0.0f;
  41   blend_equation_rgb = GL_FUNC_ADD;
  42   blend_equation_alpha = GL_FUNC_ADD;
  43   blend_source_rgb = GL_ONE;
  44   blend_dest_rgb = GL_ZERO;
  45   blend_source_alpha = GL_ONE;
  46   blend_dest_alpha = GL_ZERO;
  47   color_clear_red = 0.0f;
  48   color_clear_green = 0.0f;
  49   color_clear_blue = 0.0f;
  50   color_clear_alpha = 0.0f;
  51   depth_clear = 1.0f;
  52   stencil_clear = 0;
  53   color_mask_red = true;
  54   cached_color_mask_red = true;
  55   color_mask_green = true;
  56   cached_color_mask_green = true;
  57   color_mask_blue = true;
  58   cached_color_mask_blue = true;
  59   color_mask_alpha = true;
  60   cached_color_mask_alpha = true;
  61   cull_mode = GL_BACK;
  62   depth_func = GL_LESS;
  63   depth_mask = true;
  64   cached_depth_mask = true;
  65   z_near = 0.0f;
  66   z_far = 1.0f;
  67   front_face = GL_CCW;
  68   hint_generate_mipmap = GL_DONT_CARE;
  69   hint_fragment_shader_derivative = GL_DONT_CARE;
  70   line_width = 1.0f;
  71   modelview_matrix[0] = 1.0f;
  72   modelview_matrix[1] = 0.0f;
  73   modelview_matrix[2] = 0.0f;
  74   modelview_matrix[3] = 0.0f;
  75   modelview_matrix[4] = 0.0f;
  76   modelview_matrix[5] = 1.0f;
  77   modelview_matrix[6] = 0.0f;
  78   modelview_matrix[7] = 0.0f;
  79   modelview_matrix[8] = 0.0f;
  80   modelview_matrix[9] = 0.0f;
  81   modelview_matrix[10] = 1.0f;
  82   modelview_matrix[11] = 0.0f;
  83   modelview_matrix[12] = 0.0f;
  84   modelview_matrix[13] = 0.0f;
  85   modelview_matrix[14] = 0.0f;
  86   modelview_matrix[15] = 1.0f;
  87   projection_matrix[0] = 1.0f;
  88   projection_matrix[1] = 0.0f;
  89   projection_matrix[2] = 0.0f;
  90   projection_matrix[3] = 0.0f;
  91   projection_matrix[4] = 0.0f;
  92   projection_matrix[5] = 1.0f;
  93   projection_matrix[6] = 0.0f;
  94   projection_matrix[7] = 0.0f;
  95   projection_matrix[8] = 0.0f;
  96   projection_matrix[9] = 0.0f;
  97   projection_matrix[10] = 1.0f;
  98   projection_matrix[11] = 0.0f;
  99   projection_matrix[12] = 0.0f;
 100   projection_matrix[13] = 0.0f;
 101   projection_matrix[14] = 0.0f;
 102   projection_matrix[15] = 1.0f;
 103   pack_alignment = 4;
 104   unpack_alignment = 4;
 105   polygon_offset_factor = 0.0f;
 106   polygon_offset_units = 0.0f;
 107   sample_coverage_value = 1.0f;
 108   sample_coverage_invert = false;
 109   scissor_x = 0;
 110   scissor_y = 0;
 111   scissor_width = 1;
 112   scissor_height = 1;
 113   stencil_front_func = GL_ALWAYS;
 114   stencil_front_ref = 0;
 115   stencil_front_mask = 0xFFFFFFFFU;
 116   stencil_back_func = GL_ALWAYS;
 117   stencil_back_ref = 0;
 118   stencil_back_mask = 0xFFFFFFFFU;
 119   stencil_front_writemask = 0xFFFFFFFFU;
 120   cached_stencil_front_writemask = 0xFFFFFFFFU;
 121   stencil_back_writemask = 0xFFFFFFFFU;
 122   cached_stencil_back_writemask = 0xFFFFFFFFU;
 123   stencil_front_fail_op = GL_KEEP;
 124   stencil_front_z_fail_op = GL_KEEP;
 125   stencil_front_z_pass_op = GL_KEEP;
 126   stencil_back_fail_op = GL_KEEP;
 127   stencil_back_z_fail_op = GL_KEEP;
 128   stencil_back_z_pass_op = GL_KEEP;
 129   viewport_x = 0;
 130   viewport_y = 0;
 131   viewport_width = 1;
 132   viewport_height = 1;
 133 }
 134
 135 void ContextState::InitCapabilities(const ContextState* prev_state) const {
 136   if (prev_state) {
 137     if (prev_state->enable_flags.cached_blend != enable_flags.cached_blend)
 138       EnableDisable(GL_BLEND, enable_flags.cached_blend);
 139     if (prev_state->enable_flags.cached_cull_face !=
 140         enable_flags.cached_cull_face)
 141       EnableDisable(GL_CULL_FACE, enable_flags.cached_cull_face);
 142     if (prev_state->enable_flags.cached_depth_test !=
 143         enable_flags.cached_depth_test)
 144       EnableDisable(GL_DEPTH_TEST, enable_flags.cached_depth_test);
 145     if (prev_state->enable_flags.cached_dither != enable_flags.cached_dither)
 146       EnableDisable(GL_DITHER, enable_flags.cached_dither);
 147     if (prev_state->enable_flags.cached_polygon_offset_fill !=
 148         enable_flags.cached_polygon_offset_fill)
 149       EnableDisable(GL_POLYGON_OFFSET_FILL,
 150                     enable_flags.cached_polygon_offset_fill);
 151     if (prev_state->enable_flags.cached_sample_alpha_to_coverage !=
 152         enable_flags.cached_sample_alpha_to_coverage)
 153       EnableDisable(GL_SAMPLE_ALPHA_TO_COVERAGE,
 154                     enable_flags.cached_sample_alpha_to_coverage);
 155     if (prev_state->enable_flags.cached_sample_coverage !=
 156         enable_flags.cached_sample_coverage)
 157       EnableDisable(GL_SAMPLE_COVERAGE, enable_flags.cached_sample_coverage);
 158     if (prev_state->enable_flags.cached_scissor_test !=
 159         enable_flags.cached_scissor_test)
 160       EnableDisable(GL_SCISSOR_TEST, enable_flags.cached_scissor_test);
 161     if (prev_state->enable_flags.cached_stencil_test !=
 162         enable_flags.cached_stencil_test)
 163       EnableDisable(GL_STENCIL_TEST, enable_flags.cached_stencil_test);
 164   } else {
 165     EnableDisable(GL_BLEND, enable_flags.cached_blend);
 166     EnableDisable(GL_CULL_FACE, enable_flags.cached_cull_face);
 167     EnableDisable(GL_DEPTH_TEST, enable_flags.cached_depth_test);
 168     EnableDisable(GL_DITHER, enable_flags.cached_dither);
 169     EnableDisable(GL_POLYGON_OFFSET_FILL,
 170                   enable_flags.cached_polygon_offset_fill);
 171     EnableDisable(GL_SAMPLE_ALPHA_TO_COVERAGE,
 172                   enable_flags.cached_sample_alpha_to_coverage);
 173     EnableDisable(GL_SAMPLE_COVERAGE, enable_flags.cached_sample_coverage);
 174     EnableDisable(GL_SCISSOR_TEST, enable_flags.cached_scissor_test);
 175     EnableDisable(GL_STENCIL_TEST, enable_flags.cached_stencil_test);
 176   }
 177 }
 178
 179 void ContextState::InitState(const ContextState* prev_state) const {
 180   if (prev_state) {
 181     if ((blend_color_red != prev_state->blend_color_red) ||
 182         (blend_color_green != prev_state->blend_color_green) ||
 183         (blend_color_blue != prev_state->blend_color_blue) ||
 184         (blend_color_alpha != prev_state->blend_color_alpha))
 185       glBlendColor(blend_color_red,
 186                    blend_color_green,
 187                    blend_color_blue,
 188                    blend_color_alpha);
 189     if ((blend_equation_rgb != prev_state->blend_equation_rgb) ||
 190         (blend_equation_alpha != prev_state->blend_equation_alpha))
 191       glBlendEquationSeparate(blend_equation_rgb, blend_equation_alpha);
 192     if ((blend_source_rgb != prev_state->blend_source_rgb) ||
 193         (blend_dest_rgb != prev_state->blend_dest_rgb) ||
 194         (blend_source_alpha != prev_state->blend_source_alpha) ||
 195         (blend_dest_alpha != prev_state->blend_dest_alpha))
 196       glBlendFuncSeparate(blend_source_rgb,
 197                           blend_dest_rgb,
 198                           blend_source_alpha,
 199                           blend_dest_alpha);
 200     if ((color_clear_red != prev_state->color_clear_red) ||
 201         (color_clear_green != prev_state->color_clear_green) ||
 202         (color_clear_blue != prev_state->color_clear_blue) ||
 203         (color_clear_alpha != prev_state->color_clear_alpha))
 204       glClearColor(color_clear_red,
 205                    color_clear_green,
 206                    color_clear_blue,
 207                    color_clear_alpha);
 208     if ((depth_clear != prev_state->depth_clear))
 209       glClearDepth(depth_clear);
 210     if ((stencil_clear != prev_state->stencil_clear))
 211       glClearStencil(stencil_clear);
 212     if ((cached_color_mask_red != prev_state->cached_color_mask_red) ||
 213         (cached_color_mask_green != prev_state->cached_color_mask_green) ||
 214         (cached_color_mask_blue != prev_state->cached_color_mask_blue) ||
 215         (cached_color_mask_alpha != prev_state->cached_color_mask_alpha))
 216       glColorMask(cached_color_mask_red,
 217                   cached_color_mask_green,
 218                   cached_color_mask_blue,
 219                   cached_color_mask_alpha);
 220     if ((cull_mode != prev_state->cull_mode))
 221       glCullFace(cull_mode);
 222     if ((depth_func != prev_state->depth_func))
 223       glDepthFunc(depth_func);
 224     if ((cached_depth_mask != prev_state->cached_depth_mask))
 225       glDepthMask(cached_depth_mask);
 226     if ((z_near != prev_state->z_near) || (z_far != prev_state->z_far))
 227       glDepthRange(z_near, z_far);
 228     if ((front_face != prev_state->front_face))
 229       glFrontFace(front_face);
 230     if (prev_state->hint_generate_mipmap != hint_generate_mipmap) {
 231       glHint(GL_GENERATE_MIPMAP_HINT, hint_generate_mipmap);
 232     }
 233     if (feature_info_->feature_flags().oes_standard_derivatives) {
 234       if (prev_state->hint_fragment_shader_derivative !=
 235           hint_fragment_shader_derivative) {
 236         glHint(GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES,
 237                hint_fragment_shader_derivative);
 238       }
 239     }
 240     if ((line_width != prev_state->line_width))
 241       glLineWidth(line_width);
 242     if (feature_info_->feature_flags().chromium_path_rendering) {
 243       if (memcmp(prev_state->modelview_matrix,
 244                  modelview_matrix,
 245                  sizeof(GLfloat) * 16)) {
 246         glMatrixLoadfEXT(GL_PATH_MODELVIEW_CHROMIUM, modelview_matrix);
 247       }
 248     }
 249     if (feature_info_->feature_flags().chromium_path_rendering) {
 250       if (memcmp(prev_state->projection_matrix,
 251                  projection_matrix,
 252                  sizeof(GLfloat) * 16)) {
 253         glMatrixLoadfEXT(GL_PATH_PROJECTION_CHROMIUM, projection_matrix);
 254       }
 255     }
 256     if (prev_state->pack_alignment != pack_alignment) {
 257       glPixelStorei(GL_PACK_ALIGNMENT, pack_alignment);
 258     }
 259     if (prev_state->unpack_alignment != unpack_alignment) {
 260       glPixelStorei(GL_UNPACK_ALIGNMENT, unpack_alignment);
 261     }
 262     if ((polygon_offset_factor != prev_state->polygon_offset_factor) ||
 263         (polygon_offset_units != prev_state->polygon_offset_units))
 264       glPolygonOffset(polygon_offset_factor, polygon_offset_units);
 265     if ((sample_coverage_value != prev_state->sample_coverage_value) ||
 266         (sample_coverage_invert != prev_state->sample_coverage_invert))
 267       glSampleCoverage(sample_coverage_value, sample_coverage_invert);
 268     if ((scissor_x != prev_state->scissor_x) ||
 269         (scissor_y != prev_state->scissor_y) ||
 270         (scissor_width != prev_state->scissor_width) ||
 271         (scissor_height != prev_state->scissor_height))
 272       glScissor(scissor_x, scissor_y, scissor_width, scissor_height);
 273     if ((stencil_front_func != prev_state->stencil_front_func) ||
 274         (stencil_front_ref != prev_state->stencil_front_ref) ||
 275         (stencil_front_mask != prev_state->stencil_front_mask))
 276       glStencilFuncSeparate(
 277           GL_FRONT, stencil_front_func, stencil_front_ref, stencil_front_mask);
 278     if ((stencil_back_func != prev_state->stencil_back_func) ||
 279         (stencil_back_ref != prev_state->stencil_back_ref) ||
 280         (stencil_back_mask != prev_state->stencil_back_mask))
 281       glStencilFuncSeparate(
 282           GL_BACK, stencil_back_func, stencil_back_ref, stencil_back_mask);
 283     if ((cached_stencil_front_writemask !=
 284          prev_state->cached_stencil_front_writemask))
 285       glStencilMaskSeparate(GL_FRONT, cached_stencil_front_writemask);
 286     if ((cached_stencil_back_writemask !=
 287          prev_state->cached_stencil_back_writemask))
 288       glStencilMaskSeparate(GL_BACK, cached_stencil_back_writemask);
 289     if ((stencil_front_fail_op != prev_state->stencil_front_fail_op) ||
 290         (stencil_front_z_fail_op != prev_state->stencil_front_z_fail_op) ||
 291         (stencil_front_z_pass_op != prev_state->stencil_front_z_pass_op))
 292       glStencilOpSeparate(GL_FRONT,
 293                           stencil_front_fail_op,
 294                           stencil_front_z_fail_op,
 295                           stencil_front_z_pass_op);
 296     if ((stencil_back_fail_op != prev_state->stencil_back_fail_op) ||
 297         (stencil_back_z_fail_op != prev_state->stencil_back_z_fail_op) ||
 298         (stencil_back_z_pass_op != prev_state->stencil_back_z_pass_op))
 299       glStencilOpSeparate(GL_BACK,
 300                           stencil_back_fail_op,
 301                           stencil_back_z_fail_op,
 302                           stencil_back_z_pass_op);
 303     if ((viewport_x != prev_state->viewport_x) ||
 304         (viewport_y != prev_state->viewport_y) ||
 305         (viewport_width != prev_state->viewport_width) ||
 306         (viewport_height != prev_state->viewport_height))
 307       glViewport(viewport_x, viewport_y, viewport_width, viewport_height);
 308   } else {
 309     glBlendColor(blend_color_red,
 310                  blend_color_green,
 311                  blend_color_blue,
 312                  blend_color_alpha);
 313     glBlendEquationSeparate(blend_equation_rgb, blend_equation_alpha);
 314     glBlendFuncSeparate(
 315         blend_source_rgb, blend_dest_rgb, blend_source_alpha, blend_dest_alpha);
 316     glClearColor(color_clear_red,
 317                  color_clear_green,
 318                  color_clear_blue,
 319                  color_clear_alpha);
 320     glClearDepth(depth_clear);
 321     glClearStencil(stencil_clear);
 322     glColorMask(cached_color_mask_red,
 323                 cached_color_mask_green,
 324                 cached_color_mask_blue,
 325                 cached_color_mask_alpha);
 326     glCullFace(cull_mode);
 327     glDepthFunc(depth_func);
 328     glDepthMask(cached_depth_mask);
 329     glDepthRange(z_near, z_far);
 330     glFrontFace(front_face);
 331     glHint(GL_GENERATE_MIPMAP_HINT, hint_generate_mipmap);
 332     if (feature_info_->feature_flags().oes_standard_derivatives) {
 333       glHint(GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES,
 334              hint_fragment_shader_derivative);
 335     }
 336     glLineWidth(line_width);
 337     if (feature_info_->feature_flags().chromium_path_rendering) {
 338       glMatrixLoadfEXT(GL_PATH_MODELVIEW_CHROMIUM, modelview_matrix);
 339     }
 340     if (feature_info_->feature_flags().chromium_path_rendering) {
 341       glMatrixLoadfEXT(GL_PATH_PROJECTION_CHROMIUM, projection_matrix);
 342     }
 343     glPixelStorei(GL_PACK_ALIGNMENT, pack_alignment);
 344     glPixelStorei(GL_UNPACK_ALIGNMENT, unpack_alignment);
 345     glPolygonOffset(polygon_offset_factor, polygon_offset_units);
 346     glSampleCoverage(sample_coverage_value, sample_coverage_invert);
 347     glScissor(scissor_x, scissor_y, scissor_width, scissor_height);
 348     glStencilFuncSeparate(
 349         GL_FRONT, stencil_front_func, stencil_front_ref, stencil_front_mask);
 350     glStencilFuncSeparate(
 351         GL_BACK, stencil_back_func, stencil_back_ref, stencil_back_mask);
 352     glStencilMaskSeparate(GL_FRONT, cached_stencil_front_writemask);
 353     glStencilMaskSeparate(GL_BACK, cached_stencil_back_writemask);
 354     glStencilOpSeparate(GL_FRONT,
 355                         stencil_front_fail_op,
 356                         stencil_front_z_fail_op,
 357                         stencil_front_z_pass_op);
 358     glStencilOpSeparate(GL_BACK,
 359                         stencil_back_fail_op,
 360                         stencil_back_z_fail_op,
 361                         stencil_back_z_pass_op);
 362     glViewport(viewport_x, viewport_y, viewport_width, viewport_height);
 363   }
 364 }
 365 bool ContextState::GetEnabled(GLenum cap) const {
 366   switch (cap) {
 367     case GL_BLEND:
 368       return enable_flags.blend;
 369     case GL_CULL_FACE:
 370       return enable_flags.cull_face;
 371     case GL_DEPTH_TEST:
 372       return enable_flags.depth_test;
 373     case GL_DITHER:
 374       return enable_flags.dither;
 375     case GL_POLYGON_OFFSET_FILL:
 376       return enable_flags.polygon_offset_fill;
 377     case GL_SAMPLE_ALPHA_TO_COVERAGE:
 378       return enable_flags.sample_alpha_to_coverage;
 379     case GL_SAMPLE_COVERAGE:
 380       return enable_flags.sample_coverage;
 381     case GL_SCISSOR_TEST:
 382       return enable_flags.scissor_test;
 383     case GL_STENCIL_TEST:
 384       return enable_flags.stencil_test;
 385     default:
 386       NOTREACHED();
 387       return false;
 388   }
 389 }
 390
 391 bool ContextState::GetStateAsGLint(GLenum pname,
 392                                    GLint* params,
 393                                    GLsizei* num_written) const {
 394   switch (pname) {
 395     case GL_BLEND_COLOR:
 396       *num_written = 4;
 397       if (params) {
 398         params[0] = static_cast<GLint>(blend_color_red);
 399         params[1] = static_cast<GLint>(blend_color_green);
 400         params[2] = static_cast<GLint>(blend_color_blue);
 401         params[3] = static_cast<GLint>(blend_color_alpha);
 402       }
 403       return true;
 404     case GL_BLEND_EQUATION_RGB:
 405       *num_written = 1;
 406       if (params) {
 407         params[0] = static_cast<GLint>(blend_equation_rgb);
 408       }
 409       return true;
 410     case GL_BLEND_EQUATION_ALPHA:
 411       *num_written = 1;
 412       if (params) {
 413         params[0] = static_cast<GLint>(blend_equation_alpha);
 414       }
 415       return true;
 416     case GL_BLEND_SRC_RGB:
 417       *num_written = 1;
 418       if (params) {
 419         params[0] = static_cast<GLint>(blend_source_rgb);
 420       }
 421       return true;
 422     case GL_BLEND_DST_RGB:
 423       *num_written = 1;
 424       if (params) {
 425         params[0] = static_cast<GLint>(blend_dest_rgb);
 426       }
 427       return true;
 428     case GL_BLEND_SRC_ALPHA:
 429       *num_written = 1;
 430       if (params) {
 431         params[0] = static_cast<GLint>(blend_source_alpha);
 432       }
 433       return true;
 434     case GL_BLEND_DST_ALPHA:
 435       *num_written = 1;
 436       if (params) {
 437         params[0] = static_cast<GLint>(blend_dest_alpha);
 438       }
 439       return true;
 440     case GL_COLOR_CLEAR_VALUE:
 441       *num_written = 4;
 442       if (params) {
 443         params[0] = static_cast<GLint>(color_clear_red);
 444         params[1] = static_cast<GLint>(color_clear_green);
 445         params[2] = static_cast<GLint>(color_clear_blue);
 446         params[3] = static_cast<GLint>(color_clear_alpha);
 447       }
 448       return true;
 449     case GL_DEPTH_CLEAR_VALUE:
 450       *num_written = 1;
 451       if (params) {
 452         params[0] = static_cast<GLint>(depth_clear);
 453       }
 454       return true;
 455     case GL_STENCIL_CLEAR_VALUE:
 456       *num_written = 1;
 457       if (params) {
 458         params[0] = static_cast<GLint>(stencil_clear);
 459       }
 460       return true;
 461     case GL_COLOR_WRITEMASK:
 462       *num_written = 4;
 463       if (params) {
 464         params[0] = static_cast<GLint>(color_mask_red);
 465         params[1] = static_cast<GLint>(color_mask_green);
 466         params[2] = static_cast<GLint>(color_mask_blue);
 467         params[3] = static_cast<GLint>(color_mask_alpha);
 468       }
 469       return true;
 470     case GL_CULL_FACE_MODE:
 471       *num_written = 1;
 472       if (params) {
 473         params[0] = static_cast<GLint>(cull_mode);
 474       }
 475       return true;
 476     case GL_DEPTH_FUNC:
 477       *num_written = 1;
 478       if (params) {
 479         params[0] = static_cast<GLint>(depth_func);
 480       }
 481       return true;
 482     case GL_DEPTH_WRITEMASK:
 483       *num_written = 1;
 484       if (params) {
 485         params[0] = static_cast<GLint>(depth_mask);
 486       }
 487       return true;
 488     case GL_DEPTH_RANGE:
 489       *num_written = 2;
 490       if (params) {
 491         params[0] = static_cast<GLint>(z_near);
 492         params[1] = static_cast<GLint>(z_far);
 493       }
 494       return true;
 495     case GL_FRONT_FACE:
 496       *num_written = 1;
 497       if (params) {
 498         params[0] = static_cast<GLint>(front_face);
 499       }
 500       return true;
 501     case GL_GENERATE_MIPMAP_HINT:
 502       *num_written = 1;
 503       if (params) {
 504         params[0] = static_cast<GLint>(hint_generate_mipmap);
 505       }
 506       return true;
 507     case GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES:
 508       *num_written = 1;
 509       if (params) {
 510         params[0] = static_cast<GLint>(hint_fragment_shader_derivative);
 511       }
 512       return true;
 513     case GL_LINE_WIDTH:
 514       *num_written = 1;
 515       if (params) {
 516         params[0] = static_cast<GLint>(line_width);
 517       }
 518       return true;
 519     case GL_PATH_MODELVIEW_MATRIX_CHROMIUM:
 520       *num_written = 16;
 521       if (params) {
 522         for (size_t i = 0; i < 16; ++i) {
 523           params[i] = static_cast<GLint>(round(modelview_matrix[i]));
 524         }
 525       }
 526       return true;
 527     case GL_PATH_PROJECTION_MATRIX_CHROMIUM:
 528       *num_written = 16;
 529       if (params) {
 530         for (size_t i = 0; i < 16; ++i) {
 531           params[i] = static_cast<GLint>(round(projection_matrix[i]));
 532         }
 533       }
 534       return true;
 535     case GL_PACK_ALIGNMENT:
 536       *num_written = 1;
 537       if (params) {
 538         params[0] = static_cast<GLint>(pack_alignment);
 539       }
 540       return true;
 541     case GL_UNPACK_ALIGNMENT:
 542       *num_written = 1;
 543       if (params) {
 544         params[0] = static_cast<GLint>(unpack_alignment);
 545       }
 546       return true;
 547     case GL_POLYGON_OFFSET_FACTOR:
 548       *num_written = 1;
 549       if (params) {
 550         params[0] = static_cast<GLint>(round(polygon_offset_factor));
 551       }
 552       return true;
 553     case GL_POLYGON_OFFSET_UNITS:
 554       *num_written = 1;
 555       if (params) {
 556         params[0] = static_cast<GLint>(round(polygon_offset_units));
 557       }
 558       return true;
 559     case GL_SAMPLE_COVERAGE_VALUE:
 560       *num_written = 1;
 561       if (params) {
 562         params[0] = static_cast<GLint>(sample_coverage_value);
 563       }
 564       return true;
 565     case GL_SAMPLE_COVERAGE_INVERT:
 566       *num_written = 1;
 567       if (params) {
 568         params[0] = static_cast<GLint>(sample_coverage_invert);
 569       }
 570       return true;
 571     case GL_SCISSOR_BOX:
 572       *num_written = 4;
 573       if (params) {
 574         params[0] = static_cast<GLint>(scissor_x);
 575         params[1] = static_cast<GLint>(scissor_y);
 576         params[2] = static_cast<GLint>(scissor_width);
 577         params[3] = static_cast<GLint>(scissor_height);
 578       }
 579       return true;
 580     case GL_STENCIL_FUNC:
 581       *num_written = 1;
 582       if (params) {
 583         params[0] = static_cast<GLint>(stencil_front_func);
 584       }
 585       return true;
 586     case GL_STENCIL_REF:
 587       *num_written = 1;
 588       if (params) {
 589         params[0] = static_cast<GLint>(stencil_front_ref);
 590       }
 591       return true;
 592     case GL_STENCIL_VALUE_MASK:
 593       *num_written = 1;
 594       if (params) {
 595         params[0] = static_cast<GLint>(stencil_front_mask);
 596       }
 597       return true;
 598     case GL_STENCIL_BACK_FUNC:
 599       *num_written = 1;
 600       if (params) {
 601         params[0] = static_cast<GLint>(stencil_back_func);
 602       }
 603       return true;
 604     case GL_STENCIL_BACK_REF:
 605       *num_written = 1;
 606       if (params) {
 607         params[0] = static_cast<GLint>(stencil_back_ref);
 608       }
 609       return true;
 610     case GL_STENCIL_BACK_VALUE_MASK:
 611       *num_written = 1;
 612       if (params) {
 613         params[0] = static_cast<GLint>(stencil_back_mask);
 614       }
 615       return true;
 616     case GL_STENCIL_WRITEMASK:
 617       *num_written = 1;
 618       if (params) {
 619         params[0] = static_cast<GLint>(stencil_front_writemask);
 620       }
 621       return true;
 622     case GL_STENCIL_BACK_WRITEMASK:
 623       *num_written = 1;
 624       if (params) {
 625         params[0] = static_cast<GLint>(stencil_back_writemask);
 626       }
 627       return true;
 628     case GL_STENCIL_FAIL:
 629       *num_written = 1;
 630       if (params) {
 631         params[0] = static_cast<GLint>(stencil_front_fail_op);
 632       }
 633       return true;
 634     case GL_STENCIL_PASS_DEPTH_FAIL:
 635       *num_written = 1;
 636       if (params) {
 637         params[0] = static_cast<GLint>(stencil_front_z_fail_op);
 638       }
 639       return true;
 640     case GL_STENCIL_PASS_DEPTH_PASS:
 641       *num_written = 1;
 642       if (params) {
 643         params[0] = static_cast<GLint>(stencil_front_z_pass_op);
 644       }
 645       return true;
 646     case GL_STENCIL_BACK_FAIL:
 647       *num_written = 1;
 648       if (params) {
 649         params[0] = static_cast<GLint>(stencil_back_fail_op);
 650       }
 651       return true;
 652     case GL_STENCIL_BACK_PASS_DEPTH_FAIL:
 653       *num_written = 1;
 654       if (params) {
 655         params[0] = static_cast<GLint>(stencil_back_z_fail_op);
 656       }
 657       return true;
 658     case GL_STENCIL_BACK_PASS_DEPTH_PASS:
 659       *num_written = 1;
 660       if (params) {
 661         params[0] = static_cast<GLint>(stencil_back_z_pass_op);
 662       }
 663       return true;
 664     case GL_VIEWPORT:
 665       *num_written = 4;
 666       if (params) {
 667         params[0] = static_cast<GLint>(viewport_x);
 668         params[1] = static_cast<GLint>(viewport_y);
 669         params[2] = static_cast<GLint>(viewport_width);
 670         params[3] = static_cast<GLint>(viewport_height);
 671       }
 672       return true;
 673     case GL_BLEND:
 674       *num_written = 1;
 675       if (params) {
 676         params[0] = static_cast<GLint>(enable_flags.blend);
 677       }
 678       return true;
 679     case GL_CULL_FACE:
 680       *num_written = 1;
 681       if (params) {
 682         params[0] = static_cast<GLint>(enable_flags.cull_face);
 683       }
 684       return true;
 685     case GL_DEPTH_TEST:
 686       *num_written = 1;
 687       if (params) {
 688         params[0] = static_cast<GLint>(enable_flags.depth_test);
 689       }
 690       return true;
 691     case GL_DITHER:
 692       *num_written = 1;
 693       if (params) {
 694         params[0] = static_cast<GLint>(enable_flags.dither);
 695       }
 696       return true;
 697     case GL_POLYGON_OFFSET_FILL:
 698       *num_written = 1;
 699       if (params) {
 700         params[0] = static_cast<GLint>(enable_flags.polygon_offset_fill);
 701       }
 702       return true;
 703     case GL_SAMPLE_ALPHA_TO_COVERAGE:
 704       *num_written = 1;
 705       if (params) {
 706         params[0] = static_cast<GLint>(enable_flags.sample_alpha_to_coverage);
 707       }
 708       return true;
 709     case GL_SAMPLE_COVERAGE:
 710       *num_written = 1;
 711       if (params) {
 712         params[0] = static_cast<GLint>(enable_flags.sample_coverage);
 713       }
 714       return true;
 715     case GL_SCISSOR_TEST:
 716       *num_written = 1;
 717       if (params) {
 718         params[0] = static_cast<GLint>(enable_flags.scissor_test);
 719       }
 720       return true;
 721     case GL_STENCIL_TEST:
 722       *num_written = 1;
 723       if (params) {
 724         params[0] = static_cast<GLint>(enable_flags.stencil_test);
 725       }
 726       return true;
 727     default:
 728       return false;
 729   }
 730 }
 731
 732 bool ContextState::GetStateAsGLfloat(GLenum pname,
 733                                      GLfloat* params,
 734                                      GLsizei* num_written) const {
 735   switch (pname) {
 736     case GL_BLEND_COLOR:
 737       *num_written = 4;
 738       if (params) {
 739         params[0] = static_cast<GLfloat>(blend_color_red);
 740         params[1] = static_cast<GLfloat>(blend_color_green);
 741         params[2] = static_cast<GLfloat>(blend_color_blue);
 742         params[3] = static_cast<GLfloat>(blend_color_alpha);
 743       }
 744       return true;
 745     case GL_BLEND_EQUATION_RGB:
 746       *num_written = 1;
 747       if (params) {
 748         params[0] = static_cast<GLfloat>(blend_equation_rgb);
 749       }
 750       return true;
 751     case GL_BLEND_EQUATION_ALPHA:
 752       *num_written = 1;
 753       if (params) {
 754         params[0] = static_cast<GLfloat>(blend_equation_alpha);
 755       }
 756       return true;
 757     case GL_BLEND_SRC_RGB:
 758       *num_written = 1;
 759       if (params) {
 760         params[0] = static_cast<GLfloat>(blend_source_rgb);
 761       }
 762       return true;
 763     case GL_BLEND_DST_RGB:
 764       *num_written = 1;
 765       if (params) {
 766         params[0] = static_cast<GLfloat>(blend_dest_rgb);
 767       }
 768       return true;
 769     case GL_BLEND_SRC_ALPHA:
 770       *num_written = 1;
 771       if (params) {
 772         params[0] = static_cast<GLfloat>(blend_source_alpha);
 773       }
 774       return true;
 775     case GL_BLEND_DST_ALPHA:
 776       *num_written = 1;
 777       if (params) {
 778         params[0] = static_cast<GLfloat>(blend_dest_alpha);
 779       }
 780       return true;
 781     case GL_COLOR_CLEAR_VALUE:
 782       *num_written = 4;
 783       if (params) {
 784         params[0] = static_cast<GLfloat>(color_clear_red);
 785         params[1] = static_cast<GLfloat>(color_clear_green);
 786         params[2] = static_cast<GLfloat>(color_clear_blue);
 787         params[3] = static_cast<GLfloat>(color_clear_alpha);
 788       }
 789       return true;
 790     case GL_DEPTH_CLEAR_VALUE:
 791       *num_written = 1;
 792       if (params) {
 793         params[0] = static_cast<GLfloat>(depth_clear);
 794       }
 795       return true;
 796     case GL_STENCIL_CLEAR_VALUE:
 797       *num_written = 1;
 798       if (params) {
 799         params[0] = static_cast<GLfloat>(stencil_clear);
 800       }
 801       return true;
 802     case GL_COLOR_WRITEMASK:
 803       *num_written = 4;
 804       if (params) {
 805         params[0] = static_cast<GLfloat>(color_mask_red);
 806         params[1] = static_cast<GLfloat>(color_mask_green);
 807         params[2] = static_cast<GLfloat>(color_mask_blue);
 808         params[3] = static_cast<GLfloat>(color_mask_alpha);
 809       }
 810       return true;
 811     case GL_CULL_FACE_MODE:
 812       *num_written = 1;
 813       if (params) {
 814         params[0] = static_cast<GLfloat>(cull_mode);
 815       }
 816       return true;
 817     case GL_DEPTH_FUNC:
 818       *num_written = 1;
 819       if (params) {
 820         params[0] = static_cast<GLfloat>(depth_func);
 821       }
 822       return true;
 823     case GL_DEPTH_WRITEMASK:
 824       *num_written = 1;
 825       if (params) {
 826         params[0] = static_cast<GLfloat>(depth_mask);
 827       }
 828       return true;
 829     case GL_DEPTH_RANGE:
 830       *num_written = 2;
 831       if (params) {
 832         params[0] = static_cast<GLfloat>(z_near);
 833         params[1] = static_cast<GLfloat>(z_far);
 834       }
 835       return true;
 836     case GL_FRONT_FACE:
 837       *num_written = 1;
 838       if (params) {
 839         params[0] = static_cast<GLfloat>(front_face);
 840       }
 841       return true;
 842     case GL_GENERATE_MIPMAP_HINT:
 843       *num_written = 1;
 844       if (params) {
 845         params[0] = static_cast<GLfloat>(hint_generate_mipmap);
 846       }
 847       return true;
 848     case GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES:
 849       *num_written = 1;
 850       if (params) {
 851         params[0] = static_cast<GLfloat>(hint_fragment_shader_derivative);
 852       }
 853       return true;
 854     case GL_LINE_WIDTH:
 855       *num_written = 1;
 856       if (params) {
 857         params[0] = static_cast<GLfloat>(line_width);
 858       }
 859       return true;
 860     case GL_PATH_MODELVIEW_MATRIX_CHROMIUM:
 861       *num_written = 16;
 862       if (params) {
 863         memcpy(params, modelview_matrix, sizeof(GLfloat) * 16);
 864       }
 865       return true;
 866     case GL_PATH_PROJECTION_MATRIX_CHROMIUM:
 867       *num_written = 16;
 868       if (params) {
 869         memcpy(params, projection_matrix, sizeof(GLfloat) * 16);
 870       }
 871       return true;
 872     case GL_PACK_ALIGNMENT:
 873       *num_written = 1;
 874       if (params) {
 875         params[0] = static_cast<GLfloat>(pack_alignment);
 876       }
 877       return true;
 878     case GL_UNPACK_ALIGNMENT:
 879       *num_written = 1;
 880       if (params) {
 881         params[0] = static_cast<GLfloat>(unpack_alignment);
 882       }
 883       return true;
 884     case GL_POLYGON_OFFSET_FACTOR:
 885       *num_written = 1;
 886       if (params) {
 887         params[0] = static_cast<GLfloat>(polygon_offset_factor);
 888       }
 889       return true;
 890     case GL_POLYGON_OFFSET_UNITS:
 891       *num_written = 1;
 892       if (params) {
 893         params[0] = static_cast<GLfloat>(polygon_offset_units);
 894       }
 895       return true;
 896     case GL_SAMPLE_COVERAGE_VALUE:
 897       *num_written = 1;
 898       if (params) {
 899         params[0] = static_cast<GLfloat>(sample_coverage_value);
 900       }
 901       return true;
 902     case GL_SAMPLE_COVERAGE_INVERT:
 903       *num_written = 1;
 904       if (params) {
 905         params[0] = static_cast<GLfloat>(sample_coverage_invert);
 906       }
 907       return true;
 908     case GL_SCISSOR_BOX:
 909       *num_written = 4;
 910       if (params) {
 911         params[0] = static_cast<GLfloat>(scissor_x);
 912         params[1] = static_cast<GLfloat>(scissor_y);
 913         params[2] = static_cast<GLfloat>(scissor_width);
 914         params[3] = static_cast<GLfloat>(scissor_height);
 915       }
 916       return true;
 917     case GL_STENCIL_FUNC:
 918       *num_written = 1;
 919       if (params) {
 920         params[0] = static_cast<GLfloat>(stencil_front_func);
 921       }
 922       return true;
 923     case GL_STENCIL_REF:
 924       *num_written = 1;
 925       if (params) {
 926         params[0] = static_cast<GLfloat>(stencil_front_ref);
 927       }
 928       return true;
 929     case GL_STENCIL_VALUE_MASK:
 930       *num_written = 1;
 931       if (params) {
 932         params[0] = static_cast<GLfloat>(stencil_front_mask);
 933       }
 934       return true;
 935     case GL_STENCIL_BACK_FUNC:
 936       *num_written = 1;
 937       if (params) {
 938         params[0] = static_cast<GLfloat>(stencil_back_func);
 939       }
 940       return true;
 941     case GL_STENCIL_BACK_REF:
 942       *num_written = 1;
 943       if (params) {
 944         params[0] = static_cast<GLfloat>(stencil_back_ref);
 945       }
 946       return true;
 947     case GL_STENCIL_BACK_VALUE_MASK:
 948       *num_written = 1;
 949       if (params) {
 950         params[0] = static_cast<GLfloat>(stencil_back_mask);
 951       }
 952       return true;
 953     case GL_STENCIL_WRITEMASK:
 954       *num_written = 1;
 955       if (params) {
 956         params[0] = static_cast<GLfloat>(stencil_front_writemask);
 957       }
 958       return true;
 959     case GL_STENCIL_BACK_WRITEMASK:
 960       *num_written = 1;
 961       if (params) {
 962         params[0] = static_cast<GLfloat>(stencil_back_writemask);
 963       }
 964       return true;
 965     case GL_STENCIL_FAIL:
 966       *num_written = 1;
 967       if (params) {
 968         params[0] = static_cast<GLfloat>(stencil_front_fail_op);
 969       }
 970       return true;
 971     case GL_STENCIL_PASS_DEPTH_FAIL:
 972       *num_written = 1;
 973       if (params) {
 974         params[0] = static_cast<GLfloat>(stencil_front_z_fail_op);
 975       }
 976       return true;
 977     case GL_STENCIL_PASS_DEPTH_PASS:
 978       *num_written = 1;
 979       if (params) {
 980         params[0] = static_cast<GLfloat>(stencil_front_z_pass_op);
 981       }
 982       return true;
 983     case GL_STENCIL_BACK_FAIL:
 984       *num_written = 1;
 985       if (params) {
 986         params[0] = static_cast<GLfloat>(stencil_back_fail_op);
 987       }
 988       return true;
 989     case GL_STENCIL_BACK_PASS_DEPTH_FAIL:
 990       *num_written = 1;
 991       if (params) {
 992         params[0] = static_cast<GLfloat>(stencil_back_z_fail_op);
 993       }
 994       return true;
 995     case GL_STENCIL_BACK_PASS_DEPTH_PASS:
 996       *num_written = 1;
 997       if (params) {
 998         params[0] = static_cast<GLfloat>(stencil_back_z_pass_op);
 999       }
1000       return true;
1001     case GL_VIEWPORT:
1002       *num_written = 4;
1003       if (params) {
1004         params[0] = static_cast<GLfloat>(viewport_x);
1005         params[1] = static_cast<GLfloat>(viewport_y);
1006         params[2] = static_cast<GLfloat>(viewport_width);
1007         params[3] = static_cast<GLfloat>(viewport_height);
1008       }
1009       return true;
1010     case GL_BLEND:
1011       *num_written = 1;
1012       if (params) {
1013         params[0] = static_cast<GLfloat>(enable_flags.blend);
1014       }
1015       return true;
1016     case GL_CULL_FACE:
1017       *num_written = 1;
1018       if (params) {
1019         params[0] = static_cast<GLfloat>(enable_flags.cull_face);
1020       }
1021       return true;
1022     case GL_DEPTH_TEST:
1023       *num_written = 1;
1024       if (params) {
1025         params[0] = static_cast<GLfloat>(enable_flags.depth_test);
1026       }
1027       return true;
1028     case GL_DITHER:
1029       *num_written = 1;
1030       if (params) {
1031         params[0] = static_cast<GLfloat>(enable_flags.dither);
1032       }
1033       return true;
1034     case GL_POLYGON_OFFSET_FILL:
1035       *num_written = 1;
1036       if (params) {
1037         params[0] = static_cast<GLfloat>(enable_flags.polygon_offset_fill);
1038       }
1039       return true;
1040     case GL_SAMPLE_ALPHA_TO_COVERAGE:
1041       *num_written = 1;
1042       if (params) {
1043         params[0] = static_cast<GLfloat>(enable_flags.sample_alpha_to_coverage);
1044       }
1045       return true;
1046     case GL_SAMPLE_COVERAGE:
1047       *num_written = 1;
1048       if (params) {
1049         params[0] = static_cast<GLfloat>(enable_flags.sample_coverage);
1050       }
1051       return true;
1052     case GL_SCISSOR_TEST:
1053       *num_written = 1;
1054       if (params) {
1055         params[0] = static_cast<GLfloat>(enable_flags.scissor_test);
1056       }
1057       return true;
1058     case GL_STENCIL_TEST:
1059       *num_written = 1;
1060       if (params) {
1061         params[0] = static_cast<GLfloat>(enable_flags.stencil_test);
1062       }
1063       return true;
1064     default:
1065       return false;
1066   }
1067 }
1068 #endif  // GPU_COMMAND_BUFFER_SERVICE_CONTEXT_STATE_IMPL_AUTOGEN_H_