cc/output/shader.cc

   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 #include "cc/output/shader.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/basictypes.h"
  10 #include "base/logging.h"
  11 #include "cc/output/gl_renderer.h"  // For the GLC() macro.
  12 #include "gpu/command_buffer/client/gles2_interface.h"
  13
  14 #define SHADER0(Src) #Src
  15 #define VERTEX_SHADER(Src) SetVertexTexCoordPrecision(SHADER0(Src))
  16 #define FRAGMENT_SHADER(Src) SetFragmentTexCoordPrecision( \
  17     precision, SetFragmentSamplerType(sampler, SHADER0(Src)))
  18
  19 using gpu::gles2::GLES2Interface;
  20
  21 namespace cc {
  22
  23 namespace {
  24
  25 static void GetProgramUniformLocations(GLES2Interface* context,
  26                                        unsigned program,
  27                                        size_t count,
  28                                        const char** uniforms,
  29                                        int* locations,
  30                                        int* base_uniform_index) {
  31   for (size_t i = 0; i < count; i++) {
  32     locations[i] = (*base_uniform_index)++;
  33     context->BindUniformLocationCHROMIUM(program, locations[i], uniforms[i]);
  34   }
  35 }
  36
  37 static std::string SetFragmentTexCoordPrecision(
  38     TexCoordPrecision requested_precision, std::string shader_string) {
  39   switch (requested_precision) {
  40     case TexCoordPrecisionHigh:
  41       DCHECK_NE(shader_string.find("TexCoordPrecision"), std::string::npos);
  42       return
  43           "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
  44           "  #define TexCoordPrecision highp\n"
  45           "#else\n"
  46           "  #define TexCoordPrecision mediump\n"
  47           "#endif\n" +
  48           shader_string;
  49     case TexCoordPrecisionMedium:
  50       DCHECK_NE(shader_string.find("TexCoordPrecision"), std::string::npos);
  51       return "#define TexCoordPrecision mediump\n" +
  52           shader_string;
  53     case TexCoordPrecisionNA:
  54       DCHECK_EQ(shader_string.find("TexCoordPrecision"), std::string::npos);
  55       DCHECK_EQ(shader_string.find("texture2D"), std::string::npos);
  56       DCHECK_EQ(shader_string.find("texture2DRect"), std::string::npos);
  57       return shader_string;
  58     default:
  59       NOTREACHED();
  60       break;
  61   }
  62   return shader_string;
  63 }
  64
  65 static std::string SetVertexTexCoordPrecision(const char* shader_string) {
  66   // We unconditionally use highp in the vertex shader since
  67   // we are unlikely to be vertex shader bound when drawing large quads.
  68   // Also, some vertex shaders mutate the texture coordinate in such a
  69   // way that the effective precision might be lower than expected.
  70   return "#define TexCoordPrecision highp\n" +
  71       std::string(shader_string);
  72 }
  73
  74 TexCoordPrecision TexCoordPrecisionRequired(GLES2Interface* context,
  75                                             int *highp_threshold_cache,
  76                                             int highp_threshold_min,
  77                                             int x, int y) {
  78   if (*highp_threshold_cache == 0) {
  79     // Initialize range and precision with minimum spec values for when
  80     // GetShaderPrecisionFormat is a test stub.
  81     // TODO(brianderson): Implement better stubs of GetShaderPrecisionFormat
  82     // everywhere.
  83     GLint range[2] = { 14, 14 };
  84     GLint precision = 10;
  85     GLC(context, context->GetShaderPrecisionFormat(GL_FRAGMENT_SHADER,
  86                                                    GL_MEDIUM_FLOAT,
  87                                                    range, &precision));
  88     *highp_threshold_cache = 1 << precision;
  89   }
  90
  91   int highp_threshold = std::max(*highp_threshold_cache, highp_threshold_min);
  92   if (x > highp_threshold || y > highp_threshold)
  93     return TexCoordPrecisionHigh;
  94   return TexCoordPrecisionMedium;
  95 }
  96
  97 static std::string SetFragmentSamplerType(
  98     SamplerType requested_type, std::string shader_string) {
  99   switch (requested_type) {
 100     case SamplerType2D:
 101       DCHECK_NE(shader_string.find("SamplerType"), std::string::npos);
 102       DCHECK_NE(shader_string.find("TextureLookup"), std::string::npos);
 103       return
 104           "#define SamplerType sampler2D\n"
 105           "#define TextureLookup texture2D\n" +
 106           shader_string;
 107     case SamplerType2DRect:
 108       DCHECK_NE(shader_string.find("SamplerType"), std::string::npos);
 109       DCHECK_NE(shader_string.find("TextureLookup"), std::string::npos);
 110       return
 111           "#extension GL_ARB_texture_rectangle : require\n"
 112           "#define SamplerType sampler2DRect\n"
 113           "#define TextureLookup texture2DRect\n" +
 114           shader_string;
 115     case SamplerTypeExternalOES:
 116       DCHECK_NE(shader_string.find("SamplerType"), std::string::npos);
 117       DCHECK_NE(shader_string.find("TextureLookup"), std::string::npos);
 118       return
 119           "#extension GL_OES_EGL_image_external : require\n"
 120           "#define SamplerType samplerExternalOES\n"
 121           "#define TextureLookup texture2D\n" +
 122           shader_string;
 123     case SamplerTypeNA:
 124       DCHECK_EQ(shader_string.find("SamplerType"), std::string::npos);
 125       DCHECK_EQ(shader_string.find("TextureLookup"), std::string::npos);
 126       return shader_string;
 127     default:
 128       NOTREACHED();
 129       break;
 130   }
 131   return shader_string;
 132 }
 133
 134 }  // namespace
 135
 136 TexCoordPrecision TexCoordPrecisionRequired(GLES2Interface* context,
 137                                             int* highp_threshold_cache,
 138                                             int highp_threshold_min,
 139                                             const gfx::Point& max_coordinate) {
 140   return TexCoordPrecisionRequired(context,
 141                                    highp_threshold_cache, highp_threshold_min,
 142                                    max_coordinate.x(), max_coordinate.y());
 143 }
 144
 145 TexCoordPrecision TexCoordPrecisionRequired(GLES2Interface* context,
 146                                             int *highp_threshold_cache,
 147                                             int highp_threshold_min,
 148                                             const gfx::Size& max_size) {
 149   return TexCoordPrecisionRequired(context,
 150                                    highp_threshold_cache, highp_threshold_min,
 151                                    max_size.width(), max_size.height());
 152 }
 153
 154 VertexShaderPosTex::VertexShaderPosTex()
 155       : matrix_location_(-1) {}
 156
 157 void VertexShaderPosTex::Init(GLES2Interface* context,
 158                               unsigned program,
 159                               int* base_uniform_index) {
 160   static const char* uniforms[] = {
 161       "matrix",
 162   };
 163   int locations[arraysize(uniforms)];
 164
 165   GetProgramUniformLocations(context,
 166                              program,
 167                              arraysize(uniforms),
 168                              uniforms,
 169                              locations,
 170                              base_uniform_index);
 171   matrix_location_ = locations[0];
 172 }
 173
 174 std::string VertexShaderPosTex::GetShaderString() const {
 175   return VERTEX_SHADER(
 176     attribute vec4 a_position;
 177     attribute TexCoordPrecision vec2 a_texCoord;
 178     uniform mat4 matrix;
 179     varying TexCoordPrecision vec2 v_texCoord;
 180     void main() {
 181       gl_Position = matrix * a_position;
 182       v_texCoord = a_texCoord;
 183     }
 184   );  // NOLINT(whitespace/parens)
 185 }
 186
 187 VertexShaderPosTexYUVStretchOffset::VertexShaderPosTexYUVStretchOffset()
 188     : matrix_location_(-1), tex_scale_location_(-1), tex_offset_location_(-1) {}
 189
 190 void VertexShaderPosTexYUVStretchOffset::Init(GLES2Interface* context,
 191                                               unsigned program,
 192                                               int* base_uniform_index) {
 193   static const char* uniforms[] = {
 194     "matrix",
 195     "texScale",
 196     "texOffset",
 197   };
 198   int locations[arraysize(uniforms)];
 199
 200   GetProgramUniformLocations(context,
 201                              program,
 202                              arraysize(uniforms),
 203                              uniforms,
 204                              locations,
 205                              base_uniform_index);
 206   matrix_location_ = locations[0];
 207   tex_scale_location_ = locations[1];
 208   tex_offset_location_ = locations[2];
 209 }
 210
 211 std::string VertexShaderPosTexYUVStretchOffset::GetShaderString() const {
 212   return VERTEX_SHADER(
 213     precision mediump float;
 214     attribute vec4 a_position;
 215     attribute TexCoordPrecision vec2 a_texCoord;
 216     uniform mat4 matrix;
 217     varying TexCoordPrecision vec2 v_texCoord;
 218     uniform TexCoordPrecision vec2 texScale;
 219     uniform TexCoordPrecision vec2 texOffset;
 220     void main() {
 221         gl_Position = matrix * a_position;
 222         v_texCoord = a_texCoord * texScale + texOffset;
 223     }
 224   );  // NOLINT(whitespace/parens)
 225 }
 226
 227 VertexShaderPos::VertexShaderPos()
 228     : matrix_location_(-1) {}
 229
 230 void VertexShaderPos::Init(GLES2Interface* context,
 231                            unsigned program,
 232                            int* base_uniform_index) {
 233   static const char* uniforms[] = {
 234       "matrix",
 235   };
 236   int locations[arraysize(uniforms)];
 237
 238   GetProgramUniformLocations(context,
 239                              program,
 240                              arraysize(uniforms),
 241                              uniforms,
 242                              locations,
 243                              base_uniform_index);
 244   matrix_location_ = locations[0];
 245 }
 246
 247 std::string VertexShaderPos::GetShaderString() const {
 248   return VERTEX_SHADER(
 249     attribute vec4 a_position;
 250     uniform mat4 matrix;
 251     void main() {
 252         gl_Position = matrix * a_position;
 253     }
 254   );  // NOLINT(whitespace/parens)
 255 }
 256
 257 VertexShaderPosTexTransform::VertexShaderPosTexTransform()
 258     : matrix_location_(-1),
 259       tex_transform_location_(-1),
 260       vertex_opacity_location_(-1) {}
 261
 262 void VertexShaderPosTexTransform::Init(GLES2Interface* context,
 263                                        unsigned program,
 264                                        int* base_uniform_index) {
 265   static const char* uniforms[] = {
 266     "matrix",
 267     "texTransform",
 268     "opacity",
 269   };
 270   int locations[arraysize(uniforms)];
 271
 272   GetProgramUniformLocations(context,
 273                              program,
 274                              arraysize(uniforms),
 275                              uniforms,
 276                              locations,
 277                              base_uniform_index);
 278   matrix_location_ = locations[0];
 279   tex_transform_location_ = locations[1];
 280   vertex_opacity_location_ = locations[2];
 281 }
 282
 283 std::string VertexShaderPosTexTransform::GetShaderString() const {
 284   return VERTEX_SHADER(
 285     attribute vec4 a_position;
 286     attribute TexCoordPrecision vec2 a_texCoord;
 287     attribute float a_index;
 288     uniform mat4 matrix[8];
 289     uniform TexCoordPrecision vec4 texTransform[8];
 290     uniform float opacity[32];
 291     varying TexCoordPrecision vec2 v_texCoord;
 292     varying float v_alpha;
 293     void main() {
 294       int quad_index = int(a_index * 0.25);  // NOLINT
 295       gl_Position = matrix[quad_index] * a_position;
 296       TexCoordPrecision vec4 texTrans = texTransform[quad_index];
 297       v_texCoord = a_texCoord * texTrans.zw + texTrans.xy;
 298       v_alpha = opacity[int(a_index)]; // NOLINT
 299     }
 300   );  // NOLINT(whitespace/parens)
 301 }
 302
 303 std::string VertexShaderPosTexIdentity::GetShaderString() const {
 304   return VERTEX_SHADER(
 305     attribute vec4 a_position;
 306     varying TexCoordPrecision vec2 v_texCoord;
 307     void main() {
 308       gl_Position = a_position;
 309       v_texCoord = (a_position.xy + vec2(1.0)) * 0.5;
 310     }
 311   );  // NOLINT(whitespace/parens)
 312 }
 313
 314 VertexShaderQuad::VertexShaderQuad()
 315     : matrix_location_(-1),
 316       quad_location_(-1) {}
 317
 318 void VertexShaderQuad::Init(GLES2Interface* context,
 319                             unsigned program,
 320                             int* base_uniform_index) {
 321   static const char* uniforms[] = {
 322     "matrix",
 323     "quad",
 324   };
 325   int locations[arraysize(uniforms)];
 326
 327   GetProgramUniformLocations(context,
 328                              program,
 329                              arraysize(uniforms),
 330                              uniforms,
 331                              locations,
 332                              base_uniform_index);
 333   matrix_location_ = locations[0];
 334   quad_location_ = locations[1];
 335 }
 336
 337 std::string VertexShaderQuad::GetShaderString() const {
 338 #if defined(OS_ANDROID)
 339 // TODO(epenner): Find the cause of this 'quad' uniform
 340 // being missing if we don't add dummy variables.
 341 // http://crbug.com/240602
 342   return VERTEX_SHADER(
 343     attribute TexCoordPrecision vec4 a_position;
 344     attribute float a_index;
 345     uniform mat4 matrix;
 346     uniform TexCoordPrecision vec2 quad[4];
 347     uniform TexCoordPrecision vec2 dummy_uniform;
 348     varying TexCoordPrecision vec2 dummy_varying;
 349     void main() {
 350       vec2 pos = quad[int(a_index)];  // NOLINT
 351       gl_Position = matrix * vec4(pos, a_position.z, a_position.w);
 352       dummy_varying = dummy_uniform;
 353     }
 354   );  // NOLINT(whitespace/parens)
 355 #else
 356   return VERTEX_SHADER(
 357     attribute TexCoordPrecision vec4 a_position;
 358     attribute float a_index;
 359     uniform mat4 matrix;
 360     uniform TexCoordPrecision vec2 quad[4];
 361     void main() {
 362       vec2 pos = quad[int(a_index)];  // NOLINT
 363       gl_Position = matrix * vec4(pos, a_position.z, a_position.w);
 364     }
 365   );  // NOLINT(whitespace/parens)
 366 #endif
 367 }
 368
 369 VertexShaderQuadAA::VertexShaderQuadAA()
 370     : matrix_location_(-1),
 371       viewport_location_(-1),
 372       quad_location_(-1),
 373       edge_location_(-1) {}
 374
 375 void VertexShaderQuadAA::Init(GLES2Interface* context,
 376                             unsigned program,
 377                             int* base_uniform_index) {
 378   static const char* uniforms[] = {
 379     "matrix",
 380     "viewport",
 381     "quad",
 382     "edge",
 383   };
 384   int locations[arraysize(uniforms)];
 385
 386   GetProgramUniformLocations(context,
 387                              program,
 388                              arraysize(uniforms),
 389                              uniforms,
 390                              locations,
 391                              base_uniform_index);
 392   matrix_location_ = locations[0];
 393   viewport_location_ = locations[1];
 394   quad_location_ = locations[2];
 395   edge_location_ = locations[3];
 396 }
 397
 398 std::string VertexShaderQuadAA::GetShaderString() const {
 399   return VERTEX_SHADER(
 400     attribute TexCoordPrecision vec4 a_position;
 401     attribute float a_index;
 402     uniform mat4 matrix;
 403     uniform vec4 viewport;
 404     uniform TexCoordPrecision vec2 quad[4];
 405     uniform TexCoordPrecision vec3 edge[8];
 406     varying TexCoordPrecision vec4 edge_dist[2];  // 8 edge distances.
 407
 408     void main() {
 409       vec2 pos = quad[int(a_index)];  // NOLINT
 410       gl_Position = matrix * vec4(pos, a_position.z, a_position.w);
 411       vec2 ndc_pos = 0.5 * (1.0 + gl_Position.xy / gl_Position.w);
 412       vec3 screen_pos = vec3(viewport.xy + viewport.zw * ndc_pos, 1.0);
 413       edge_dist[0] = vec4(dot(edge[0], screen_pos),
 414                           dot(edge[1], screen_pos),
 415                           dot(edge[2], screen_pos),
 416                           dot(edge[3], screen_pos)) * gl_Position.w;
 417       edge_dist[1] = vec4(dot(edge[4], screen_pos),
 418                           dot(edge[5], screen_pos),
 419                           dot(edge[6], screen_pos),
 420                           dot(edge[7], screen_pos)) * gl_Position.w;
 421     }
 422   );  // NOLINT(whitespace/parens)
 423 }
 424
 425 VertexShaderQuadTexTransformAA::VertexShaderQuadTexTransformAA()
 426     : matrix_location_(-1),
 427       viewport_location_(-1),
 428       quad_location_(-1),
 429       edge_location_(-1),
 430       tex_transform_location_(-1) {}
 431
 432 void VertexShaderQuadTexTransformAA::Init(GLES2Interface* context,
 433                                         unsigned program,
 434                                         int* base_uniform_index) {
 435   static const char* uniforms[] = {
 436     "matrix",
 437     "viewport",
 438     "quad",
 439     "edge",
 440     "texTrans",
 441   };
 442   int locations[arraysize(uniforms)];
 443
 444   GetProgramUniformLocations(context,
 445                              program,
 446                              arraysize(uniforms),
 447                              uniforms,
 448                              locations,
 449                              base_uniform_index);
 450   matrix_location_ = locations[0];
 451   viewport_location_ = locations[1];
 452   quad_location_ = locations[2];
 453   edge_location_ = locations[3];
 454   tex_transform_location_ = locations[4];
 455 }
 456
 457 std::string VertexShaderQuadTexTransformAA::GetShaderString() const {
 458   return VERTEX_SHADER(
 459     attribute TexCoordPrecision vec4 a_position;
 460     attribute float a_index;
 461     uniform mat4 matrix;
 462     uniform vec4 viewport;
 463     uniform TexCoordPrecision vec2 quad[4];
 464     uniform TexCoordPrecision vec3 edge[8];
 465     uniform TexCoordPrecision vec4 texTrans;
 466     varying TexCoordPrecision vec2 v_texCoord;
 467     varying TexCoordPrecision vec4 edge_dist[2];  // 8 edge distances.
 468
 469     void main() {
 470       vec2 pos = quad[int(a_index)];  // NOLINT
 471       gl_Position = matrix * vec4(pos, a_position.z, a_position.w);
 472       vec2 ndc_pos = 0.5 * (1.0 + gl_Position.xy / gl_Position.w);
 473       vec3 screen_pos = vec3(viewport.xy + viewport.zw * ndc_pos, 1.0);
 474       edge_dist[0] = vec4(dot(edge[0], screen_pos),
 475                           dot(edge[1], screen_pos),
 476                           dot(edge[2], screen_pos),
 477                           dot(edge[3], screen_pos)) * gl_Position.w;
 478       edge_dist[1] = vec4(dot(edge[4], screen_pos),
 479                           dot(edge[5], screen_pos),
 480                           dot(edge[6], screen_pos),
 481                           dot(edge[7], screen_pos)) * gl_Position.w;
 482       v_texCoord = (pos.xy + vec2(0.5)) * texTrans.zw + texTrans.xy;
 483     }
 484   );  // NOLINT(whitespace/parens)
 485 }
 486
 487 VertexShaderTile::VertexShaderTile()
 488     : matrix_location_(-1),
 489       quad_location_(-1),
 490       vertex_tex_transform_location_(-1) {}
 491
 492 void VertexShaderTile::Init(GLES2Interface* context,
 493                             unsigned program,
 494                             int* base_uniform_index) {
 495   static const char* uniforms[] = {
 496     "matrix",
 497     "quad",
 498     "vertexTexTransform",
 499   };
 500   int locations[arraysize(uniforms)];
 501
 502   GetProgramUniformLocations(context,
 503                              program,
 504                              arraysize(uniforms),
 505                              uniforms,
 506                              locations,
 507                              base_uniform_index);
 508   matrix_location_ = locations[0];
 509   quad_location_ = locations[1];
 510   vertex_tex_transform_location_ = locations[2];
 511 }
 512
 513 std::string VertexShaderTile::GetShaderString() const {
 514   return VERTEX_SHADER(
 515     attribute TexCoordPrecision vec4 a_position;
 516     attribute float a_index;
 517     uniform mat4 matrix;
 518     uniform TexCoordPrecision vec2 quad[4];
 519     uniform TexCoordPrecision vec4 vertexTexTransform;
 520     varying TexCoordPrecision vec2 v_texCoord;
 521     void main() {
 522       vec2 pos = quad[int(a_index)];  // NOLINT
 523       gl_Position = matrix * vec4(pos, a_position.z, a_position.w);
 524       v_texCoord = pos.xy * vertexTexTransform.zw + vertexTexTransform.xy;
 525     }
 526   );  // NOLINT(whitespace/parens)
 527 }
 528
 529 VertexShaderTileAA::VertexShaderTileAA()
 530     : matrix_location_(-1),
 531       viewport_location_(-1),
 532       quad_location_(-1),
 533       edge_location_(-1),
 534       vertex_tex_transform_location_(-1) {}
 535
 536 void VertexShaderTileAA::Init(GLES2Interface* context,
 537                               unsigned program,
 538                               int* base_uniform_index) {
 539   static const char* uniforms[] = {
 540     "matrix",
 541     "viewport",
 542     "quad",
 543     "edge",
 544     "vertexTexTransform",
 545   };
 546   int locations[arraysize(uniforms)];
 547
 548   GetProgramUniformLocations(context,
 549                              program,
 550                              arraysize(uniforms),
 551                              uniforms,
 552                              locations,
 553                              base_uniform_index);
 554   matrix_location_ = locations[0];
 555   viewport_location_ = locations[1];
 556   quad_location_ = locations[2];
 557   edge_location_ = locations[3];
 558   vertex_tex_transform_location_ = locations[4];
 559 }
 560
 561 std::string VertexShaderTileAA::GetShaderString() const {
 562   return VERTEX_SHADER(
 563     attribute TexCoordPrecision vec4 a_position;
 564     attribute float a_index;
 565     uniform mat4 matrix;
 566     uniform vec4 viewport;
 567     uniform TexCoordPrecision vec2 quad[4];
 568     uniform TexCoordPrecision vec3 edge[8];
 569     uniform TexCoordPrecision vec4 vertexTexTransform;
 570     varying TexCoordPrecision vec2 v_texCoord;
 571     varying TexCoordPrecision vec4 edge_dist[2];  // 8 edge distances.
 572
 573     void main() {
 574       vec2 pos = quad[int(a_index)];  // NOLINT
 575       gl_Position = matrix * vec4(pos, a_position.z, a_position.w);
 576       vec2 ndc_pos = 0.5 * (1.0 + gl_Position.xy / gl_Position.w);
 577       vec3 screen_pos = vec3(viewport.xy + viewport.zw * ndc_pos, 1.0);
 578       edge_dist[0] = vec4(dot(edge[0], screen_pos),
 579                           dot(edge[1], screen_pos),
 580                           dot(edge[2], screen_pos),
 581                           dot(edge[3], screen_pos)) * gl_Position.w;
 582       edge_dist[1] = vec4(dot(edge[4], screen_pos),
 583                           dot(edge[5], screen_pos),
 584                           dot(edge[6], screen_pos),
 585                           dot(edge[7], screen_pos)) * gl_Position.w;
 586       v_texCoord = pos.xy * vertexTexTransform.zw + vertexTexTransform.xy;
 587     }
 588   );  // NOLINT(whitespace/parens)
 589 }
 590
 591 VertexShaderVideoTransform::VertexShaderVideoTransform()
 592     : matrix_location_(-1),
 593       tex_matrix_location_(-1) {}
 594
 595 void VertexShaderVideoTransform::Init(GLES2Interface* context,
 596                                       unsigned program,
 597                                       int* base_uniform_index) {
 598   static const char* uniforms[] = {
 599     "matrix",
 600     "texMatrix",
 601   };
 602   int locations[arraysize(uniforms)];
 603
 604   GetProgramUniformLocations(context,
 605                              program,
 606                              arraysize(uniforms),
 607                              uniforms,
 608                              locations,
 609                              base_uniform_index);
 610   matrix_location_ = locations[0];
 611   tex_matrix_location_ = locations[1];
 612 }
 613
 614 std::string VertexShaderVideoTransform::GetShaderString() const {
 615   return VERTEX_SHADER(
 616     attribute vec4 a_position;
 617     attribute TexCoordPrecision vec2 a_texCoord;
 618     uniform mat4 matrix;
 619     uniform TexCoordPrecision mat4 texMatrix;
 620     varying TexCoordPrecision vec2 v_texCoord;
 621     void main() {
 622         gl_Position = matrix * a_position;
 623         v_texCoord =
 624             vec2(texMatrix * vec4(a_texCoord.x, 1.0 - a_texCoord.y, 0.0, 1.0));
 625     }
 626   );  // NOLINT(whitespace/parens)
 627 }
 628
 629 FragmentTexAlphaBinding::FragmentTexAlphaBinding()
 630     : sampler_location_(-1),
 631       alpha_location_(-1) {}
 632
 633 void FragmentTexAlphaBinding::Init(GLES2Interface* context,
 634                                    unsigned program,
 635                                    int* base_uniform_index) {
 636   static const char* uniforms[] = {
 637     "s_texture",
 638     "alpha",
 639   };
 640   int locations[arraysize(uniforms)];
 641
 642   GetProgramUniformLocations(context,
 643                              program,
 644                              arraysize(uniforms),
 645                              uniforms,
 646                              locations,
 647                              base_uniform_index);
 648   sampler_location_ = locations[0];
 649   alpha_location_ = locations[1];
 650 }
 651
 652 FragmentTexColorMatrixAlphaBinding::FragmentTexColorMatrixAlphaBinding()
 653     : sampler_location_(-1),
 654       alpha_location_(-1),
 655       color_matrix_location_(-1),
 656       color_offset_location_(-1) {}
 657
 658 void FragmentTexColorMatrixAlphaBinding::Init(GLES2Interface* context,
 659                                               unsigned program,
 660                                               int* base_uniform_index) {
 661   static const char* uniforms[] = {
 662     "s_texture",
 663     "alpha",
 664     "colorMatrix",
 665     "colorOffset",
 666   };
 667   int locations[arraysize(uniforms)];
 668
 669   GetProgramUniformLocations(context,
 670                              program,
 671                              arraysize(uniforms),
 672                              uniforms,
 673                              locations,
 674                              base_uniform_index);
 675   sampler_location_ = locations[0];
 676   alpha_location_ = locations[1];
 677   color_matrix_location_ = locations[2];
 678   color_offset_location_ = locations[3];
 679 }
 680
 681 FragmentTexOpaqueBinding::FragmentTexOpaqueBinding()
 682     : sampler_location_(-1) {}
 683
 684 void FragmentTexOpaqueBinding::Init(GLES2Interface* context,
 685                                     unsigned program,
 686                                     int* base_uniform_index) {
 687   static const char* uniforms[] = {
 688     "s_texture",
 689   };
 690   int locations[arraysize(uniforms)];
 691
 692   GetProgramUniformLocations(context,
 693                              program,
 694                              arraysize(uniforms),
 695                              uniforms,
 696                              locations,
 697                              base_uniform_index);
 698   sampler_location_ = locations[0];
 699 }
 700
 701 std::string FragmentShaderRGBATexAlpha::GetShaderString(
 702     TexCoordPrecision precision, SamplerType sampler) const {
 703   return FRAGMENT_SHADER(
 704     precision mediump float;
 705     varying TexCoordPrecision vec2 v_texCoord;
 706     uniform SamplerType s_texture;
 707     uniform float alpha;
 708     void main() {
 709       vec4 texColor = TextureLookup(s_texture, v_texCoord);
 710       gl_FragColor = texColor * alpha;
 711     }
 712   );  // NOLINT(whitespace/parens)
 713 }
 714
 715 std::string FragmentShaderRGBATexColorMatrixAlpha::GetShaderString(
 716     TexCoordPrecision precision, SamplerType sampler) const {
 717   return FRAGMENT_SHADER(
 718     precision mediump float;
 719     varying TexCoordPrecision vec2 v_texCoord;
 720     uniform SamplerType s_texture;
 721     uniform float alpha;
 722     uniform mat4 colorMatrix;
 723     uniform vec4 colorOffset;
 724     void main() {
 725       vec4 texColor = TextureLookup(s_texture, v_texCoord);
 726       float nonZeroAlpha = max(texColor.a, 0.00001);
 727       texColor = vec4(texColor.rgb / nonZeroAlpha, nonZeroAlpha);
 728       texColor = colorMatrix * texColor + colorOffset;
 729       texColor.rgb *= texColor.a;
 730       texColor = clamp(texColor, 0.0, 1.0);
 731       gl_FragColor = texColor * alpha;
 732     }
 733   );  // NOLINT(whitespace/parens)
 734 }
 735
 736 std::string FragmentShaderRGBATexVaryingAlpha::GetShaderString(
 737     TexCoordPrecision precision, SamplerType sampler) const {
 738   return FRAGMENT_SHADER(
 739     precision mediump float;
 740     varying TexCoordPrecision vec2 v_texCoord;
 741     varying float v_alpha;
 742     uniform SamplerType s_texture;
 743     void main() {
 744       vec4 texColor = TextureLookup(s_texture, v_texCoord);
 745       gl_FragColor = texColor * v_alpha;
 746     }
 747   );  // NOLINT(whitespace/parens)
 748 }
 749
 750 std::string FragmentShaderRGBATexPremultiplyAlpha::GetShaderString(
 751     TexCoordPrecision precision, SamplerType sampler) const {
 752   return FRAGMENT_SHADER(
 753     precision mediump float;
 754     varying TexCoordPrecision vec2 v_texCoord;
 755     varying float v_alpha;
 756     uniform SamplerType s_texture;
 757     void main() {
 758       vec4 texColor = TextureLookup(s_texture, v_texCoord);
 759       texColor.rgb *= texColor.a;
 760       gl_FragColor = texColor * v_alpha;
 761     }
 762   );  // NOLINT(whitespace/parens)
 763 }
 764
 765 FragmentTexBackgroundBinding::FragmentTexBackgroundBinding()
 766     : background_color_location_(-1),
 767       sampler_location_(-1) {
 768 }
 769
 770 void FragmentTexBackgroundBinding::Init(GLES2Interface* context,
 771                                         unsigned program,
 772                                         int* base_uniform_index) {
 773   static const char* uniforms[] = {
 774     "s_texture",
 775     "background_color",
 776   };
 777   int locations[arraysize(uniforms)];
 778
 779   GetProgramUniformLocations(context,
 780                              program,
 781                              arraysize(uniforms),
 782                              uniforms,
 783                              locations,
 784                              base_uniform_index);
 785
 786   sampler_location_ = locations[0];
 787   DCHECK_NE(sampler_location_, -1);
 788
 789   background_color_location_ = locations[1];
 790   DCHECK_NE(background_color_location_, -1);
 791 }
 792
 793 std::string FragmentShaderTexBackgroundVaryingAlpha::GetShaderString(
 794     TexCoordPrecision precision, SamplerType sampler) const {
 795   return FRAGMENT_SHADER(
 796     precision mediump float;
 797     varying TexCoordPrecision vec2 v_texCoord;
 798     varying float v_alpha;
 799     uniform vec4 background_color;
 800     uniform SamplerType s_texture;
 801     void main() {
 802       vec4 texColor = TextureLookup(s_texture, v_texCoord);
 803       texColor += background_color * (1.0 - texColor.a);
 804       gl_FragColor = texColor * v_alpha;
 805     }
 806   );  // NOLINT(whitespace/parens)
 807 }
 808
 809 std::string FragmentShaderTexBackgroundPremultiplyAlpha::GetShaderString(
 810     TexCoordPrecision precision, SamplerType sampler) const {
 811   return FRAGMENT_SHADER(
 812     precision mediump float;
 813     varying TexCoordPrecision vec2 v_texCoord;
 814     varying float v_alpha;
 815     uniform vec4 background_color;
 816     uniform SamplerType s_texture;
 817     void main() {
 818       vec4 texColor = TextureLookup(s_texture, v_texCoord);
 819       texColor.rgb *= texColor.a;
 820       texColor += background_color * (1.0 - texColor.a);
 821       gl_FragColor = texColor * v_alpha;
 822     }
 823   );  // NOLINT(whitespace/parens)
 824 }
 825
 826 std::string FragmentShaderRGBATexOpaque::GetShaderString(
 827     TexCoordPrecision precision, SamplerType sampler) const {
 828   return FRAGMENT_SHADER(
 829     precision mediump float;
 830     varying TexCoordPrecision vec2 v_texCoord;
 831     uniform SamplerType s_texture;
 832     void main() {
 833       vec4 texColor = TextureLookup(s_texture, v_texCoord);
 834       gl_FragColor = vec4(texColor.rgb, 1.0);
 835     }
 836   );  // NOLINT(whitespace/parens)
 837 }
 838
 839 std::string FragmentShaderRGBATex::GetShaderString(
 840     TexCoordPrecision precision, SamplerType sampler) const {
 841   return FRAGMENT_SHADER(
 842     precision mediump float;
 843     varying TexCoordPrecision vec2 v_texCoord;
 844     uniform SamplerType s_texture;
 845     void main() {
 846       gl_FragColor = TextureLookup(s_texture, v_texCoord);
 847     }
 848   );  // NOLINT(whitespace/parens)
 849 }
 850
 851 std::string FragmentShaderRGBATexSwizzleAlpha::GetShaderString(
 852     TexCoordPrecision precision, SamplerType sampler) const {
 853   return FRAGMENT_SHADER(
 854     precision mediump float;
 855     varying TexCoordPrecision vec2 v_texCoord;
 856     uniform SamplerType s_texture;
 857     uniform float alpha;
 858     void main() {
 859         vec4 texColor = TextureLookup(s_texture, v_texCoord);
 860         gl_FragColor =
 861             vec4(texColor.z, texColor.y, texColor.x, texColor.w) * alpha;
 862     }
 863   );  // NOLINT(whitespace/parens)
 864 }
 865
 866 std::string FragmentShaderRGBATexSwizzleOpaque::GetShaderString(
 867     TexCoordPrecision precision, SamplerType sampler) const {
 868   return FRAGMENT_SHADER(
 869     precision mediump float;
 870     varying TexCoordPrecision vec2 v_texCoord;
 871     uniform SamplerType s_texture;
 872     void main() {
 873       vec4 texColor = TextureLookup(s_texture, v_texCoord);
 874       gl_FragColor = vec4(texColor.z, texColor.y, texColor.x, 1.0);
 875     }
 876   );  // NOLINT(whitespace/parens)
 877 }
 878
 879 FragmentShaderRGBATexAlphaAA::FragmentShaderRGBATexAlphaAA()
 880     : sampler_location_(-1),
 881       alpha_location_(-1) {}
 882
 883 void FragmentShaderRGBATexAlphaAA::Init(GLES2Interface* context,
 884                                         unsigned program,
 885                                         int* base_uniform_index) {
 886   static const char* uniforms[] = {
 887     "s_texture",
 888     "alpha",
 889   };
 890   int locations[arraysize(uniforms)];
 891
 892   GetProgramUniformLocations(context,
 893                              program,
 894                              arraysize(uniforms),
 895                              uniforms,
 896                              locations,
 897                              base_uniform_index);
 898   sampler_location_ = locations[0];
 899   alpha_location_ = locations[1];
 900 }
 901
 902 std::string FragmentShaderRGBATexAlphaAA::GetShaderString(
 903     TexCoordPrecision precision, SamplerType sampler) const {
 904   return FRAGMENT_SHADER(
 905     precision mediump float;
 906     uniform SamplerType s_texture;
 907     uniform float alpha;
 908     varying TexCoordPrecision vec2 v_texCoord;
 909     varying TexCoordPrecision vec4 edge_dist[2];  // 8 edge distances.
 910
 911     void main() {
 912       vec4 texColor = TextureLookup(s_texture, v_texCoord);
 913       vec4 d4 = min(edge_dist[0], edge_dist[1]);
 914       vec2 d2 = min(d4.xz, d4.yw);
 915       float aa = clamp(gl_FragCoord.w * min(d2.x, d2.y), 0.0, 1.0);
 916       gl_FragColor = texColor * alpha * aa;
 917     }
 918   );  // NOLINT(whitespace/parens)
 919 }
 920
 921 FragmentTexClampAlphaAABinding::FragmentTexClampAlphaAABinding()
 922     : sampler_location_(-1),
 923       alpha_location_(-1),
 924       fragment_tex_transform_location_(-1) {}
 925
 926 void FragmentTexClampAlphaAABinding::Init(GLES2Interface* context,
 927                                           unsigned program,
 928                                           int* base_uniform_index) {
 929   static const char* uniforms[] = {
 930     "s_texture",
 931     "alpha",
 932     "fragmentTexTransform",
 933   };
 934   int locations[arraysize(uniforms)];
 935
 936   GetProgramUniformLocations(context,
 937                              program,
 938                              arraysize(uniforms),
 939                              uniforms,
 940                              locations,
 941                              base_uniform_index);
 942   sampler_location_ = locations[0];
 943   alpha_location_ = locations[1];
 944   fragment_tex_transform_location_ = locations[2];
 945 }
 946
 947 std::string FragmentShaderRGBATexClampAlphaAA::GetShaderString(
 948     TexCoordPrecision precision, SamplerType sampler) const {
 949   return FRAGMENT_SHADER(
 950     precision mediump float;
 951     uniform SamplerType s_texture;
 952     uniform float alpha;
 953     uniform TexCoordPrecision vec4 fragmentTexTransform;
 954     varying TexCoordPrecision vec2 v_texCoord;
 955     varying TexCoordPrecision vec4 edge_dist[2];  // 8 edge distances.
 956
 957     void main() {
 958       TexCoordPrecision vec2 texCoord =
 959           clamp(v_texCoord, 0.0, 1.0) * fragmentTexTransform.zw +
 960           fragmentTexTransform.xy;
 961       vec4 texColor = TextureLookup(s_texture, texCoord);
 962       vec4 d4 = min(edge_dist[0], edge_dist[1]);
 963       vec2 d2 = min(d4.xz, d4.yw);
 964       float aa = clamp(gl_FragCoord.w * min(d2.x, d2.y), 0.0, 1.0);
 965       gl_FragColor = texColor * alpha * aa;
 966     }
 967   );  // NOLINT(whitespace/parens)
 968 }
 969
 970 std::string FragmentShaderRGBATexClampSwizzleAlphaAA::GetShaderString(
 971     TexCoordPrecision precision, SamplerType sampler) const {
 972   return FRAGMENT_SHADER(
 973     precision mediump float;
 974     uniform SamplerType s_texture;
 975     uniform float alpha;
 976     uniform TexCoordPrecision vec4 fragmentTexTransform;
 977     varying TexCoordPrecision vec2 v_texCoord;
 978     varying TexCoordPrecision vec4 edge_dist[2];  // 8 edge distances.
 979
 980     void main() {
 981       TexCoordPrecision vec2 texCoord =
 982           clamp(v_texCoord, 0.0, 1.0) * fragmentTexTransform.zw +
 983           fragmentTexTransform.xy;
 984       vec4 texColor = TextureLookup(s_texture, texCoord);
 985       vec4 d4 = min(edge_dist[0], edge_dist[1]);
 986       vec2 d2 = min(d4.xz, d4.yw);
 987       float aa = clamp(gl_FragCoord.w * min(d2.x, d2.y), 0.0, 1.0);
 988       gl_FragColor = vec4(texColor.z, texColor.y, texColor.x, texColor.w) *
 989           alpha * aa;
 990     }
 991   );  // NOLINT(whitespace/parens)
 992 }
 993
 994 FragmentShaderRGBATexAlphaMask::FragmentShaderRGBATexAlphaMask()
 995     : sampler_location_(-1),
 996       mask_sampler_location_(-1),
 997       alpha_location_(-1),
 998       mask_tex_coord_scale_location_(-1) {}
 999
1000 void FragmentShaderRGBATexAlphaMask::Init(GLES2Interface* context,
1001                                           unsigned program,
1002                                           int* base_uniform_index) {
1003   static const char* uniforms[] = {
1004     "s_texture",
1005     "s_mask",
1006     "alpha",
1007     "maskTexCoordScale",
1008     "maskTexCoordOffset",
1009   };
1010   int locations[arraysize(uniforms)];
1011
1012   GetProgramUniformLocations(context,
1013                              program,
1014                              arraysize(uniforms),
1015                              uniforms,
1016                              locations,
1017                              base_uniform_index);
1018   sampler_location_ = locations[0];
1019   mask_sampler_location_ = locations[1];
1020   alpha_location_ = locations[2];
1021   mask_tex_coord_scale_location_ = locations[3];
1022   mask_tex_coord_offset_location_ = locations[4];
1023 }
1024
1025 std::string FragmentShaderRGBATexAlphaMask::GetShaderString(
1026     TexCoordPrecision precision, SamplerType sampler) const {
1027   return FRAGMENT_SHADER(
1028     precision mediump float;
1029     varying TexCoordPrecision vec2 v_texCoord;
1030     uniform SamplerType s_texture;
1031     uniform SamplerType s_mask;
1032     uniform TexCoordPrecision vec2 maskTexCoordScale;
1033     uniform TexCoordPrecision vec2 maskTexCoordOffset;
1034     uniform float alpha;
1035     void main() {
1036       vec4 texColor = TextureLookup(s_texture, v_texCoord);
1037       TexCoordPrecision vec2 maskTexCoord =
1038           vec2(maskTexCoordOffset.x + v_texCoord.x * maskTexCoordScale.x,
1039                maskTexCoordOffset.y + v_texCoord.y * maskTexCoordScale.y);
1040       vec4 maskColor = TextureLookup(s_mask, maskTexCoord);
1041       gl_FragColor = texColor * alpha * maskColor.w;
1042     }
1043   );  // NOLINT(whitespace/parens)
1044 }
1045
1046 FragmentShaderRGBATexAlphaMaskAA::FragmentShaderRGBATexAlphaMaskAA()
1047     : sampler_location_(-1),
1048       mask_sampler_location_(-1),
1049       alpha_location_(-1),
1050       mask_tex_coord_scale_location_(-1),
1051       mask_tex_coord_offset_location_(-1) {}
1052
1053 void FragmentShaderRGBATexAlphaMaskAA::Init(GLES2Interface* context,
1054                                             unsigned program,
1055                                             int* base_uniform_index) {
1056   static const char* uniforms[] = {
1057     "s_texture",
1058     "s_mask",
1059     "alpha",
1060     "maskTexCoordScale",
1061     "maskTexCoordOffset",
1062   };
1063   int locations[arraysize(uniforms)];
1064
1065   GetProgramUniformLocations(context,
1066                              program,
1067                              arraysize(uniforms),
1068                              uniforms,
1069                              locations,
1070                              base_uniform_index);
1071   sampler_location_ = locations[0];
1072   mask_sampler_location_ = locations[1];
1073   alpha_location_ = locations[2];
1074   mask_tex_coord_scale_location_ = locations[3];
1075   mask_tex_coord_offset_location_ = locations[4];
1076 }
1077
1078 std::string FragmentShaderRGBATexAlphaMaskAA::GetShaderString(
1079     TexCoordPrecision precision, SamplerType sampler) const {
1080   return FRAGMENT_SHADER(
1081     precision mediump float;
1082     uniform SamplerType s_texture;
1083     uniform SamplerType s_mask;
1084     uniform TexCoordPrecision vec2 maskTexCoordScale;
1085     uniform TexCoordPrecision vec2 maskTexCoordOffset;
1086     uniform float alpha;
1087     varying TexCoordPrecision vec2 v_texCoord;
1088     varying TexCoordPrecision vec4 edge_dist[2];  // 8 edge distances.
1089
1090     void main() {
1091       vec4 texColor = TextureLookup(s_texture, v_texCoord);
1092       TexCoordPrecision vec2 maskTexCoord =
1093           vec2(maskTexCoordOffset.x + v_texCoord.x * maskTexCoordScale.x,
1094                maskTexCoordOffset.y + v_texCoord.y * maskTexCoordScale.y);
1095       vec4 maskColor = TextureLookup(s_mask, maskTexCoord);
1096       vec4 d4 = min(edge_dist[0], edge_dist[1]);
1097       vec2 d2 = min(d4.xz, d4.yw);
1098       float aa = clamp(gl_FragCoord.w * min(d2.x, d2.y), 0.0, 1.0);
1099       gl_FragColor = texColor * alpha * maskColor.w * aa;
1100     }
1101   );  // NOLINT(whitespace/parens)
1102 }
1103
1104 FragmentShaderRGBATexAlphaMaskColorMatrixAA::
1105     FragmentShaderRGBATexAlphaMaskColorMatrixAA()
1106         : sampler_location_(-1),
1107           mask_sampler_location_(-1),
1108           alpha_location_(-1),
1109           mask_tex_coord_scale_location_(-1),
1110           color_matrix_location_(-1),
1111           color_offset_location_(-1) {}
1112
1113 void FragmentShaderRGBATexAlphaMaskColorMatrixAA::Init(
1114     GLES2Interface* context,
1115     unsigned program,
1116     int* base_uniform_index) {
1117   static const char* uniforms[] = {
1118     "s_texture",
1119     "s_mask",
1120     "alpha",
1121     "maskTexCoordScale",
1122     "maskTexCoordOffset",
1123     "colorMatrix",
1124     "colorOffset",
1125   };
1126   int locations[arraysize(uniforms)];
1127
1128   GetProgramUniformLocations(context,
1129                              program,
1130                              arraysize(uniforms),
1131                              uniforms,
1132                              locations,
1133                              base_uniform_index);
1134   sampler_location_ = locations[0];
1135   mask_sampler_location_ = locations[1];
1136   alpha_location_ = locations[2];
1137   mask_tex_coord_scale_location_ = locations[3];
1138   mask_tex_coord_offset_location_ = locations[4];
1139   color_matrix_location_ = locations[5];
1140   color_offset_location_ = locations[6];
1141 }
1142
1143 std::string FragmentShaderRGBATexAlphaMaskColorMatrixAA::GetShaderString(
1144     TexCoordPrecision precision, SamplerType sampler) const {
1145   return FRAGMENT_SHADER(
1146     precision mediump float;
1147     uniform SamplerType s_texture;
1148     uniform SamplerType s_mask;
1149     uniform vec2 maskTexCoordScale;
1150     uniform vec2 maskTexCoordOffset;
1151     uniform mat4 colorMatrix;
1152     uniform vec4 colorOffset;
1153     uniform float alpha;
1154     varying TexCoordPrecision vec2 v_texCoord;
1155     varying TexCoordPrecision vec4 edge_dist[2];  // 8 edge distances.
1156
1157     void main() {
1158       vec4 texColor = TextureLookup(s_texture, v_texCoord);
1159       float nonZeroAlpha = max(texColor.a, 0.00001);
1160       texColor = vec4(texColor.rgb / nonZeroAlpha, nonZeroAlpha);
1161       texColor = colorMatrix * texColor + colorOffset;
1162       texColor.rgb *= texColor.a;
1163       texColor = clamp(texColor, 0.0, 1.0);
1164       TexCoordPrecision vec2 maskTexCoord =
1165           vec2(maskTexCoordOffset.x + v_texCoord.x * maskTexCoordScale.x,
1166                maskTexCoordOffset.y + v_texCoord.y * maskTexCoordScale.y);
1167       vec4 maskColor = TextureLookup(s_mask, maskTexCoord);
1168       vec4 d4 = min(edge_dist[0], edge_dist[1]);
1169       vec2 d2 = min(d4.xz, d4.yw);
1170       float aa = clamp(gl_FragCoord.w * min(d2.x, d2.y), 0.0, 1.0);
1171       gl_FragColor = texColor * alpha * maskColor.w * aa;
1172     }
1173   );  // NOLINT(whitespace/parens)
1174 }
1175
1176 FragmentShaderRGBATexAlphaColorMatrixAA::
1177     FragmentShaderRGBATexAlphaColorMatrixAA()
1178         : sampler_location_(-1),
1179           alpha_location_(-1),
1180           color_matrix_location_(-1),
1181           color_offset_location_(-1) {}
1182
1183 void FragmentShaderRGBATexAlphaColorMatrixAA::Init(
1184       GLES2Interface* context,
1185       unsigned program,
1186       int* base_uniform_index) {
1187   static const char* uniforms[] = {
1188     "s_texture",
1189     "alpha",
1190     "colorMatrix",
1191     "colorOffset",
1192   };
1193   int locations[arraysize(uniforms)];
1194
1195   GetProgramUniformLocations(context,
1196                              program,
1197                              arraysize(uniforms),
1198                              uniforms,
1199                              locations,
1200                              base_uniform_index);
1201   sampler_location_ = locations[0];
1202   alpha_location_ = locations[1];
1203   color_matrix_location_ = locations[2];
1204   color_offset_location_ = locations[3];
1205 }
1206
1207 std::string FragmentShaderRGBATexAlphaColorMatrixAA::GetShaderString(
1208     TexCoordPrecision precision, SamplerType sampler) const {
1209   return FRAGMENT_SHADER(
1210     precision mediump float;
1211     uniform SamplerType s_texture;
1212     uniform float alpha;
1213     uniform mat4 colorMatrix;
1214     uniform vec4 colorOffset;
1215     varying TexCoordPrecision vec2 v_texCoord;
1216     varying TexCoordPrecision vec4 edge_dist[2];  // 8 edge distances.
1217
1218     void main() {
1219       vec4 texColor = TextureLookup(s_texture, v_texCoord);
1220       float nonZeroAlpha = max(texColor.a, 0.00001);
1221       texColor = vec4(texColor.rgb / nonZeroAlpha, nonZeroAlpha);
1222       texColor = colorMatrix * texColor + colorOffset;
1223       texColor.rgb *= texColor.a;
1224       texColor = clamp(texColor, 0.0, 1.0);
1225       vec4 d4 = min(edge_dist[0], edge_dist[1]);
1226       vec2 d2 = min(d4.xz, d4.yw);
1227       float aa = clamp(gl_FragCoord.w * min(d2.x, d2.y), 0.0, 1.0);
1228       gl_FragColor = texColor * alpha * aa;
1229     }
1230   );  // NOLINT(whitespace/parens)
1231 }
1232
1233 FragmentShaderRGBATexAlphaMaskColorMatrix::
1234     FragmentShaderRGBATexAlphaMaskColorMatrix()
1235         : sampler_location_(-1),
1236           mask_sampler_location_(-1),
1237           alpha_location_(-1),
1238           mask_tex_coord_scale_location_(-1) {}
1239
1240 void FragmentShaderRGBATexAlphaMaskColorMatrix::Init(
1241     GLES2Interface* context,
1242     unsigned program,
1243     int* base_uniform_index) {
1244   static const char* uniforms[] = {
1245     "s_texture",
1246     "s_mask",
1247     "alpha",
1248     "maskTexCoordScale",
1249     "maskTexCoordOffset",
1250     "colorMatrix",
1251     "colorOffset",
1252   };
1253   int locations[arraysize(uniforms)];
1254
1255   GetProgramUniformLocations(context,
1256                              program,
1257                              arraysize(uniforms),
1258                              uniforms,
1259                              locations,
1260                              base_uniform_index);
1261   sampler_location_ = locations[0];
1262   mask_sampler_location_ = locations[1];
1263   alpha_location_ = locations[2];
1264   mask_tex_coord_scale_location_ = locations[3];
1265   mask_tex_coord_offset_location_ = locations[4];
1266   color_matrix_location_ = locations[5];
1267   color_offset_location_ = locations[6];
1268 }
1269
1270 std::string FragmentShaderRGBATexAlphaMaskColorMatrix::GetShaderString(
1271     TexCoordPrecision precision, SamplerType sampler) const {
1272   return FRAGMENT_SHADER(
1273     precision mediump float;
1274     varying TexCoordPrecision vec2 v_texCoord;
1275     uniform SamplerType s_texture;
1276     uniform SamplerType s_mask;
1277     uniform vec2 maskTexCoordScale;
1278     uniform vec2 maskTexCoordOffset;
1279     uniform mat4 colorMatrix;
1280     uniform vec4 colorOffset;
1281     uniform float alpha;
1282     void main() {
1283       vec4 texColor = TextureLookup(s_texture, v_texCoord);
1284       float nonZeroAlpha = max(texColor.a, 0.00001);
1285       texColor = vec4(texColor.rgb / nonZeroAlpha, nonZeroAlpha);
1286       texColor = colorMatrix * texColor + colorOffset;
1287       texColor.rgb *= texColor.a;
1288       texColor = clamp(texColor, 0.0, 1.0);
1289       TexCoordPrecision vec2 maskTexCoord =
1290           vec2(maskTexCoordOffset.x + v_texCoord.x * maskTexCoordScale.x,
1291                maskTexCoordOffset.y + v_texCoord.y * maskTexCoordScale.y);
1292       vec4 maskColor = TextureLookup(s_mask, maskTexCoord);
1293       gl_FragColor = texColor * alpha * maskColor.w;
1294     }
1295   );  // NOLINT(whitespace/parens)
1296 }
1297
1298 FragmentShaderYUVVideo::FragmentShaderYUVVideo()
1299     : y_texture_location_(-1),
1300       u_texture_location_(-1),
1301       v_texture_location_(-1),
1302       alpha_location_(-1),
1303       yuv_matrix_location_(-1),
1304       yuv_adj_location_(-1) {}
1305
1306 void FragmentShaderYUVVideo::Init(GLES2Interface* context,
1307                                   unsigned program,
1308                                   int* base_uniform_index) {
1309   static const char* uniforms[] = {
1310     "y_texture",
1311     "u_texture",
1312     "v_texture",
1313     "alpha",
1314     "yuv_matrix",
1315     "yuv_adj",
1316   };
1317   int locations[arraysize(uniforms)];
1318
1319   GetProgramUniformLocations(context,
1320                              program,
1321                              arraysize(uniforms),
1322                              uniforms,
1323                              locations,
1324                              base_uniform_index);
1325   y_texture_location_ = locations[0];
1326   u_texture_location_ = locations[1];
1327   v_texture_location_ = locations[2];
1328   alpha_location_ = locations[3];
1329   yuv_matrix_location_ = locations[4];
1330   yuv_adj_location_ = locations[5];
1331 }
1332
1333 std::string FragmentShaderYUVVideo::GetShaderString(
1334     TexCoordPrecision precision, SamplerType sampler) const {
1335   return FRAGMENT_SHADER(
1336     precision mediump float;
1337     precision mediump int;
1338     varying TexCoordPrecision vec2 v_texCoord;
1339     uniform SamplerType y_texture;
1340     uniform SamplerType u_texture;
1341     uniform SamplerType v_texture;
1342     uniform float alpha;
1343     uniform vec3 yuv_adj;
1344     uniform mat3 yuv_matrix;
1345     void main() {
1346       float y_raw = TextureLookup(y_texture, v_texCoord).x;
1347       float u_unsigned = TextureLookup(u_texture, v_texCoord).x;
1348       float v_unsigned = TextureLookup(v_texture, v_texCoord).x;
1349       vec3 yuv = vec3(y_raw, u_unsigned, v_unsigned) + yuv_adj;
1350       vec3 rgb = yuv_matrix * yuv;
1351       gl_FragColor = vec4(rgb, 1.0) * alpha;
1352     }
1353   );  // NOLINT(whitespace/parens)
1354 }
1355
1356 FragmentShaderYUVAVideo::FragmentShaderYUVAVideo()
1357     : y_texture_location_(-1),
1358       u_texture_location_(-1),
1359       v_texture_location_(-1),
1360       a_texture_location_(-1),
1361       alpha_location_(-1),
1362       yuv_matrix_location_(-1),
1363       yuv_adj_location_(-1) {
1364 }
1365
1366 void FragmentShaderYUVAVideo::Init(GLES2Interface* context,
1367                                    unsigned program,
1368                                    int* base_uniform_index) {
1369   static const char* uniforms[] = {
1370       "y_texture",
1371       "u_texture",
1372       "v_texture",
1373       "a_texture",
1374       "alpha",
1375       "cc_matrix",
1376       "yuv_adj",
1377   };
1378   int locations[arraysize(uniforms)];
1379
1380   GetProgramUniformLocations(context,
1381                              program,
1382                              arraysize(uniforms),
1383                              uniforms,
1384                              locations,
1385                              base_uniform_index);
1386   y_texture_location_ = locations[0];
1387   u_texture_location_ = locations[1];
1388   v_texture_location_ = locations[2];
1389   a_texture_location_ = locations[3];
1390   alpha_location_ = locations[4];
1391   yuv_matrix_location_ = locations[5];
1392   yuv_adj_location_ = locations[6];
1393 }
1394
1395 std::string FragmentShaderYUVAVideo::GetShaderString(
1396     TexCoordPrecision precision, SamplerType sampler) const {
1397   return FRAGMENT_SHADER(
1398     precision mediump float;
1399     precision mediump int;
1400     varying TexCoordPrecision vec2 v_texCoord;
1401     uniform SamplerType y_texture;
1402     uniform SamplerType u_texture;
1403     uniform SamplerType v_texture;
1404     uniform SamplerType a_texture;
1405     uniform float alpha;
1406     uniform vec3 yuv_adj;
1407     uniform mat3 yuv_matrix;
1408     void main() {
1409       float y_raw = TextureLookup(y_texture, v_texCoord).x;
1410       float u_unsigned = TextureLookup(u_texture, v_texCoord).x;
1411       float v_unsigned = TextureLookup(v_texture, v_texCoord).x;
1412       float a_raw = TextureLookup(a_texture, v_texCoord).x;
1413       vec3 yuv = vec3(y_raw, u_unsigned, v_unsigned) + yuv_adj;
1414       vec3 rgb = yuv_matrix * yuv;
1415       gl_FragColor = vec4(rgb, 1.0) * (alpha * a_raw);
1416     }
1417   );  // NOLINT(whitespace/parens)
1418 }
1419
1420 FragmentShaderColor::FragmentShaderColor()
1421     : color_location_(-1) {}
1422
1423 void FragmentShaderColor::Init(GLES2Interface* context,
1424                                unsigned program,
1425                                int* base_uniform_index) {
1426   static const char* uniforms[] = {
1427     "color",
1428   };
1429   int locations[arraysize(uniforms)];
1430
1431   GetProgramUniformLocations(context,
1432                              program,
1433                              arraysize(uniforms),
1434                              uniforms,
1435                              locations,
1436                              base_uniform_index);
1437   color_location_ = locations[0];
1438 }
1439
1440 std::string FragmentShaderColor::GetShaderString(
1441     TexCoordPrecision precision, SamplerType sampler) const {
1442   return FRAGMENT_SHADER(
1443     precision mediump float;
1444     uniform vec4 color;
1445     void main() {
1446       gl_FragColor = color;
1447     }
1448   );  // NOLINT(whitespace/parens)
1449 }
1450
1451 FragmentShaderColorAA::FragmentShaderColorAA()
1452     : color_location_(-1) {}
1453
1454 void FragmentShaderColorAA::Init(GLES2Interface* context,
1455                                  unsigned program,
1456                                  int* base_uniform_index) {
1457   static const char* uniforms[] = {
1458     "color",
1459   };
1460   int locations[arraysize(uniforms)];
1461
1462   GetProgramUniformLocations(context,
1463                              program,
1464                              arraysize(uniforms),
1465                              uniforms,
1466                              locations,
1467                              base_uniform_index);
1468   color_location_ = locations[0];
1469 }
1470
1471 std::string FragmentShaderColorAA::GetShaderString(
1472     TexCoordPrecision precision, SamplerType sampler) const {
1473   return FRAGMENT_SHADER(
1474     precision mediump float;
1475     uniform vec4 color;
1476     varying vec4 edge_dist[2];  // 8 edge distances.
1477
1478     void main() {
1479       vec4 d4 = min(edge_dist[0], edge_dist[1]);
1480       vec2 d2 = min(d4.xz, d4.yw);
1481       float aa = clamp(gl_FragCoord.w * min(d2.x, d2.y), 0.0, 1.0);
1482       gl_FragColor = color * aa;
1483     }
1484   );  // NOLINT(whitespace/parens)
1485 }
1486
1487 FragmentShaderCheckerboard::FragmentShaderCheckerboard()
1488     : alpha_location_(-1),
1489       tex_transform_location_(-1),
1490       frequency_location_(-1) {}
1491
1492 void FragmentShaderCheckerboard::Init(GLES2Interface* context,
1493                                       unsigned program,
1494                                       int* base_uniform_index) {
1495   static const char* uniforms[] = {
1496     "alpha",
1497     "texTransform",
1498     "frequency",
1499     "color",
1500   };
1501   int locations[arraysize(uniforms)];
1502
1503   GetProgramUniformLocations(context,
1504                              program,
1505                              arraysize(uniforms),
1506                              uniforms,
1507                              locations,
1508                              base_uniform_index);
1509   alpha_location_ = locations[0];
1510   tex_transform_location_ = locations[1];
1511   frequency_location_ = locations[2];
1512   color_location_ = locations[3];
1513 }
1514
1515 std::string FragmentShaderCheckerboard::GetShaderString(
1516     TexCoordPrecision precision, SamplerType sampler) const {
1517   // Shader based on Example 13-17 of "OpenGL ES 2.0 Programming Guide"
1518   // by Munshi, Ginsburg, Shreiner.
1519   return FRAGMENT_SHADER(
1520     precision mediump float;
1521     precision mediump int;
1522     varying vec2 v_texCoord;
1523     uniform float alpha;
1524     uniform float frequency;
1525     uniform vec4 texTransform;
1526     uniform vec4 color;
1527     void main() {
1528       vec4 color1 = vec4(1.0, 1.0, 1.0, 1.0);
1529       vec4 color2 = color;
1530       vec2 texCoord =
1531           clamp(v_texCoord, 0.0, 1.0) * texTransform.zw + texTransform.xy;
1532       vec2 coord = mod(floor(texCoord * frequency * 2.0), 2.0);
1533       float picker = abs(coord.x - coord.y);  // NOLINT
1534       gl_FragColor = mix(color1, color2, picker) * alpha;
1535     }
1536   );  // NOLINT(whitespace/parens)
1537 }
1538
1539 }  // namespace cc