cc/output/shader.h

   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
   3 // found in the LICENSE file.
   4
   5 #ifndef CC_OUTPUT_SHADER_H_
   6 #define CC_OUTPUT_SHADER_H_
   7
   8 #include <string>
   9
  10 #include "base/basictypes.h"
  11 #include "cc/base/cc_export.h"
  12
  13 namespace gfx {
  14 class Point;
  15 class Size;
  16 }
  17
  18 namespace gpu {
  19 namespace gles2 {
  20 class GLES2Interface;
  21 }
  22 }
  23
  24 namespace cc {
  25
  26 enum TexCoordPrecision {
  27   TEX_COORD_PRECISION_NA = 0,
  28   TEX_COORD_PRECISION_MEDIUM = 1,
  29   TEX_COORD_PRECISION_HIGH = 2,
  30   LAST_TEX_COORD_PRECISION = 2
  31 };
  32
  33 enum SamplerType {
  34   SAMPLER_TYPE_NA = 0,
  35   SAMPLER_TYPE_2D = 1,
  36   SAMPLER_TYPE_2D_RECT = 2,
  37   SAMPLER_TYPE_EXTERNAL_OES = 3,
  38   LAST_SAMPLER_TYPE = 3
  39 };
  40
  41 enum BlendMode {
  42   BLEND_MODE_NONE,
  43   BLEND_MODE_NORMAL,
  44   BLEND_MODE_SCREEN,
  45   BLEND_MODE_OVERLAY,
  46   BLEND_MODE_DARKEN,
  47   BLEND_MODE_LIGHTEN,
  48   BLEND_MODE_COLOR_DODGE,
  49   BLEND_MODE_COLOR_BURN,
  50   BLEND_MODE_HARD_LIGHT,
  51   BLEND_MODE_SOFT_LIGHT,
  52   BLEND_MODE_DIFFERENCE,
  53   BLEND_MODE_EXCLUSION,
  54   BLEND_MODE_MULTIPLY,
  55   BLEND_MODE_HUE,
  56   BLEND_MODE_SATURATION,
  57   BLEND_MODE_COLOR,
  58   BLEND_MODE_LUMINOSITY,
  59   LAST_BLEND_MODE = BLEND_MODE_LUMINOSITY
  60 };
  61
  62 enum MaskMode {
  63   NO_MASK = 0,
  64   HAS_MASK = 1,
  65   LAST_MASK_VALUE = HAS_MASK
  66 };
  67
  68 struct ShaderLocations {
  69   ShaderLocations();
  70
  71   int sampler = -1;
  72   int quad = -1;
  73   int edge = -1;
  74   int viewport = -1;
  75   int mask_sampler = -1;
  76   int mask_tex_coord_scale = -1;
  77   int mask_tex_coord_offset = -1;
  78   int matrix = -1;
  79   int alpha = -1;
  80   int color_matrix = -1;
  81   int color_offset = -1;
  82   int tex_transform = -1;
  83   int backdrop = -1;
  84   int backdrop_rect = -1;
  85   int original_backdrop = -1;
  86 };
  87
  88 // Note: The highp_threshold_cache must be provided by the caller to make
  89 // the caching multi-thread/context safe in an easy low-overhead manner.
  90 // The caller must make sure to clear highp_threshold_cache to 0, so it can be
  91 // reinitialized, if a new or different context is used.
  92 CC_EXPORT TexCoordPrecision
  93     TexCoordPrecisionRequired(gpu::gles2::GLES2Interface* context,
  94                               int* highp_threshold_cache,
  95                               int highp_threshold_min,
  96                               const gfx::Point& max_coordinate);
  97
  98 CC_EXPORT TexCoordPrecision TexCoordPrecisionRequired(
  99     gpu::gles2::GLES2Interface* context,
 100     int *highp_threshold_cache,
 101     int highp_threshold_min,
 102     const gfx::Size& max_size);
 103
 104 class VertexShaderPosTex {
 105  public:
 106   VertexShaderPosTex();
 107
 108   void Init(gpu::gles2::GLES2Interface* context,
 109             unsigned program,
 110             int* base_uniform_index);
 111   std::string GetShaderString() const;
 112   static std::string GetShaderHead();
 113   static std::string GetShaderBody();
 114
 115   int matrix_location() const { return matrix_location_; }
 116
 117  private:
 118   int matrix_location_;
 119
 120   DISALLOW_COPY_AND_ASSIGN(VertexShaderPosTex);
 121 };
 122
 123 class VertexShaderPosTexYUVStretchOffset {
 124  public:
 125   VertexShaderPosTexYUVStretchOffset();
 126
 127   void Init(gpu::gles2::GLES2Interface* context,
 128             unsigned program,
 129             int* base_uniform_index);
 130   std::string GetShaderString() const;
 131   static std::string GetShaderHead();
 132   static std::string GetShaderBody();
 133
 134   int matrix_location() const { return matrix_location_; }
 135   int tex_scale_location() const { return tex_scale_location_; }
 136   int tex_offset_location() const { return tex_offset_location_; }
 137
 138  private:
 139   int matrix_location_;
 140   int tex_scale_location_;
 141   int tex_offset_location_;
 142
 143   DISALLOW_COPY_AND_ASSIGN(VertexShaderPosTexYUVStretchOffset);
 144 };
 145
 146 class VertexShaderPos {
 147  public:
 148   VertexShaderPos();
 149
 150   void Init(gpu::gles2::GLES2Interface* context,
 151             unsigned program,
 152             int* base_uniform_index);
 153   std::string GetShaderString() const;
 154   static std::string GetShaderHead();
 155   static std::string GetShaderBody();
 156
 157   int matrix_location() const { return matrix_location_; }
 158
 159  private:
 160   int matrix_location_;
 161
 162   DISALLOW_COPY_AND_ASSIGN(VertexShaderPos);
 163 };
 164
 165 class VertexShaderPosTexIdentity {
 166  public:
 167   void Init(gpu::gles2::GLES2Interface* context,
 168             unsigned program,
 169             int* base_uniform_index) {}
 170   std::string GetShaderString() const;
 171   static std::string GetShaderHead();
 172   static std::string GetShaderBody();
 173 };
 174
 175 class VertexShaderPosTexTransform {
 176  public:
 177   VertexShaderPosTexTransform();
 178
 179   void Init(gpu::gles2::GLES2Interface* context,
 180             unsigned program,
 181             int* base_uniform_index);
 182   std::string GetShaderString() const;
 183   static std::string GetShaderHead();
 184   static std::string GetShaderBody();
 185   void FillLocations(ShaderLocations* locations) const;
 186
 187   int matrix_location() const { return matrix_location_; }
 188   int tex_transform_location() const { return tex_transform_location_; }
 189   int vertex_opacity_location() const { return vertex_opacity_location_; }
 190
 191  private:
 192   int matrix_location_;
 193   int tex_transform_location_;
 194   int vertex_opacity_location_;
 195
 196   DISALLOW_COPY_AND_ASSIGN(VertexShaderPosTexTransform);
 197 };
 198
 199 class VertexShaderQuad {
 200  public:
 201   VertexShaderQuad();
 202
 203   void Init(gpu::gles2::GLES2Interface* context,
 204            unsigned program,
 205            int* base_uniform_index);
 206   std::string GetShaderString() const;
 207   static std::string GetShaderHead();
 208   static std::string GetShaderBody();
 209
 210   int matrix_location() const { return matrix_location_; }
 211   int viewport_location() const { return -1; }
 212   int quad_location() const { return quad_location_; }
 213   int edge_location() const { return -1; }
 214
 215  private:
 216   int matrix_location_;
 217   int quad_location_;
 218
 219   DISALLOW_COPY_AND_ASSIGN(VertexShaderQuad);
 220 };
 221
 222 class VertexShaderQuadAA {
 223  public:
 224   VertexShaderQuadAA();
 225
 226   void Init(gpu::gles2::GLES2Interface* context,
 227            unsigned program,
 228            int* base_uniform_index);
 229   std::string GetShaderString() const;
 230   static std::string GetShaderHead();
 231   static std::string GetShaderBody();
 232
 233   int matrix_location() const { return matrix_location_; }
 234   int viewport_location() const { return viewport_location_; }
 235   int quad_location() const { return quad_location_; }
 236   int edge_location() const { return edge_location_; }
 237
 238  private:
 239   int matrix_location_;
 240   int viewport_location_;
 241   int quad_location_;
 242   int edge_location_;
 243
 244   DISALLOW_COPY_AND_ASSIGN(VertexShaderQuadAA);
 245 };
 246
 247
 248 class VertexShaderQuadTexTransformAA {
 249  public:
 250   VertexShaderQuadTexTransformAA();
 251
 252   void Init(gpu::gles2::GLES2Interface* context,
 253            unsigned program,
 254            int* base_uniform_index);
 255   std::string GetShaderString() const;
 256   static std::string GetShaderHead();
 257   static std::string GetShaderBody();
 258   void FillLocations(ShaderLocations* locations) const;
 259
 260   int matrix_location() const { return matrix_location_; }
 261   int viewport_location() const { return viewport_location_; }
 262   int quad_location() const { return quad_location_; }
 263   int edge_location() const { return edge_location_; }
 264   int tex_transform_location() const { return tex_transform_location_; }
 265
 266  private:
 267   int matrix_location_;
 268   int viewport_location_;
 269   int quad_location_;
 270   int edge_location_;
 271   int tex_transform_location_;
 272
 273   DISALLOW_COPY_AND_ASSIGN(VertexShaderQuadTexTransformAA);
 274 };
 275
 276 class VertexShaderTile {
 277  public:
 278   VertexShaderTile();
 279
 280   void Init(gpu::gles2::GLES2Interface* context,
 281             unsigned program,
 282             int* base_uniform_index);
 283   std::string GetShaderString() const;
 284   static std::string GetShaderHead();
 285   static std::string GetShaderBody();
 286
 287   int matrix_location() const { return matrix_location_; }
 288   int viewport_location() const { return -1; }
 289   int quad_location() const { return quad_location_; }
 290   int edge_location() const { return -1; }
 291   int vertex_tex_transform_location() const {
 292     return vertex_tex_transform_location_;
 293   }
 294
 295  private:
 296   int matrix_location_;
 297   int quad_location_;
 298   int vertex_tex_transform_location_;
 299
 300   DISALLOW_COPY_AND_ASSIGN(VertexShaderTile);
 301 };
 302
 303 class VertexShaderTileAA {
 304  public:
 305   VertexShaderTileAA();
 306
 307   void Init(gpu::gles2::GLES2Interface* context,
 308             unsigned program,
 309             int* base_uniform_index);
 310   std::string GetShaderString() const;
 311   static std::string GetShaderHead();
 312   static std::string GetShaderBody();
 313
 314   int matrix_location() const { return matrix_location_; }
 315   int viewport_location() const { return viewport_location_; }
 316   int quad_location() const { return quad_location_; }
 317   int edge_location() const { return edge_location_; }
 318   int vertex_tex_transform_location() const {
 319     return vertex_tex_transform_location_;
 320   }
 321
 322  private:
 323   int matrix_location_;
 324   int viewport_location_;
 325   int quad_location_;
 326   int edge_location_;
 327   int vertex_tex_transform_location_;
 328
 329   DISALLOW_COPY_AND_ASSIGN(VertexShaderTileAA);
 330 };
 331
 332 class VertexShaderVideoTransform {
 333  public:
 334   VertexShaderVideoTransform();
 335
 336   void Init(gpu::gles2::GLES2Interface* context,
 337             unsigned program,
 338             int* base_uniform_index);
 339   std::string GetShaderString() const;
 340   static std::string GetShaderHead();
 341   static std::string GetShaderBody();
 342
 343   int matrix_location() const { return matrix_location_; }
 344   int tex_matrix_location() const { return tex_matrix_location_; }
 345
 346  private:
 347   int matrix_location_;
 348   int tex_matrix_location_;
 349
 350   DISALLOW_COPY_AND_ASSIGN(VertexShaderVideoTransform);
 351 };
 352
 353 class FragmentTexBlendMode {
 354  public:
 355   int backdrop_location() const { return backdrop_location_; }
 356   int original_backdrop_location() const { return original_backdrop_location_; }
 357   int backdrop_rect_location() const { return backdrop_rect_location_; }
 358
 359   BlendMode blend_mode() const { return blend_mode_; }
 360   void set_blend_mode(BlendMode blend_mode) { blend_mode_ = blend_mode; }
 361   bool has_blend_mode() const { return blend_mode_ != BLEND_MODE_NONE; }
 362   void set_mask_for_background(bool mask_for_background) {
 363     mask_for_background_ = mask_for_background;
 364   }
 365   bool mask_for_background() const { return mask_for_background_; }
 366
 367  protected:
 368   FragmentTexBlendMode();
 369
 370   std::string SetBlendModeFunctions(std::string shader_string) const;
 371
 372   int backdrop_location_;
 373   int original_backdrop_location_;
 374   int backdrop_rect_location_;
 375
 376  private:
 377   BlendMode blend_mode_;
 378   bool mask_for_background_;
 379
 380   std::string GetHelperFunctions() const;
 381   std::string GetBlendFunction() const;
 382   std::string GetBlendFunctionBodyForRGB() const;
 383 };
 384
 385 class FragmentTexAlphaBinding : public FragmentTexBlendMode {
 386  public:
 387   FragmentTexAlphaBinding();
 388
 389   void Init(gpu::gles2::GLES2Interface* context,
 390             unsigned program,
 391             int* base_uniform_index);
 392   int alpha_location() const { return alpha_location_; }
 393   int fragment_tex_transform_location() const { return -1; }
 394   int sampler_location() const { return sampler_location_; }
 395
 396  private:
 397   int sampler_location_;
 398   int alpha_location_;
 399
 400   DISALLOW_COPY_AND_ASSIGN(FragmentTexAlphaBinding);
 401 };
 402
 403 class FragmentTexColorMatrixAlphaBinding : public FragmentTexBlendMode {
 404  public:
 405     FragmentTexColorMatrixAlphaBinding();
 406
 407     void Init(gpu::gles2::GLES2Interface* context,
 408               unsigned program,
 409               int* base_uniform_index);
 410     int alpha_location() const { return alpha_location_; }
 411     int color_matrix_location() const { return color_matrix_location_; }
 412     int color_offset_location() const { return color_offset_location_; }
 413     int fragment_tex_transform_location() const { return -1; }
 414     int sampler_location() const { return sampler_location_; }
 415
 416  private:
 417     int sampler_location_;
 418     int alpha_location_;
 419     int color_matrix_location_;
 420     int color_offset_location_;
 421 };
 422
 423 class FragmentTexOpaqueBinding : public FragmentTexBlendMode {
 424  public:
 425   FragmentTexOpaqueBinding();
 426
 427   void Init(gpu::gles2::GLES2Interface* context,
 428             unsigned program,
 429             int* base_uniform_index);
 430   int alpha_location() const { return -1; }
 431   int fragment_tex_transform_location() const { return -1; }
 432   int background_color_location() const { return -1; }
 433   int sampler_location() const { return sampler_location_; }
 434
 435  private:
 436   int sampler_location_;
 437
 438   DISALLOW_COPY_AND_ASSIGN(FragmentTexOpaqueBinding);
 439 };
 440
 441 class FragmentTexBackgroundBinding : public FragmentTexBlendMode {
 442  public:
 443   FragmentTexBackgroundBinding();
 444
 445   void Init(gpu::gles2::GLES2Interface* context,
 446             unsigned program,
 447             int* base_uniform_index);
 448   int background_color_location() const { return background_color_location_; }
 449   int sampler_location() const { return sampler_location_; }
 450
 451  private:
 452   int background_color_location_;
 453   int sampler_location_;
 454
 455   DISALLOW_COPY_AND_ASSIGN(FragmentTexBackgroundBinding);
 456 };
 457
 458 class FragmentShaderRGBATexVaryingAlpha : public FragmentTexOpaqueBinding {
 459  public:
 460   std::string GetShaderString(
 461       TexCoordPrecision precision, SamplerType sampler) const;
 462   static std::string GetShaderHead();
 463   static std::string GetShaderBody();
 464 };
 465
 466 class FragmentShaderRGBATexPremultiplyAlpha : public FragmentTexOpaqueBinding {
 467  public:
 468   std::string GetShaderString(
 469       TexCoordPrecision precision, SamplerType sampler) const;
 470   static std::string GetShaderHead();
 471   static std::string GetShaderBody();
 472 };
 473
 474 class FragmentShaderTexBackgroundVaryingAlpha
 475     : public FragmentTexBackgroundBinding {
 476  public:
 477   std::string GetShaderString(
 478       TexCoordPrecision precision, SamplerType sampler) const;
 479   static std::string GetShaderHead();
 480   static std::string GetShaderBody();
 481 };
 482
 483 class FragmentShaderTexBackgroundPremultiplyAlpha
 484     : public FragmentTexBackgroundBinding {
 485  public:
 486   std::string GetShaderString(
 487       TexCoordPrecision precision, SamplerType sampler) const;
 488   static std::string GetShaderHead();
 489   static std::string GetShaderBody();
 490 };
 491
 492 class FragmentShaderRGBATexAlpha : public FragmentTexAlphaBinding {
 493  public:
 494   std::string GetShaderString(
 495       TexCoordPrecision precision, SamplerType sampler) const;
 496   static std::string GetShaderHead();
 497   static std::string GetShaderBody();
 498   void FillLocations(ShaderLocations* locations) const;
 499 };
 500
 501 class FragmentShaderRGBATexColorMatrixAlpha
 502     : public FragmentTexColorMatrixAlphaBinding {
 503  public:
 504   std::string GetShaderString(TexCoordPrecision precision,
 505                               SamplerType sampler) const;
 506   static std::string GetShaderHead();
 507   static std::string GetShaderBody();
 508   void FillLocations(ShaderLocations* locations) const;
 509 };
 510
 511 class FragmentShaderRGBATexOpaque : public FragmentTexOpaqueBinding {
 512  public:
 513   std::string GetShaderString(
 514       TexCoordPrecision precision, SamplerType sampler) const;
 515   static std::string GetShaderHead();
 516   static std::string GetShaderBody();
 517 };
 518
 519 class FragmentShaderRGBATex : public FragmentTexOpaqueBinding {
 520  public:
 521   std::string GetShaderString(
 522       TexCoordPrecision precision, SamplerType sampler) const;
 523   static std::string GetShaderHead();
 524   static std::string GetShaderBody();
 525 };
 526
 527 // Swizzles the red and blue component of sampled texel with alpha.
 528 class FragmentShaderRGBATexSwizzleAlpha : public FragmentTexAlphaBinding {
 529  public:
 530   std::string GetShaderString(
 531       TexCoordPrecision precision, SamplerType sampler) const;
 532   static std::string GetShaderHead();
 533   static std::string GetShaderBody();
 534 };
 535
 536 // Swizzles the red and blue component of sampled texel without alpha.
 537 class FragmentShaderRGBATexSwizzleOpaque : public FragmentTexOpaqueBinding {
 538  public:
 539   std::string GetShaderString(
 540       TexCoordPrecision precision, SamplerType sampler) const;
 541   static std::string GetShaderHead();
 542   static std::string GetShaderBody();
 543 };
 544
 545 class FragmentShaderRGBATexAlphaAA : public FragmentTexBlendMode {
 546  public:
 547   FragmentShaderRGBATexAlphaAA();
 548
 549   void Init(gpu::gles2::GLES2Interface* context,
 550             unsigned program,
 551             int* base_uniform_index);
 552   std::string GetShaderString(
 553       TexCoordPrecision precision, SamplerType sampler) const;
 554   static std::string GetShaderHead();
 555   static std::string GetShaderBody();
 556   void FillLocations(ShaderLocations* locations) const;
 557
 558   int alpha_location() const { return alpha_location_; }
 559   int sampler_location() const { return sampler_location_; }
 560
 561  private:
 562   int sampler_location_;
 563   int alpha_location_;
 564
 565   DISALLOW_COPY_AND_ASSIGN(FragmentShaderRGBATexAlphaAA);
 566 };
 567
 568 class FragmentTexClampAlphaAABinding : public FragmentTexBlendMode {
 569  public:
 570   FragmentTexClampAlphaAABinding();
 571
 572   void Init(gpu::gles2::GLES2Interface* context,
 573             unsigned program,
 574             int* base_uniform_index);
 575   int alpha_location() const { return alpha_location_; }
 576   int sampler_location() const { return sampler_location_; }
 577   int fragment_tex_transform_location() const {
 578     return fragment_tex_transform_location_;
 579   }
 580
 581  private:
 582   int sampler_location_;
 583   int alpha_location_;
 584   int fragment_tex_transform_location_;
 585
 586   DISALLOW_COPY_AND_ASSIGN(FragmentTexClampAlphaAABinding);
 587 };
 588
 589 class FragmentShaderRGBATexClampAlphaAA
 590     : public FragmentTexClampAlphaAABinding {
 591  public:
 592   std::string GetShaderString(
 593       TexCoordPrecision precision, SamplerType sampler) const;
 594   static std::string GetShaderHead();
 595   static std::string GetShaderBody();
 596 };
 597
 598 // Swizzles the red and blue component of sampled texel.
 599 class FragmentShaderRGBATexClampSwizzleAlphaAA
 600     : public FragmentTexClampAlphaAABinding {
 601  public:
 602   std::string GetShaderString(
 603       TexCoordPrecision precision, SamplerType sampler) const;
 604   static std::string GetShaderHead();
 605   static std::string GetShaderBody();
 606 };
 607
 608 class FragmentShaderRGBATexAlphaMask : public FragmentTexBlendMode {
 609  public:
 610   FragmentShaderRGBATexAlphaMask();
 611   std::string GetShaderString(
 612       TexCoordPrecision precision, SamplerType sampler) const;
 613   static std::string GetShaderHead();
 614   static std::string GetShaderBody();
 615   void FillLocations(ShaderLocations* locations) const;
 616   void Init(gpu::gles2::GLES2Interface* context,
 617             unsigned program,
 618             int* base_uniform_index);
 619   int alpha_location() const { return alpha_location_; }
 620   int sampler_location() const { return sampler_location_; }
 621   int mask_sampler_location() const { return mask_sampler_location_; }
 622   int mask_tex_coord_scale_location() const {
 623     return mask_tex_coord_scale_location_;
 624   }
 625   int mask_tex_coord_offset_location() const {
 626     return mask_tex_coord_offset_location_;
 627   }
 628
 629  private:
 630   int sampler_location_;
 631   int mask_sampler_location_;
 632   int alpha_location_;
 633   int mask_tex_coord_scale_location_;
 634   int mask_tex_coord_offset_location_;
 635
 636   DISALLOW_COPY_AND_ASSIGN(FragmentShaderRGBATexAlphaMask);
 637 };
 638
 639 class FragmentShaderRGBATexAlphaMaskAA : public FragmentTexBlendMode {
 640  public:
 641   FragmentShaderRGBATexAlphaMaskAA();
 642   std::string GetShaderString(
 643       TexCoordPrecision precision, SamplerType sampler) const;
 644   static std::string GetShaderHead();
 645   static std::string GetShaderBody();
 646   void FillLocations(ShaderLocations* locations) const;
 647   void Init(gpu::gles2::GLES2Interface* context,
 648             unsigned program,
 649             int* base_uniform_index);
 650   int alpha_location() const { return alpha_location_; }
 651   int sampler_location() const { return sampler_location_; }
 652   int mask_sampler_location() const { return mask_sampler_location_; }
 653   int mask_tex_coord_scale_location() const {
 654     return mask_tex_coord_scale_location_;
 655   }
 656   int mask_tex_coord_offset_location() const {
 657     return mask_tex_coord_offset_location_;
 658   }
 659
 660  private:
 661   int sampler_location_;
 662   int mask_sampler_location_;
 663   int alpha_location_;
 664   int mask_tex_coord_scale_location_;
 665   int mask_tex_coord_offset_location_;
 666
 667   DISALLOW_COPY_AND_ASSIGN(FragmentShaderRGBATexAlphaMaskAA);
 668 };
 669
 670 class FragmentShaderRGBATexAlphaMaskColorMatrixAA
 671     : public FragmentTexBlendMode {
 672  public:
 673   FragmentShaderRGBATexAlphaMaskColorMatrixAA();
 674   std::string GetShaderString(
 675       TexCoordPrecision precision, SamplerType sampler) const;
 676   static std::string GetShaderHead();
 677   static std::string GetShaderBody();
 678   void FillLocations(ShaderLocations* locations) const;
 679   void Init(gpu::gles2::GLES2Interface* context,
 680             unsigned program,
 681             int* base_uniform_index);
 682   int alpha_location() const { return alpha_location_; }
 683   int sampler_location() const { return sampler_location_; }
 684   int mask_sampler_location() const { return mask_sampler_location_; }
 685   int mask_tex_coord_scale_location() const {
 686     return mask_tex_coord_scale_location_;
 687   }
 688   int mask_tex_coord_offset_location() const {
 689     return mask_tex_coord_offset_location_;
 690   }
 691   int color_matrix_location() const { return color_matrix_location_; }
 692   int color_offset_location() const { return color_offset_location_; }
 693
 694  private:
 695   int sampler_location_;
 696   int mask_sampler_location_;
 697   int alpha_location_;
 698   int mask_tex_coord_scale_location_;
 699   int mask_tex_coord_offset_location_;
 700   int color_matrix_location_;
 701   int color_offset_location_;
 702 };
 703
 704 class FragmentShaderRGBATexAlphaColorMatrixAA : public FragmentTexBlendMode {
 705  public:
 706   FragmentShaderRGBATexAlphaColorMatrixAA();
 707   std::string GetShaderString(
 708       TexCoordPrecision precision, SamplerType sampler) const;
 709   static std::string GetShaderHead();
 710   static std::string GetShaderBody();
 711   void FillLocations(ShaderLocations* locations) const;
 712   void Init(gpu::gles2::GLES2Interface* context,
 713             unsigned program,
 714             int* base_uniform_index);
 715   int alpha_location() const { return alpha_location_; }
 716   int sampler_location() const { return sampler_location_; }
 717   int color_matrix_location() const { return color_matrix_location_; }
 718   int color_offset_location() const { return color_offset_location_; }
 719
 720  private:
 721   int sampler_location_;
 722   int alpha_location_;
 723   int color_matrix_location_;
 724   int color_offset_location_;
 725 };
 726
 727 class FragmentShaderRGBATexAlphaMaskColorMatrix : public FragmentTexBlendMode {
 728  public:
 729   FragmentShaderRGBATexAlphaMaskColorMatrix();
 730   std::string GetShaderString(
 731       TexCoordPrecision precision, SamplerType sampler) const;
 732   static std::string GetShaderHead();
 733   static std::string GetShaderBody();
 734   void FillLocations(ShaderLocations* locations) const;
 735   void Init(gpu::gles2::GLES2Interface* context,
 736             unsigned program,
 737             int* base_uniform_index);
 738   int alpha_location() const { return alpha_location_; }
 739   int sampler_location() const { return sampler_location_; }
 740   int mask_sampler_location() const { return mask_sampler_location_; }
 741   int mask_tex_coord_scale_location() const {
 742     return mask_tex_coord_scale_location_;
 743   }
 744   int mask_tex_coord_offset_location() const {
 745     return mask_tex_coord_offset_location_;
 746   }
 747   int color_matrix_location() const { return color_matrix_location_; }
 748   int color_offset_location() const { return color_offset_location_; }
 749
 750  private:
 751   int sampler_location_;
 752   int mask_sampler_location_;
 753   int alpha_location_;
 754   int mask_tex_coord_scale_location_;
 755   int mask_tex_coord_offset_location_;
 756   int color_matrix_location_;
 757   int color_offset_location_;
 758 };
 759
 760 class FragmentShaderYUVVideo : public FragmentTexBlendMode {
 761  public:
 762   FragmentShaderYUVVideo();
 763   std::string GetShaderString(
 764       TexCoordPrecision precision, SamplerType sampler) const;
 765   static std::string GetShaderHead();
 766   static std::string GetShaderBody();
 767
 768   void Init(gpu::gles2::GLES2Interface* context,
 769             unsigned program,
 770             int* base_uniform_index);
 771   int y_texture_location() const { return y_texture_location_; }
 772   int u_texture_location() const { return u_texture_location_; }
 773   int v_texture_location() const { return v_texture_location_; }
 774   int alpha_location() const { return alpha_location_; }
 775   int yuv_matrix_location() const { return yuv_matrix_location_; }
 776   int yuv_adj_location() const { return yuv_adj_location_; }
 777   int ya_clamp_rect_location() const { return ya_clamp_rect_location_; }
 778   int uv_clamp_rect_location() const { return uv_clamp_rect_location_; }
 779
 780  private:
 781   int y_texture_location_;
 782   int u_texture_location_;
 783   int v_texture_location_;
 784   int alpha_location_;
 785   int yuv_matrix_location_;
 786   int yuv_adj_location_;
 787   int ya_clamp_rect_location_;
 788   int uv_clamp_rect_location_;
 789
 790   DISALLOW_COPY_AND_ASSIGN(FragmentShaderYUVVideo);
 791 };
 792
 793 class FragmentShaderYUVAVideo : public FragmentTexBlendMode {
 794  public:
 795   FragmentShaderYUVAVideo();
 796   std::string GetShaderString(
 797       TexCoordPrecision precision, SamplerType sampler) const;
 798   static std::string GetShaderHead();
 799   static std::string GetShaderBody();
 800
 801   void Init(gpu::gles2::GLES2Interface* context,
 802             unsigned program,
 803             int* base_uniform_index);
 804
 805   int y_texture_location() const { return y_texture_location_; }
 806   int u_texture_location() const { return u_texture_location_; }
 807   int v_texture_location() const { return v_texture_location_; }
 808   int a_texture_location() const { return a_texture_location_; }
 809   int alpha_location() const { return alpha_location_; }
 810   int yuv_matrix_location() const { return yuv_matrix_location_; }
 811   int yuv_adj_location() const { return yuv_adj_location_; }
 812   int ya_clamp_rect_location() const { return ya_clamp_rect_location_; }
 813   int uv_clamp_rect_location() const { return uv_clamp_rect_location_; }
 814
 815  private:
 816   int y_texture_location_;
 817   int u_texture_location_;
 818   int v_texture_location_;
 819   int a_texture_location_;
 820   int alpha_location_;
 821   int yuv_matrix_location_;
 822   int yuv_adj_location_;
 823   int ya_clamp_rect_location_;
 824   int uv_clamp_rect_location_;
 825
 826   DISALLOW_COPY_AND_ASSIGN(FragmentShaderYUVAVideo);
 827 };
 828
 829 class FragmentShaderColor : public FragmentTexBlendMode {
 830  public:
 831   FragmentShaderColor();
 832   std::string GetShaderString(
 833       TexCoordPrecision precision, SamplerType sampler) const;
 834   static std::string GetShaderHead();
 835   static std::string GetShaderBody();
 836
 837   void Init(gpu::gles2::GLES2Interface* context,
 838             unsigned program,
 839             int* base_uniform_index);
 840   int color_location() const { return color_location_; }
 841
 842  private:
 843   int color_location_;
 844
 845   DISALLOW_COPY_AND_ASSIGN(FragmentShaderColor);
 846 };
 847
 848 class FragmentShaderColorAA : public FragmentTexBlendMode {
 849  public:
 850   FragmentShaderColorAA();
 851   std::string GetShaderString(
 852       TexCoordPrecision precision, SamplerType sampler) const;
 853   static std::string GetShaderHead();
 854   static std::string GetShaderBody();
 855
 856   void Init(gpu::gles2::GLES2Interface* context,
 857             unsigned program,
 858             int* base_uniform_index);
 859   int color_location() const { return color_location_; }
 860
 861  private:
 862   int color_location_;
 863
 864   DISALLOW_COPY_AND_ASSIGN(FragmentShaderColorAA);
 865 };
 866
 867 class FragmentShaderCheckerboard : public FragmentTexBlendMode {
 868  public:
 869   FragmentShaderCheckerboard();
 870   std::string GetShaderString(
 871       TexCoordPrecision precision, SamplerType sampler) const;
 872   static std::string GetShaderHead();
 873   static std::string GetShaderBody();
 874
 875   void Init(gpu::gles2::GLES2Interface* context,
 876             unsigned program,
 877             int* base_uniform_index);
 878   int alpha_location() const { return alpha_location_; }
 879   int tex_transform_location() const { return tex_transform_location_; }
 880   int frequency_location() const { return frequency_location_; }
 881   int color_location() const { return color_location_; }
 882
 883  private:
 884   int alpha_location_;
 885   int tex_transform_location_;
 886   int frequency_location_;
 887   int color_location_;
 888
 889   DISALLOW_COPY_AND_ASSIGN(FragmentShaderCheckerboard);
 890 };
 891
 892 }  // namespace cc
 893
 894 #endif  // CC_OUTPUT_SHADER_H_