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