| OLD | NEW |
| 1 // Copyright 2011 The Chromium Authors. All rights reserved. | 1 // Copyright 2011 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
| 4 | 4 |
| 5 #ifndef CC_OUTPUT_SHADER_H_ | 5 #ifndef CC_OUTPUT_SHADER_H_ |
| 6 #define CC_OUTPUT_SHADER_H_ | 6 #define CC_OUTPUT_SHADER_H_ |
| 7 | 7 |
| 8 #include <string> | 8 #include <string> |
| 9 | 9 |
| 10 #include "base/logging.h" | 10 #include "base/logging.h" |
| (...skipping 216 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
| 227 bool has_dummy_variables_ = false; | 227 bool has_dummy_variables_ = false; |
| 228 | 228 |
| 229 bool has_vertex_opacity_ = false; | 229 bool has_vertex_opacity_ = false; |
| 230 int vertex_opacity_location_ = -1; | 230 int vertex_opacity_location_ = -1; |
| 231 | 231 |
| 232 AAMode aa_mode_ = NO_AA; | 232 AAMode aa_mode_ = NO_AA; |
| 233 int viewport_location_ = -1; | 233 int viewport_location_ = -1; |
| 234 int edge_location_ = -1; | 234 int edge_location_ = -1; |
| 235 }; | 235 }; |
| 236 | 236 |
| 237 class VertexShaderPosTex : public VertexShaderBase { | |
| 238 public: | |
| 239 void CheckSubclassProperties() { | |
| 240 DCHECK_EQ(tex_coord_source_, TEX_COORD_SOURCE_ATTRIBUTE); | |
| 241 DCHECK_EQ(has_matrix_, true); | |
| 242 | |
| 243 DCHECK_EQ(use_uniform_arrays_, false); | |
| 244 DCHECK_EQ(position_source_, POSITION_SOURCE_ATTRIBUTE); | |
| 245 DCHECK_EQ(tex_coord_transform_, TEX_COORD_TRANSFORM_NONE); | |
| 246 DCHECK_EQ(is_ya_uv_, false); | |
| 247 DCHECK_EQ(has_dummy_variables_, false); | |
| 248 DCHECK_EQ(has_vertex_opacity_, false); | |
| 249 DCHECK_EQ(aa_mode_, NO_AA); | |
| 250 } | |
| 251 }; | |
| 252 | |
| 253 class VertexShaderPosTexYUVStretchOffset : public VertexShaderBase { | |
| 254 public: | |
| 255 void CheckSubclassProperties() { | |
| 256 DCHECK_EQ(tex_coord_source_, TEX_COORD_SOURCE_ATTRIBUTE); | |
| 257 DCHECK_EQ(has_matrix_, true); | |
| 258 DCHECK_EQ(is_ya_uv_, true); | |
| 259 | |
| 260 DCHECK_EQ(use_uniform_arrays_, false); | |
| 261 DCHECK_EQ(position_source_, POSITION_SOURCE_ATTRIBUTE); | |
| 262 DCHECK_EQ(tex_coord_transform_, TEX_COORD_TRANSFORM_NONE); | |
| 263 DCHECK_EQ(has_dummy_variables_, false); | |
| 264 DCHECK_EQ(has_vertex_opacity_, false); | |
| 265 DCHECK_EQ(aa_mode_, NO_AA); | |
| 266 } | |
| 267 }; | |
| 268 | |
| 269 class VertexShaderPos : public VertexShaderBase { | |
| 270 public: | |
| 271 void CheckSubclassProperties() { | |
| 272 DCHECK_EQ(has_matrix_, true); | |
| 273 | |
| 274 DCHECK_EQ(position_source_, POSITION_SOURCE_ATTRIBUTE); | |
| 275 DCHECK_EQ(tex_coord_source_, TEX_COORD_SOURCE_NONE); | |
| 276 DCHECK_EQ(tex_coord_transform_, TEX_COORD_TRANSFORM_NONE); | |
| 277 DCHECK_EQ(is_ya_uv_, false); | |
| 278 DCHECK_EQ(has_dummy_variables_, false); | |
| 279 DCHECK_EQ(has_vertex_opacity_, false); | |
| 280 DCHECK_EQ(aa_mode_, NO_AA); | |
| 281 DCHECK_EQ(use_uniform_arrays_, false); | |
| 282 } | |
| 283 }; | |
| 284 | |
| 285 class VertexShaderPosTexTransform : public VertexShaderBase { | |
| 286 public: | |
| 287 void CheckSubclassProperties() { | |
| 288 DCHECK_EQ(tex_coord_source_, TEX_COORD_SOURCE_ATTRIBUTE); | |
| 289 DCHECK_EQ(tex_coord_transform_, TEX_COORD_TRANSFORM_VEC4); | |
| 290 DCHECK_EQ(has_matrix_, true); | |
| 291 DCHECK_EQ(has_vertex_opacity_, true); | |
| 292 DCHECK_EQ(use_uniform_arrays_, true); | |
| 293 | |
| 294 DCHECK_EQ(position_source_, POSITION_SOURCE_ATTRIBUTE); | |
| 295 DCHECK_EQ(is_ya_uv_, false); | |
| 296 DCHECK_EQ(has_dummy_variables_, false); | |
| 297 DCHECK_EQ(aa_mode_, NO_AA); | |
| 298 } | |
| 299 }; | |
| 300 | |
| 301 class VertexShaderQuad : public VertexShaderBase { | |
| 302 public: | |
| 303 void CheckSubclassProperties() { | |
| 304 DCHECK_EQ(position_source_, POSITION_SOURCE_ATTRIBUTE_INDEXED_UNIFORM); | |
| 305 DCHECK_EQ(has_matrix_, true); | |
| 306 #if defined(OS_ANDROID) | |
| 307 DCHECK_EQ(has_dummy_variables_, true); | |
| 308 #endif | |
| 309 | |
| 310 DCHECK_EQ(use_uniform_arrays_, false); | |
| 311 DCHECK_EQ(tex_coord_source_, TEX_COORD_SOURCE_NONE); | |
| 312 DCHECK_EQ(tex_coord_transform_, TEX_COORD_TRANSFORM_NONE); | |
| 313 DCHECK_EQ(is_ya_uv_, false); | |
| 314 DCHECK_EQ(has_vertex_opacity_, false); | |
| 315 DCHECK_EQ(aa_mode_, NO_AA); | |
| 316 } | |
| 317 }; | |
| 318 | |
| 319 class VertexShaderQuadAA : public VertexShaderBase { | |
| 320 public: | |
| 321 void CheckSubclassProperties() { | |
| 322 DCHECK_EQ(position_source_, POSITION_SOURCE_ATTRIBUTE_INDEXED_UNIFORM); | |
| 323 DCHECK_EQ(has_matrix_, true); | |
| 324 DCHECK_EQ(aa_mode_, USE_AA); | |
| 325 | |
| 326 DCHECK_EQ(use_uniform_arrays_, false); | |
| 327 DCHECK_EQ(tex_coord_source_, TEX_COORD_SOURCE_NONE); | |
| 328 DCHECK_EQ(tex_coord_transform_, TEX_COORD_TRANSFORM_NONE); | |
| 329 DCHECK_EQ(is_ya_uv_, false); | |
| 330 DCHECK_EQ(has_dummy_variables_, false); | |
| 331 DCHECK_EQ(has_vertex_opacity_, false); | |
| 332 } | |
| 333 }; | |
| 334 | |
| 335 class VertexShaderQuadTexTransformAA : public VertexShaderBase { | |
| 336 public: | |
| 337 void CheckSubclassProperties() { | |
| 338 DCHECK_EQ(position_source_, POSITION_SOURCE_ATTRIBUTE_INDEXED_UNIFORM); | |
| 339 DCHECK_EQ(tex_coord_source_, TEX_COORD_SOURCE_POSITION); | |
| 340 DCHECK_EQ(tex_coord_transform_, TEX_COORD_TRANSFORM_TRANSLATED_VEC4); | |
| 341 DCHECK_EQ(has_matrix_, true); | |
| 342 DCHECK_EQ(aa_mode_, USE_AA); | |
| 343 | |
| 344 DCHECK_EQ(use_uniform_arrays_, false); | |
| 345 DCHECK_EQ(is_ya_uv_, false); | |
| 346 DCHECK_EQ(has_dummy_variables_, false); | |
| 347 DCHECK_EQ(has_vertex_opacity_, false); | |
| 348 } | |
| 349 }; | |
| 350 | |
| 351 class VertexShaderTile : public VertexShaderBase { | |
| 352 public: | |
| 353 void CheckSubclassProperties() { | |
| 354 DCHECK_EQ(position_source_, POSITION_SOURCE_ATTRIBUTE_INDEXED_UNIFORM); | |
| 355 DCHECK_EQ(tex_coord_source_, TEX_COORD_SOURCE_ATTRIBUTE); | |
| 356 DCHECK_EQ(tex_coord_transform_, TEX_COORD_TRANSFORM_VEC4); | |
| 357 DCHECK_EQ(has_matrix_, true); | |
| 358 | |
| 359 DCHECK_EQ(use_uniform_arrays_, false); | |
| 360 DCHECK_EQ(is_ya_uv_, false); | |
| 361 DCHECK_EQ(has_dummy_variables_, false); | |
| 362 DCHECK_EQ(has_vertex_opacity_, false); | |
| 363 DCHECK_EQ(aa_mode_, NO_AA); | |
| 364 } | |
| 365 }; | |
| 366 | |
| 367 class VertexShaderTileAA : public VertexShaderBase { | |
| 368 public: | |
| 369 void CheckSubclassProperties() { | |
| 370 DCHECK_EQ(position_source_, POSITION_SOURCE_ATTRIBUTE_INDEXED_UNIFORM); | |
| 371 DCHECK_EQ(tex_coord_source_, TEX_COORD_SOURCE_POSITION); | |
| 372 DCHECK_EQ(tex_coord_transform_, TEX_COORD_TRANSFORM_VEC4); | |
| 373 DCHECK_EQ(has_matrix_, true); | |
| 374 DCHECK_EQ(aa_mode_, USE_AA); | |
| 375 | |
| 376 DCHECK_EQ(use_uniform_arrays_, false); | |
| 377 DCHECK_EQ(is_ya_uv_, false); | |
| 378 DCHECK_EQ(has_dummy_variables_, false); | |
| 379 DCHECK_EQ(has_vertex_opacity_, false); | |
| 380 } | |
| 381 }; | |
| 382 | |
| 383 class VertexShaderVideoTransform : public VertexShaderBase { | |
| 384 public: | |
| 385 void CheckSubclassProperties() { | |
| 386 DCHECK_EQ(tex_coord_source_, TEX_COORD_SOURCE_ATTRIBUTE); | |
| 387 DCHECK_EQ(tex_coord_transform_, TEX_COORD_TRANSFORM_MATRIX); | |
| 388 DCHECK_EQ(has_matrix_, true); | |
| 389 | |
| 390 DCHECK_EQ(use_uniform_arrays_, false); | |
| 391 DCHECK_EQ(position_source_, POSITION_SOURCE_ATTRIBUTE); | |
| 392 DCHECK_EQ(is_ya_uv_, false); | |
| 393 DCHECK_EQ(has_dummy_variables_, false); | |
| 394 DCHECK_EQ(has_vertex_opacity_, false); | |
| 395 DCHECK_EQ(aa_mode_, NO_AA); | |
| 396 } | |
| 397 }; | |
| 398 | |
| 399 class FragmentShaderBase { | 237 class FragmentShaderBase { |
| 400 public: | 238 public: |
| 401 virtual void Init(gpu::gles2::GLES2Interface* context, | 239 virtual void Init(gpu::gles2::GLES2Interface* context, |
| 402 unsigned program, | 240 unsigned program, |
| 403 int* base_uniform_index); | 241 int* base_uniform_index); |
| 404 std::string GetShaderString() const; | 242 std::string GetShaderString() const; |
| 405 void FillLocations(ShaderLocations* locations) const; | 243 void FillLocations(ShaderLocations* locations) const; |
| 406 | 244 |
| 407 int sampler_location() const { return sampler_location_; } | 245 int sampler_location() const { return sampler_location_; } |
| 408 int alpha_location() const { return alpha_location_; } | 246 int alpha_location() const { return alpha_location_; } |
| (...skipping 62 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
| 471 template <class VertexShader, class FragmentShader> | 309 template <class VertexShader, class FragmentShader> |
| 472 friend class ProgramBinding; | 310 friend class ProgramBinding; |
| 473 | 311 |
| 474 std::string GetHelperFunctions() const; | 312 std::string GetHelperFunctions() const; |
| 475 std::string GetBlendFunction() const; | 313 std::string GetBlendFunction() const; |
| 476 std::string GetBlendFunctionBodyForRGB() const; | 314 std::string GetBlendFunctionBodyForRGB() const; |
| 477 | 315 |
| 478 DISALLOW_COPY_AND_ASSIGN(FragmentShaderBase); | 316 DISALLOW_COPY_AND_ASSIGN(FragmentShaderBase); |
| 479 }; | 317 }; |
| 480 | 318 |
| 481 class FragmentShaderRGBATexVaryingAlpha : public FragmentShaderBase { | |
| 482 public: | |
| 483 void CheckSubclassProperties() { | |
| 484 DCHECK_EQ(has_varying_alpha_, true); | |
| 485 DCHECK_EQ(frag_color_mode_, FRAG_COLOR_MODE_DEFAULT); | |
| 486 | |
| 487 DCHECK_EQ(aa_mode_, NO_AA); | |
| 488 DCHECK_EQ(swizzle_mode_, NO_SWIZZLE); | |
| 489 DCHECK_EQ(premultiply_alpha_mode_, PREMULTIPLIED_ALPHA); | |
| 490 DCHECK_EQ(input_color_type_, INPUT_COLOR_SOURCE_RGBA_TEXTURE); | |
| 491 DCHECK_EQ(has_rgba_fragment_tex_transform_, false); | |
| 492 DCHECK_EQ(ignore_sampler_type_, false); | |
| 493 DCHECK_EQ(mask_mode_, NO_MASK); | |
| 494 DCHECK_EQ(has_color_matrix_, false); | |
| 495 DCHECK_EQ(has_uniform_alpha_, false); | |
| 496 DCHECK_EQ(has_background_color_, false); | |
| 497 } | |
| 498 }; | |
| 499 | |
| 500 class FragmentShaderRGBATexPremultiplyAlpha : public FragmentShaderBase { | |
| 501 public: | |
| 502 void CheckSubclassProperties() { | |
| 503 DCHECK_EQ(has_varying_alpha_, true); | |
| 504 DCHECK_EQ(premultiply_alpha_mode_, NON_PREMULTIPLIED_ALPHA); | |
| 505 DCHECK_EQ(frag_color_mode_, FRAG_COLOR_MODE_DEFAULT); | |
| 506 | |
| 507 DCHECK_EQ(aa_mode_, NO_AA); | |
| 508 DCHECK_EQ(swizzle_mode_, NO_SWIZZLE); | |
| 509 DCHECK_EQ(input_color_type_, INPUT_COLOR_SOURCE_RGBA_TEXTURE); | |
| 510 DCHECK_EQ(has_rgba_fragment_tex_transform_, false); | |
| 511 DCHECK_EQ(ignore_sampler_type_, false); | |
| 512 DCHECK_EQ(mask_mode_, NO_MASK); | |
| 513 DCHECK_EQ(has_color_matrix_, false); | |
| 514 DCHECK_EQ(has_uniform_alpha_, false); | |
| 515 DCHECK_EQ(has_background_color_, false); | |
| 516 } | |
| 517 }; | |
| 518 | |
| 519 class FragmentShaderTexBackgroundVaryingAlpha : public FragmentShaderBase { | |
| 520 public: | |
| 521 void CheckSubclassProperties() { | |
| 522 DCHECK_EQ(has_background_color_, true); | |
| 523 DCHECK_EQ(has_varying_alpha_, true); | |
| 524 DCHECK_EQ(frag_color_mode_, FRAG_COLOR_MODE_DEFAULT); | |
| 525 | |
| 526 DCHECK_EQ(aa_mode_, NO_AA); | |
| 527 DCHECK_EQ(swizzle_mode_, NO_SWIZZLE); | |
| 528 DCHECK_EQ(premultiply_alpha_mode_, PREMULTIPLIED_ALPHA); | |
| 529 DCHECK_EQ(input_color_type_, INPUT_COLOR_SOURCE_RGBA_TEXTURE); | |
| 530 DCHECK_EQ(has_rgba_fragment_tex_transform_, false); | |
| 531 DCHECK_EQ(ignore_sampler_type_, false); | |
| 532 DCHECK_EQ(mask_mode_, NO_MASK); | |
| 533 DCHECK_EQ(has_color_matrix_, false); | |
| 534 DCHECK_EQ(has_uniform_alpha_, false); | |
| 535 } | |
| 536 }; | |
| 537 | |
| 538 class FragmentShaderTexBackgroundPremultiplyAlpha : public FragmentShaderBase { | |
| 539 public: | |
| 540 void CheckSubclassProperties() { | |
| 541 DCHECK_EQ(has_background_color_, true); | |
| 542 DCHECK_EQ(has_varying_alpha_, true); | |
| 543 DCHECK_EQ(premultiply_alpha_mode_, NON_PREMULTIPLIED_ALPHA); | |
| 544 DCHECK_EQ(frag_color_mode_, FRAG_COLOR_MODE_DEFAULT); | |
| 545 | |
| 546 DCHECK_EQ(aa_mode_, NO_AA); | |
| 547 DCHECK_EQ(swizzle_mode_, NO_SWIZZLE); | |
| 548 DCHECK_EQ(input_color_type_, INPUT_COLOR_SOURCE_RGBA_TEXTURE); | |
| 549 DCHECK_EQ(has_rgba_fragment_tex_transform_, false); | |
| 550 DCHECK_EQ(ignore_sampler_type_, false); | |
| 551 DCHECK_EQ(mask_mode_, NO_MASK); | |
| 552 DCHECK_EQ(has_color_matrix_, false); | |
| 553 DCHECK_EQ(has_uniform_alpha_, false); | |
| 554 } | |
| 555 }; | |
| 556 | |
| 557 class FragmentShaderRGBATexAlpha : public FragmentShaderBase { | |
| 558 public: | |
| 559 void CheckSubclassProperties() { | |
| 560 DCHECK_EQ(has_uniform_alpha_, true); | |
| 561 DCHECK_EQ(frag_color_mode_, FRAG_COLOR_MODE_APPLY_BLEND_MODE); | |
| 562 | |
| 563 DCHECK_EQ(aa_mode_, NO_AA); | |
| 564 DCHECK_EQ(has_varying_alpha_, false); | |
| 565 DCHECK_EQ(swizzle_mode_, NO_SWIZZLE); | |
| 566 DCHECK_EQ(premultiply_alpha_mode_, PREMULTIPLIED_ALPHA); | |
| 567 DCHECK_EQ(input_color_type_, INPUT_COLOR_SOURCE_RGBA_TEXTURE); | |
| 568 DCHECK_EQ(has_rgba_fragment_tex_transform_, false); | |
| 569 DCHECK_EQ(ignore_sampler_type_, false); | |
| 570 DCHECK_EQ(mask_mode_, NO_MASK); | |
| 571 DCHECK_EQ(has_color_matrix_, false); | |
| 572 DCHECK_EQ(has_background_color_, false); | |
| 573 } | |
| 574 }; | |
| 575 | |
| 576 class FragmentShaderRGBATexColorMatrixAlpha : public FragmentShaderBase { | |
| 577 public: | |
| 578 void CheckSubclassProperties() { | |
| 579 DCHECK_EQ(has_uniform_alpha_, true); | |
| 580 DCHECK_EQ(has_color_matrix_, true); | |
| 581 DCHECK_EQ(frag_color_mode_, FRAG_COLOR_MODE_APPLY_BLEND_MODE); | |
| 582 | |
| 583 DCHECK_EQ(aa_mode_, NO_AA); | |
| 584 DCHECK_EQ(has_varying_alpha_, false); | |
| 585 DCHECK_EQ(swizzle_mode_, NO_SWIZZLE); | |
| 586 DCHECK_EQ(premultiply_alpha_mode_, PREMULTIPLIED_ALPHA); | |
| 587 DCHECK_EQ(input_color_type_, INPUT_COLOR_SOURCE_RGBA_TEXTURE); | |
| 588 DCHECK_EQ(has_rgba_fragment_tex_transform_, false); | |
| 589 DCHECK_EQ(ignore_sampler_type_, false); | |
| 590 DCHECK_EQ(mask_mode_, NO_MASK); | |
| 591 DCHECK_EQ(has_background_color_, false); | |
| 592 } | |
| 593 }; | |
| 594 | |
| 595 class FragmentShaderRGBATexOpaque : public FragmentShaderBase { | |
| 596 public: | |
| 597 void CheckSubclassProperties() { | |
| 598 DCHECK_EQ(frag_color_mode_, FRAG_COLOR_MODE_OPAQUE); | |
| 599 | |
| 600 DCHECK_EQ(aa_mode_, NO_AA); | |
| 601 DCHECK_EQ(has_varying_alpha_, false); | |
| 602 DCHECK_EQ(swizzle_mode_, NO_SWIZZLE); | |
| 603 DCHECK_EQ(premultiply_alpha_mode_, PREMULTIPLIED_ALPHA); | |
| 604 DCHECK_EQ(input_color_type_, INPUT_COLOR_SOURCE_RGBA_TEXTURE); | |
| 605 DCHECK_EQ(has_rgba_fragment_tex_transform_, false); | |
| 606 DCHECK_EQ(ignore_sampler_type_, false); | |
| 607 DCHECK_EQ(mask_mode_, NO_MASK); | |
| 608 DCHECK_EQ(has_color_matrix_, false); | |
| 609 DCHECK_EQ(has_uniform_alpha_, false); | |
| 610 DCHECK_EQ(has_background_color_, false); | |
| 611 } | |
| 612 }; | |
| 613 | |
| 614 class FragmentShaderRGBATex : public FragmentShaderBase { | |
| 615 public: | |
| 616 void CheckSubclassProperties() { | |
| 617 DCHECK_EQ(frag_color_mode_, FRAG_COLOR_MODE_DEFAULT); | |
| 618 DCHECK_EQ(sampler_type_, SAMPLER_TYPE_EXTERNAL_OES); | |
| 619 | |
| 620 DCHECK_EQ(aa_mode_, NO_AA); | |
| 621 DCHECK_EQ(has_varying_alpha_, false); | |
| 622 DCHECK_EQ(swizzle_mode_, NO_SWIZZLE); | |
| 623 DCHECK_EQ(premultiply_alpha_mode_, PREMULTIPLIED_ALPHA); | |
| 624 DCHECK_EQ(input_color_type_, INPUT_COLOR_SOURCE_RGBA_TEXTURE); | |
| 625 DCHECK_EQ(has_rgba_fragment_tex_transform_, false); | |
| 626 DCHECK_EQ(ignore_sampler_type_, false); | |
| 627 DCHECK_EQ(mask_mode_, NO_MASK); | |
| 628 DCHECK_EQ(has_color_matrix_, false); | |
| 629 DCHECK_EQ(has_uniform_alpha_, false); | |
| 630 DCHECK_EQ(has_background_color_, false); | |
| 631 } | |
| 632 }; | |
| 633 | |
| 634 // Swizzles the red and blue component of sampled texel with alpha. | |
| 635 class FragmentShaderRGBATexSwizzleAlpha : public FragmentShaderBase { | |
| 636 public: | |
| 637 void CheckSubclassProperties() { | |
| 638 DCHECK_EQ(has_uniform_alpha_, true); | |
| 639 DCHECK_EQ(swizzle_mode_, DO_SWIZZLE); | |
| 640 DCHECK_EQ(frag_color_mode_, FRAG_COLOR_MODE_DEFAULT); | |
| 641 | |
| 642 DCHECK_EQ(aa_mode_, NO_AA); | |
| 643 DCHECK_EQ(has_varying_alpha_, false); | |
| 644 DCHECK_EQ(premultiply_alpha_mode_, PREMULTIPLIED_ALPHA); | |
| 645 DCHECK_EQ(input_color_type_, INPUT_COLOR_SOURCE_RGBA_TEXTURE); | |
| 646 DCHECK_EQ(has_rgba_fragment_tex_transform_, false); | |
| 647 DCHECK_EQ(ignore_sampler_type_, false); | |
| 648 DCHECK_EQ(mask_mode_, NO_MASK); | |
| 649 DCHECK_EQ(has_color_matrix_, false); | |
| 650 DCHECK_EQ(has_background_color_, false); | |
| 651 } | |
| 652 }; | |
| 653 | |
| 654 // Swizzles the red and blue component of sampled texel without alpha. | |
| 655 class FragmentShaderRGBATexSwizzleOpaque : public FragmentShaderBase { | |
| 656 public: | |
| 657 void CheckSubclassProperties() { | |
| 658 DCHECK_EQ(swizzle_mode_, DO_SWIZZLE); | |
| 659 DCHECK_EQ(frag_color_mode_, FRAG_COLOR_MODE_OPAQUE); | |
| 660 | |
| 661 DCHECK_EQ(aa_mode_, NO_AA); | |
| 662 DCHECK_EQ(has_varying_alpha_, false); | |
| 663 DCHECK_EQ(premultiply_alpha_mode_, PREMULTIPLIED_ALPHA); | |
| 664 DCHECK_EQ(input_color_type_, INPUT_COLOR_SOURCE_RGBA_TEXTURE); | |
| 665 DCHECK_EQ(has_rgba_fragment_tex_transform_, false); | |
| 666 DCHECK_EQ(ignore_sampler_type_, false); | |
| 667 DCHECK_EQ(mask_mode_, NO_MASK); | |
| 668 DCHECK_EQ(has_color_matrix_, false); | |
| 669 DCHECK_EQ(has_uniform_alpha_, false); | |
| 670 DCHECK_EQ(has_background_color_, false); | |
| 671 } | |
| 672 }; | |
| 673 | |
| 674 class FragmentShaderRGBATexAlphaAA : public FragmentShaderBase { | |
| 675 public: | |
| 676 void CheckSubclassProperties() { | |
| 677 DCHECK_EQ(aa_mode_, USE_AA); | |
| 678 DCHECK_EQ(has_uniform_alpha_, true); | |
| 679 DCHECK_EQ(frag_color_mode_, FRAG_COLOR_MODE_APPLY_BLEND_MODE); | |
| 680 | |
| 681 DCHECK_EQ(has_varying_alpha_, false); | |
| 682 DCHECK_EQ(swizzle_mode_, NO_SWIZZLE); | |
| 683 DCHECK_EQ(premultiply_alpha_mode_, PREMULTIPLIED_ALPHA); | |
| 684 DCHECK_EQ(input_color_type_, INPUT_COLOR_SOURCE_RGBA_TEXTURE); | |
| 685 DCHECK_EQ(has_rgba_fragment_tex_transform_, false); | |
| 686 DCHECK_EQ(ignore_sampler_type_, false); | |
| 687 DCHECK_EQ(mask_mode_, NO_MASK); | |
| 688 DCHECK_EQ(has_color_matrix_, false); | |
| 689 DCHECK_EQ(has_background_color_, false); | |
| 690 } | |
| 691 }; | |
| 692 | |
| 693 class FragmentShaderRGBATexClampAlphaAA : public FragmentShaderBase { | |
| 694 public: | |
| 695 void CheckSubclassProperties() { | |
| 696 DCHECK_EQ(aa_mode_, USE_AA); | |
| 697 DCHECK_EQ(has_uniform_alpha_, true); | |
| 698 DCHECK_EQ(has_rgba_fragment_tex_transform_, true); | |
| 699 DCHECK_EQ(frag_color_mode_, FRAG_COLOR_MODE_DEFAULT); | |
| 700 | |
| 701 DCHECK_EQ(has_varying_alpha_, false); | |
| 702 DCHECK_EQ(swizzle_mode_, NO_SWIZZLE); | |
| 703 DCHECK_EQ(premultiply_alpha_mode_, PREMULTIPLIED_ALPHA); | |
| 704 DCHECK_EQ(input_color_type_, INPUT_COLOR_SOURCE_RGBA_TEXTURE); | |
| 705 DCHECK_EQ(ignore_sampler_type_, false); | |
| 706 DCHECK_EQ(mask_mode_, NO_MASK); | |
| 707 DCHECK_EQ(has_color_matrix_, false); | |
| 708 DCHECK_EQ(has_background_color_, false); | |
| 709 } | |
| 710 }; | |
| 711 | |
| 712 // Swizzles the red and blue component of sampled texel. | |
| 713 class FragmentShaderRGBATexClampSwizzleAlphaAA : public FragmentShaderBase { | |
| 714 public: | |
| 715 void CheckSubclassProperties() { | |
| 716 DCHECK_EQ(aa_mode_, USE_AA); | |
| 717 DCHECK_EQ(has_uniform_alpha_, true); | |
| 718 DCHECK_EQ(has_rgba_fragment_tex_transform_, true); | |
| 719 DCHECK_EQ(swizzle_mode_, DO_SWIZZLE); | |
| 720 DCHECK_EQ(frag_color_mode_, FRAG_COLOR_MODE_DEFAULT); | |
| 721 | |
| 722 DCHECK_EQ(has_varying_alpha_, false); | |
| 723 DCHECK_EQ(premultiply_alpha_mode_, PREMULTIPLIED_ALPHA); | |
| 724 DCHECK_EQ(input_color_type_, INPUT_COLOR_SOURCE_RGBA_TEXTURE); | |
| 725 DCHECK_EQ(ignore_sampler_type_, false); | |
| 726 DCHECK_EQ(mask_mode_, NO_MASK); | |
| 727 DCHECK_EQ(has_color_matrix_, false); | |
| 728 DCHECK_EQ(has_background_color_, false); | |
| 729 } | |
| 730 }; | |
| 731 | |
| 732 class FragmentShaderRGBATexAlphaMask : public FragmentShaderBase { | |
| 733 public: | |
| 734 void CheckSubclassProperties() { | |
| 735 DCHECK_EQ(has_uniform_alpha_, true); | |
| 736 DCHECK_EQ(mask_mode_, HAS_MASK); | |
| 737 DCHECK_EQ(frag_color_mode_, FRAG_COLOR_MODE_APPLY_BLEND_MODE); | |
| 738 DCHECK_EQ(ignore_sampler_type_, true); | |
| 739 | |
| 740 DCHECK_EQ(aa_mode_, NO_AA); | |
| 741 DCHECK_EQ(has_varying_alpha_, false); | |
| 742 DCHECK_EQ(swizzle_mode_, NO_SWIZZLE); | |
| 743 DCHECK_EQ(premultiply_alpha_mode_, PREMULTIPLIED_ALPHA); | |
| 744 DCHECK_EQ(input_color_type_, INPUT_COLOR_SOURCE_RGBA_TEXTURE); | |
| 745 DCHECK_EQ(has_rgba_fragment_tex_transform_, false); | |
| 746 DCHECK_EQ(has_color_matrix_, false); | |
| 747 DCHECK_EQ(has_background_color_, false); | |
| 748 } | |
| 749 }; | |
| 750 | |
| 751 class FragmentShaderRGBATexAlphaMaskAA : public FragmentShaderBase { | |
| 752 public: | |
| 753 void CheckSubclassProperties() { | |
| 754 DCHECK_EQ(aa_mode_, USE_AA); | |
| 755 DCHECK_EQ(has_uniform_alpha_, true); | |
| 756 DCHECK_EQ(mask_mode_, HAS_MASK); | |
| 757 DCHECK_EQ(frag_color_mode_, FRAG_COLOR_MODE_APPLY_BLEND_MODE); | |
| 758 DCHECK_EQ(ignore_sampler_type_, true); | |
| 759 | |
| 760 DCHECK_EQ(has_varying_alpha_, false); | |
| 761 DCHECK_EQ(swizzle_mode_, NO_SWIZZLE); | |
| 762 DCHECK_EQ(premultiply_alpha_mode_, PREMULTIPLIED_ALPHA); | |
| 763 DCHECK_EQ(input_color_type_, INPUT_COLOR_SOURCE_RGBA_TEXTURE); | |
| 764 DCHECK_EQ(has_rgba_fragment_tex_transform_, false); | |
| 765 DCHECK_EQ(has_color_matrix_, false); | |
| 766 DCHECK_EQ(has_background_color_, false); | |
| 767 } | |
| 768 }; | |
| 769 | |
| 770 class FragmentShaderRGBATexAlphaMaskColorMatrixAA : public FragmentShaderBase { | |
| 771 public: | |
| 772 void CheckSubclassProperties() { | |
| 773 DCHECK_EQ(aa_mode_, USE_AA); | |
| 774 DCHECK_EQ(has_uniform_alpha_, true); | |
| 775 DCHECK_EQ(mask_mode_, HAS_MASK); | |
| 776 DCHECK_EQ(has_color_matrix_, true); | |
| 777 DCHECK_EQ(frag_color_mode_, FRAG_COLOR_MODE_APPLY_BLEND_MODE); | |
| 778 DCHECK_EQ(ignore_sampler_type_, true); | |
| 779 | |
| 780 DCHECK_EQ(has_varying_alpha_, false); | |
| 781 DCHECK_EQ(swizzle_mode_, NO_SWIZZLE); | |
| 782 DCHECK_EQ(premultiply_alpha_mode_, PREMULTIPLIED_ALPHA); | |
| 783 DCHECK_EQ(input_color_type_, INPUT_COLOR_SOURCE_RGBA_TEXTURE); | |
| 784 DCHECK_EQ(has_rgba_fragment_tex_transform_, false); | |
| 785 DCHECK_EQ(has_background_color_, false); | |
| 786 } | |
| 787 }; | |
| 788 | |
| 789 class FragmentShaderRGBATexAlphaColorMatrixAA : public FragmentShaderBase { | |
| 790 public: | |
| 791 void CheckSubclassProperties() { | |
| 792 DCHECK_EQ(aa_mode_, USE_AA); | |
| 793 DCHECK_EQ(has_uniform_alpha_, true); | |
| 794 DCHECK_EQ(has_color_matrix_, true); | |
| 795 DCHECK_EQ(frag_color_mode_, FRAG_COLOR_MODE_APPLY_BLEND_MODE); | |
| 796 | |
| 797 DCHECK_EQ(has_varying_alpha_, false); | |
| 798 DCHECK_EQ(swizzle_mode_, NO_SWIZZLE); | |
| 799 DCHECK_EQ(premultiply_alpha_mode_, PREMULTIPLIED_ALPHA); | |
| 800 DCHECK_EQ(input_color_type_, INPUT_COLOR_SOURCE_RGBA_TEXTURE); | |
| 801 DCHECK_EQ(has_rgba_fragment_tex_transform_, false); | |
| 802 DCHECK_EQ(ignore_sampler_type_, false); | |
| 803 DCHECK_EQ(mask_mode_, NO_MASK); | |
| 804 DCHECK_EQ(has_background_color_, false); | |
| 805 } | |
| 806 }; | |
| 807 | |
| 808 class FragmentShaderRGBATexAlphaMaskColorMatrix : public FragmentShaderBase { | |
| 809 public: | |
| 810 void CheckSubclassProperties() { | |
| 811 DCHECK_EQ(has_uniform_alpha_, true); | |
| 812 DCHECK_EQ(mask_mode_, HAS_MASK); | |
| 813 DCHECK_EQ(has_color_matrix_, true); | |
| 814 DCHECK_EQ(frag_color_mode_, FRAG_COLOR_MODE_APPLY_BLEND_MODE); | |
| 815 DCHECK_EQ(ignore_sampler_type_, true); | |
| 816 | |
| 817 DCHECK_EQ(aa_mode_, NO_AA); | |
| 818 DCHECK_EQ(has_varying_alpha_, false); | |
| 819 DCHECK_EQ(swizzle_mode_, NO_SWIZZLE); | |
| 820 DCHECK_EQ(premultiply_alpha_mode_, PREMULTIPLIED_ALPHA); | |
| 821 DCHECK_EQ(input_color_type_, INPUT_COLOR_SOURCE_RGBA_TEXTURE); | |
| 822 DCHECK_EQ(has_rgba_fragment_tex_transform_, false); | |
| 823 DCHECK_EQ(has_background_color_, false); | |
| 824 } | |
| 825 }; | |
| 826 | |
| 827 class FragmentShaderYUVVideo : public FragmentShaderBase { | 319 class FragmentShaderYUVVideo : public FragmentShaderBase { |
| 828 public: | 320 public: |
| 829 FragmentShaderYUVVideo(); | 321 FragmentShaderYUVVideo(); |
| 830 | 322 |
| 831 void CheckSubclassProperties() {} | 323 void CheckSubclassProperties() {} |
| 832 | 324 |
| 833 void Init(gpu::gles2::GLES2Interface* context, | 325 void Init(gpu::gles2::GLES2Interface* context, |
| 834 unsigned program, | 326 unsigned program, |
| 835 int* base_uniform_index) override; | 327 int* base_uniform_index) override; |
| 836 int y_texture_location() const { return y_texture_location_; } | 328 int y_texture_location() const { return y_texture_location_; } |
| (...skipping 30 matching lines...) Expand all Loading... |
| 867 int lut_texture_location_ = -1; | 359 int lut_texture_location_ = -1; |
| 868 int alpha_location_ = -1; | 360 int alpha_location_ = -1; |
| 869 int yuv_matrix_location_ = -1; | 361 int yuv_matrix_location_ = -1; |
| 870 int yuv_adj_location_ = -1; | 362 int yuv_adj_location_ = -1; |
| 871 int ya_clamp_rect_location_ = -1; | 363 int ya_clamp_rect_location_ = -1; |
| 872 int uv_clamp_rect_location_ = -1; | 364 int uv_clamp_rect_location_ = -1; |
| 873 int resource_multiplier_location_ = -1; | 365 int resource_multiplier_location_ = -1; |
| 874 int resource_offset_location_ = -1; | 366 int resource_offset_location_ = -1; |
| 875 }; | 367 }; |
| 876 | 368 |
| 877 class FragmentShaderColor : public FragmentShaderBase { | |
| 878 public: | |
| 879 void CheckSubclassProperties() { | |
| 880 DCHECK_EQ(input_color_type_, INPUT_COLOR_SOURCE_UNIFORM); | |
| 881 DCHECK_EQ(frag_color_mode_, FRAG_COLOR_MODE_DEFAULT); | |
| 882 | |
| 883 DCHECK_EQ(aa_mode_, NO_AA); | |
| 884 DCHECK_EQ(has_varying_alpha_, false); | |
| 885 DCHECK_EQ(swizzle_mode_, NO_SWIZZLE); | |
| 886 DCHECK_EQ(premultiply_alpha_mode_, PREMULTIPLIED_ALPHA); | |
| 887 DCHECK_EQ(has_rgba_fragment_tex_transform_, false); | |
| 888 DCHECK_EQ(ignore_sampler_type_, false); | |
| 889 DCHECK_EQ(mask_mode_, NO_MASK); | |
| 890 DCHECK_EQ(has_color_matrix_, false); | |
| 891 DCHECK_EQ(has_uniform_alpha_, false); | |
| 892 DCHECK_EQ(has_background_color_, false); | |
| 893 } | |
| 894 }; | |
| 895 | |
| 896 class FragmentShaderColorAA : public FragmentShaderBase { | |
| 897 public: | |
| 898 void CheckSubclassProperties() { | |
| 899 DCHECK_EQ(input_color_type_, INPUT_COLOR_SOURCE_UNIFORM); | |
| 900 DCHECK_EQ(aa_mode_, USE_AA); | |
| 901 DCHECK_EQ(frag_color_mode_, FRAG_COLOR_MODE_DEFAULT); | |
| 902 | |
| 903 DCHECK_EQ(has_varying_alpha_, false); | |
| 904 DCHECK_EQ(swizzle_mode_, NO_SWIZZLE); | |
| 905 DCHECK_EQ(premultiply_alpha_mode_, PREMULTIPLIED_ALPHA); | |
| 906 DCHECK_EQ(has_rgba_fragment_tex_transform_, false); | |
| 907 DCHECK_EQ(ignore_sampler_type_, false); | |
| 908 DCHECK_EQ(mask_mode_, NO_MASK); | |
| 909 DCHECK_EQ(has_color_matrix_, false); | |
| 910 DCHECK_EQ(has_uniform_alpha_, false); | |
| 911 DCHECK_EQ(has_background_color_, false); | |
| 912 } | |
| 913 }; | |
| 914 | |
| 915 } // namespace cc | 369 } // namespace cc |
| 916 | 370 |
| 917 #endif // CC_OUTPUT_SHADER_H_ | 371 #endif // CC_OUTPUT_SHADER_H_ |
| OLD | NEW |