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