cc/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/shader.h"
   6
   7 #include "base/basictypes.h"
   8 #include "base/logging.h"
   9 #include <public/WebGraphicsContext3D.h>
  10
  11 #define SHADER0(Src) #Src
  12 #define SHADER(Src) SHADER0(Src)
  13
  14 using WebKit::WebGraphicsContext3D;
  15
  16 namespace cc {
  17
  18 namespace {
  19
  20 static void getProgramUniformLocations(WebGraphicsContext3D* context, unsigned program, const char** shaderUniforms, size_t count, size_t maxLocations, int* locations, bool usingBindUniform, int* baseUniformIndex)
  21 {
  22     for (size_t uniformIndex = 0; uniformIndex < count; uniformIndex ++) {
  23         DCHECK(uniformIndex < maxLocations);
  24
  25         if (usingBindUniform) {
  26             locations[uniformIndex] = (*baseUniformIndex)++;
  27             context->bindUniformLocationCHROMIUM(program, locations[uniformIndex], shaderUniforms[uniformIndex]);
  28         } else
  29             locations[uniformIndex] = context->getUniformLocation(program, shaderUniforms[uniformIndex]);
  30     }
  31 }
  32
  33 }
  34
  35 VertexShaderPosTex::VertexShaderPosTex()
  36     : m_matrixLocation(-1)
  37 {
  38 }
  39
  40 void VertexShaderPosTex::init(WebGraphicsContext3D* context, unsigned program, bool usingBindUniform, int* baseUniformIndex)
  41 {
  42     static const char* shaderUniforms[] = {
  43         "matrix",
  44     };
  45     int locations[1];
  46
  47     getProgramUniformLocations(context, program, shaderUniforms, arraysize(shaderUniforms), arraysize(locations), locations, usingBindUniform, baseUniformIndex);
  48
  49     m_matrixLocation = locations[0];
  50     DCHECK(m_matrixLocation != -1);
  51 }
  52
  53 std::string VertexShaderPosTex::getShaderString() const
  54 {
  55     return SHADER(
  56         attribute vec4 a_position;
  57         attribute vec2 a_texCoord;
  58         uniform mat4 matrix;
  59         varying vec2 v_texCoord;
  60         void main()
  61         {
  62             gl_Position = matrix * a_position;
  63             v_texCoord = a_texCoord;
  64         }
  65     );
  66 }
  67
  68 VertexShaderPosTexYUVStretch::VertexShaderPosTexYUVStretch()
  69     : m_matrixLocation(-1)
  70     , m_texScaleLocation(-1)
  71 {
  72 }
  73
  74 void VertexShaderPosTexYUVStretch::init(WebGraphicsContext3D* context, unsigned program, bool usingBindUniform, int* baseUniformIndex)
  75 {
  76     static const char* shaderUniforms[] = {
  77         "matrix",
  78         "texScale",
  79     };
  80     int locations[2];
  81
  82     getProgramUniformLocations(context, program, shaderUniforms, arraysize(shaderUniforms), arraysize(locations), locations, usingBindUniform, baseUniformIndex);
  83
  84     m_matrixLocation = locations[0];
  85     m_texScaleLocation = locations[1];
  86     DCHECK(m_matrixLocation != -1 && m_texScaleLocation != -1);
  87 }
  88
  89 std::string VertexShaderPosTexYUVStretch::getShaderString() const
  90 {
  91     return SHADER(
  92         precision mediump float;
  93         attribute vec4 a_position;
  94         attribute vec2 a_texCoord;
  95         uniform mat4 matrix;
  96         varying vec2 v_texCoord;
  97         uniform vec2 texScale;
  98         void main()
  99         {
 100             gl_Position = matrix * a_position;
 101             v_texCoord = a_texCoord * texScale;
 102         }
 103     );
 104 }
 105
 106 VertexShaderPos::VertexShaderPos()
 107     : m_matrixLocation(-1)
 108 {
 109 }
 110
 111 void VertexShaderPos::init(WebGraphicsContext3D* context, unsigned program, bool usingBindUniform, int* baseUniformIndex)
 112 {
 113     static const char* shaderUniforms[] = {
 114         "matrix",
 115     };
 116     int locations[1];
 117
 118     getProgramUniformLocations(context, program, shaderUniforms, arraysize(shaderUniforms), arraysize(locations), locations, usingBindUniform, baseUniformIndex);
 119
 120     m_matrixLocation = locations[0];
 121     DCHECK(m_matrixLocation != -1);
 122 }
 123
 124 std::string VertexShaderPos::getShaderString() const
 125 {
 126     return SHADER(
 127         attribute vec4 a_position;
 128         uniform mat4 matrix;
 129         void main()
 130         {
 131             gl_Position = matrix * a_position;
 132         }
 133     );
 134 }
 135
 136 VertexShaderPosTexTransform::VertexShaderPosTexTransform()
 137     : m_matrixLocation(-1)
 138     , m_texTransformLocation(-1)
 139 {
 140 }
 141
 142 void VertexShaderPosTexTransform::init(WebGraphicsContext3D* context, unsigned program, bool usingBindUniform, int* baseUniformIndex)
 143 {
 144     static const char* shaderUniforms[] = {
 145         "matrix",
 146         "texTransform",
 147     };
 148     int locations[2];
 149
 150     getProgramUniformLocations(context, program, shaderUniforms, arraysize(shaderUniforms), arraysize(locations), locations, usingBindUniform, baseUniformIndex);
 151
 152     m_matrixLocation = locations[0];
 153     m_texTransformLocation = locations[1];
 154     DCHECK(m_matrixLocation != -1 && m_texTransformLocation != -1);
 155 }
 156
 157 std::string VertexShaderPosTexTransform::getShaderString() const
 158 {
 159     return SHADER(
 160         attribute vec4 a_position;
 161         attribute vec2 a_texCoord;
 162         attribute float a_index;
 163         uniform mat4 matrix[8];
 164         uniform vec4 texTransform[8];
 165         varying vec2 v_texCoord;
 166         void main()
 167         {
 168             gl_Position = matrix[int(a_index)] * a_position;
 169             v_texCoord = a_texCoord * texTransform[int(a_index)].zw + texTransform[int(a_index)].xy;
 170         }
 171     );
 172 }
 173
 174 VertexShaderQuad::VertexShaderQuad()
 175     : m_matrixLocation(-1)
 176     , m_pointLocation(-1)
 177 {
 178 }
 179
 180 std::string VertexShaderPosTexIdentity::getShaderString() const
 181 {
 182     return SHADER(
 183         attribute vec4 a_position;
 184         varying vec2 v_texCoord;
 185         void main()
 186         {
 187             gl_Position = a_position;
 188             v_texCoord = (a_position.xy + vec2(1.0)) * 0.5;
 189         }
 190     );
 191 }
 192
 193 void VertexShaderQuad::init(WebGraphicsContext3D* context, unsigned program, bool usingBindUniform, int* baseUniformIndex)
 194 {
 195     static const char* shaderUniforms[] = {
 196         "matrix",
 197         "point",
 198     };
 199     int locations[2];
 200
 201     getProgramUniformLocations(context, program, shaderUniforms, arraysize(shaderUniforms), arraysize(locations), locations, usingBindUniform, baseUniformIndex);
 202
 203     m_matrixLocation = locations[0];
 204     m_pointLocation = locations[1];
 205     DCHECK(m_matrixLocation != -1 && m_pointLocation != -1);
 206 }
 207
 208 std::string VertexShaderQuad::getShaderString() const
 209 {
 210     return SHADER(
 211         attribute vec4 a_position;
 212         attribute vec2 a_texCoord;
 213         uniform mat4 matrix;
 214         uniform vec2 point[4];
 215         varying vec2 v_texCoord;
 216         void main()
 217         {
 218             vec2 complement = abs(a_texCoord - 1.0);
 219             vec4 pos = vec4(0.0, 0.0, a_position.z, a_position.w);
 220             pos.xy += (complement.x * complement.y) * point[0];
 221             pos.xy += (a_texCoord.x * complement.y) * point[1];
 222             pos.xy += (a_texCoord.x * a_texCoord.y) * point[2];
 223             pos.xy += (complement.x * a_texCoord.y) * point[3];
 224             gl_Position = matrix * pos;
 225             v_texCoord = pos.xy + vec2(0.5);
 226         }
 227     );
 228 }
 229
 230 VertexShaderTile::VertexShaderTile()
 231     : m_matrixLocation(-1)
 232     , m_pointLocation(-1)
 233     , m_vertexTexTransformLocation(-1)
 234 {
 235 }
 236
 237 void VertexShaderTile::init(WebGraphicsContext3D* context, unsigned program, bool usingBindUniform, int* baseUniformIndex)
 238 {
 239     static const char* shaderUniforms[] = {
 240         "matrix",
 241         "point",
 242         "vertexTexTransform",
 243     };
 244     int locations[3];
 245
 246     getProgramUniformLocations(context, program, shaderUniforms, arraysize(shaderUniforms), arraysize(locations), locations, usingBindUniform, baseUniformIndex);
 247
 248     m_matrixLocation = locations[0];
 249     m_pointLocation = locations[1];
 250     m_vertexTexTransformLocation = locations[2];
 251     DCHECK(m_matrixLocation != -1 && m_pointLocation != -1 && m_vertexTexTransformLocation != -1);
 252 }
 253
 254 std::string VertexShaderTile::getShaderString() const
 255 {
 256     return SHADER(
 257         attribute vec4 a_position;
 258         attribute vec2 a_texCoord;
 259         uniform mat4 matrix;
 260         uniform vec2 point[4];
 261         uniform vec4 vertexTexTransform;
 262         varying vec2 v_texCoord;
 263         void main()
 264         {
 265             vec2 complement = abs(a_texCoord - 1.0);
 266             vec4 pos = vec4(0.0, 0.0, a_position.z, a_position.w);
 267             pos.xy += (complement.x * complement.y) * point[0];
 268             pos.xy += (a_texCoord.x * complement.y) * point[1];
 269             pos.xy += (a_texCoord.x * a_texCoord.y) * point[2];
 270             pos.xy += (complement.x * a_texCoord.y) * point[3];
 271             gl_Position = matrix * pos;
 272             v_texCoord = pos.xy * vertexTexTransform.zw + vertexTexTransform.xy;
 273         }
 274     );
 275 }
 276
 277 VertexShaderVideoTransform::VertexShaderVideoTransform()
 278     : m_matrixLocation(-1)
 279     , m_texMatrixLocation(-1)
 280 {
 281 }
 282
 283 bool VertexShaderVideoTransform::init(WebGraphicsContext3D* context, unsigned program, bool usingBindUniform, int* baseUniformIndex)
 284 {
 285     static const char* shaderUniforms[] = {
 286         "matrix",
 287         "texMatrix",
 288     };
 289     int locations[2];
 290
 291     getProgramUniformLocations(context, program, shaderUniforms, arraysize(shaderUniforms), arraysize(locations), locations, usingBindUniform, baseUniformIndex);
 292
 293     m_matrixLocation = locations[0];
 294     m_texMatrixLocation = locations[1];
 295     return m_matrixLocation != -1 && m_texMatrixLocation != -1;
 296 }
 297
 298 std::string VertexShaderVideoTransform::getShaderString() const
 299 {
 300     return SHADER(
 301         attribute vec4 a_position;
 302         attribute vec2 a_texCoord;
 303         uniform mat4 matrix;
 304         uniform mat4 texMatrix;
 305         varying vec2 v_texCoord;
 306         void main()
 307         {
 308             gl_Position = matrix * a_position;
 309             v_texCoord = vec2(texMatrix * vec4(a_texCoord.x, 1.0 - a_texCoord.y, 0.0, 1.0));
 310         }
 311     );
 312 }
 313
 314 FragmentTexAlphaBinding::FragmentTexAlphaBinding()
 315     : m_samplerLocation(-1)
 316     , m_alphaLocation(-1)
 317 {
 318 }
 319
 320 void FragmentTexAlphaBinding::init(WebGraphicsContext3D* context, unsigned program, bool usingBindUniform, int* baseUniformIndex)
 321 {
 322     static const char* shaderUniforms[] = {
 323         "s_texture",
 324         "alpha",
 325     };
 326     int locations[2];
 327
 328     getProgramUniformLocations(context, program, shaderUniforms, arraysize(shaderUniforms), arraysize(locations), locations, usingBindUniform, baseUniformIndex);
 329
 330     m_samplerLocation = locations[0];
 331     m_alphaLocation = locations[1];
 332     DCHECK(m_samplerLocation != -1 && m_alphaLocation != -1);
 333 }
 334
 335 FragmentTexOpaqueBinding::FragmentTexOpaqueBinding()
 336     : m_samplerLocation(-1)
 337 {
 338 }
 339
 340 void FragmentTexOpaqueBinding::init(WebGraphicsContext3D* context, unsigned program, bool usingBindUniform, int* baseUniformIndex)
 341 {
 342     static const char* shaderUniforms[] = {
 343         "s_texture",
 344     };
 345     int locations[1];
 346
 347     getProgramUniformLocations(context, program, shaderUniforms, arraysize(shaderUniforms), arraysize(locations), locations, usingBindUniform, baseUniformIndex);
 348
 349     m_samplerLocation = locations[0];
 350     DCHECK(m_samplerLocation != -1);
 351 }
 352
 353 std::string FragmentShaderRGBATexFlipAlpha::getShaderString() const
 354 {
 355     return SHADER(
 356         precision mediump float;
 357         varying vec2 v_texCoord;
 358         uniform sampler2D s_texture;
 359         uniform float alpha;
 360         void main()
 361         {
 362             vec4 texColor = texture2D(s_texture, vec2(v_texCoord.x, 1.0 - v_texCoord.y));
 363             gl_FragColor = vec4(texColor.x, texColor.y, texColor.z, texColor.w) * alpha;
 364         }
 365     );
 366 }
 367
 368 bool FragmentShaderOESImageExternal::init(WebGraphicsContext3D* context, unsigned program, bool usingBindUniform, int* baseUniformIndex)
 369 {
 370     static const char* shaderUniforms[] = {
 371         "s_texture",
 372     };
 373     int locations[1];
 374
 375     getProgramUniformLocations(context, program, shaderUniforms, arraysize(shaderUniforms), arraysize(locations), locations, usingBindUniform, baseUniformIndex);
 376
 377     m_samplerLocation = locations[0];
 378     return m_samplerLocation != -1;
 379 }
 380
 381 std::string FragmentShaderOESImageExternal::getShaderString() const
 382 {
 383     // Cannot use the SHADER() macro because of the '#' char
 384     return "#extension GL_OES_EGL_image_external : require \n"
 385            "precision mediump float;\n"
 386            "varying vec2 v_texCoord;\n"
 387            "uniform samplerExternalOES s_texture;\n"
 388            "void main()\n"
 389            "{\n"
 390            "    vec4 texColor = texture2D(s_texture, v_texCoord);\n"
 391            "    gl_FragColor = vec4(texColor.x, texColor.y, texColor.z, texColor.w);\n"
 392            "}\n";
 393 }
 394
 395 std::string FragmentShaderRGBATexAlpha::getShaderString() const
 396 {
 397     return SHADER(
 398         precision mediump float;
 399         varying vec2 v_texCoord;
 400         uniform sampler2D s_texture;
 401         uniform float alpha;
 402         void main()
 403         {
 404             vec4 texColor = texture2D(s_texture, v_texCoord);
 405             gl_FragColor = texColor * alpha;
 406         }
 407     );
 408 }
 409
 410 std::string FragmentShaderRGBATexRectFlipAlpha::getShaderString() const
 411 {
 412     // This must be paired with VertexShaderPosTexTransform to pick up the texTransform uniform.
 413     // The necessary #extension preprocessing directive breaks the SHADER and SHADER0 macros.
 414     return "#extension GL_ARB_texture_rectangle : require\n"
 415             "precision mediump float;\n"
 416             "varying vec2 v_texCoord;\n"
 417             "uniform vec4 texTransform;\n"
 418             "uniform sampler2DRect s_texture;\n"
 419             "uniform float alpha;\n"
 420             "void main()\n"
 421             "{\n"
 422             "    vec4 texColor = texture2DRect(s_texture, vec2(v_texCoord.x, texTransform.w - v_texCoord.y));\n"
 423             "    gl_FragColor = vec4(texColor.x, texColor.y, texColor.z, texColor.w) * alpha;\n"
 424             "}\n";
 425 }
 426
 427 std::string FragmentShaderRGBATexRectAlpha::getShaderString() const
 428 {
 429     return "#extension GL_ARB_texture_rectangle : require\n"
 430             "precision mediump float;\n"
 431             "varying vec2 v_texCoord;\n"
 432             "uniform sampler2DRect s_texture;\n"
 433             "uniform float alpha;\n"
 434             "void main()\n"
 435             "{\n"
 436             "    vec4 texColor = texture2DRect(s_texture, v_texCoord);\n"
 437             "    gl_FragColor = texColor * alpha;\n"
 438             "}\n";
 439 }
 440
 441 std::string FragmentShaderRGBATexOpaque::getShaderString() const
 442 {
 443     return SHADER(
 444         precision mediump float;
 445         varying vec2 v_texCoord;
 446         uniform sampler2D s_texture;
 447         void main()
 448         {
 449             vec4 texColor = texture2D(s_texture, v_texCoord);
 450             gl_FragColor = vec4(texColor.rgb, 1.0);
 451         }
 452     );
 453 }
 454
 455 std::string FragmentShaderRGBATex::getShaderString() const
 456 {
 457     return SHADER(
 458         precision mediump float;
 459         varying vec2 v_texCoord;
 460         uniform sampler2D s_texture;
 461         void main()
 462         {
 463             gl_FragColor = texture2D(s_texture, v_texCoord);
 464         }
 465     );
 466 }
 467
 468 std::string FragmentShaderRGBATexSwizzleAlpha::getShaderString() const
 469 {
 470     return SHADER(
 471         precision mediump float;
 472         varying vec2 v_texCoord;
 473         uniform sampler2D s_texture;
 474         uniform float alpha;
 475         void main()
 476         {
 477             vec4 texColor = texture2D(s_texture, v_texCoord);
 478             gl_FragColor = vec4(texColor.z, texColor.y, texColor.x, texColor.w) * alpha;
 479         }
 480     );
 481 }
 482
 483 std::string FragmentShaderRGBATexSwizzleOpaque::getShaderString() const
 484 {
 485     return SHADER(
 486         precision mediump float;
 487         varying vec2 v_texCoord;
 488         uniform sampler2D s_texture;
 489         void main()
 490         {
 491             vec4 texColor = texture2D(s_texture, v_texCoord);
 492             gl_FragColor = vec4(texColor.z, texColor.y, texColor.x, 1.0);
 493         }
 494     );
 495 }
 496
 497 FragmentShaderRGBATexAlphaAA::FragmentShaderRGBATexAlphaAA()
 498     : m_samplerLocation(-1)
 499     , m_alphaLocation(-1)
 500     , m_edgeLocation(-1)
 501 {
 502 }
 503
 504 void FragmentShaderRGBATexAlphaAA::init(WebGraphicsContext3D* context, unsigned program, bool usingBindUniform, int* baseUniformIndex)
 505 {
 506     static const char* shaderUniforms[] = {
 507         "s_texture",
 508         "alpha",
 509         "edge",
 510     };
 511     int locations[3];
 512
 513     getProgramUniformLocations(context, program, shaderUniforms, arraysize(shaderUniforms), arraysize(locations), locations, usingBindUniform, baseUniformIndex);
 514
 515     m_samplerLocation = locations[0];
 516     m_alphaLocation = locations[1];
 517     m_edgeLocation = locations[2];
 518     DCHECK(m_samplerLocation != -1 && m_alphaLocation != -1 && m_edgeLocation != -1);
 519 }
 520
 521 std::string FragmentShaderRGBATexAlphaAA::getShaderString() const
 522 {
 523     return SHADER(
 524         precision mediump float;
 525         varying vec2 v_texCoord;
 526         uniform sampler2D s_texture;
 527         uniform float alpha;
 528         uniform vec3 edge[8];
 529         void main()
 530         {
 531             vec4 texColor = texture2D(s_texture, v_texCoord);
 532             vec3 pos = vec3(gl_FragCoord.xy, 1);
 533             float a0 = clamp(dot(edge[0], pos), 0.0, 1.0);
 534             float a1 = clamp(dot(edge[1], pos), 0.0, 1.0);
 535             float a2 = clamp(dot(edge[2], pos), 0.0, 1.0);
 536             float a3 = clamp(dot(edge[3], pos), 0.0, 1.0);
 537             float a4 = clamp(dot(edge[4], pos), 0.0, 1.0);
 538             float a5 = clamp(dot(edge[5], pos), 0.0, 1.0);
 539             float a6 = clamp(dot(edge[6], pos), 0.0, 1.0);
 540             float a7 = clamp(dot(edge[7], pos), 0.0, 1.0);
 541             gl_FragColor = texColor * alpha * min(min(a0, a2) * min(a1, a3), min(a4, a6) * min(a5, a7));
 542         }
 543     );
 544 }
 545
 546 FragmentTexClampAlphaAABinding::FragmentTexClampAlphaAABinding()
 547     : m_samplerLocation(-1)
 548     , m_alphaLocation(-1)
 549     , m_fragmentTexTransformLocation(-1)
 550     , m_edgeLocation(-1)
 551 {
 552 }
 553
 554 void FragmentTexClampAlphaAABinding::init(WebGraphicsContext3D* context, unsigned program, bool usingBindUniform, int* baseUniformIndex)
 555 {
 556     static const char* shaderUniforms[] = {
 557         "s_texture",
 558         "alpha",
 559         "fragmentTexTransform",
 560         "edge",
 561     };
 562     int locations[4];
 563
 564     getProgramUniformLocations(context, program, shaderUniforms, arraysize(shaderUniforms), arraysize(locations), locations, usingBindUniform, baseUniformIndex);
 565
 566     m_samplerLocation = locations[0];
 567     m_alphaLocation = locations[1];
 568     m_fragmentTexTransformLocation = locations[2];
 569     m_edgeLocation = locations[3];
 570     DCHECK(m_samplerLocation != -1 && m_alphaLocation != -1 && m_fragmentTexTransformLocation != -1 && m_edgeLocation != -1);
 571 }
 572
 573 std::string FragmentShaderRGBATexClampAlphaAA::getShaderString() const
 574 {
 575     return SHADER(
 576         precision mediump float;
 577         varying vec2 v_texCoord;
 578         uniform sampler2D s_texture;
 579         uniform float alpha;
 580         uniform vec4 fragmentTexTransform;
 581         uniform vec3 edge[8];
 582         void main()
 583         {
 584             vec2 texCoord = clamp(v_texCoord, 0.0, 1.0) * fragmentTexTransform.zw + fragmentTexTransform.xy;
 585             vec4 texColor = texture2D(s_texture, texCoord);
 586             vec3 pos = vec3(gl_FragCoord.xy, 1);
 587             float a0 = clamp(dot(edge[0], pos), 0.0, 1.0);
 588             float a1 = clamp(dot(edge[1], pos), 0.0, 1.0);
 589             float a2 = clamp(dot(edge[2], pos), 0.0, 1.0);
 590             float a3 = clamp(dot(edge[3], pos), 0.0, 1.0);
 591             float a4 = clamp(dot(edge[4], pos), 0.0, 1.0);
 592             float a5 = clamp(dot(edge[5], pos), 0.0, 1.0);
 593             float a6 = clamp(dot(edge[6], pos), 0.0, 1.0);
 594             float a7 = clamp(dot(edge[7], pos), 0.0, 1.0);
 595             gl_FragColor = texColor * alpha * min(min(a0, a2) * min(a1, a3), min(a4, a6) * min(a5, a7));
 596         }
 597     );
 598 }
 599
 600 std::string FragmentShaderRGBATexClampSwizzleAlphaAA::getShaderString() const
 601 {
 602     return SHADER(
 603         precision mediump float;
 604         varying vec2 v_texCoord;
 605         uniform sampler2D s_texture;
 606         uniform float alpha;
 607         uniform vec4 fragmentTexTransform;
 608         uniform vec3 edge[8];
 609         void main()
 610         {
 611             vec2 texCoord = clamp(v_texCoord, 0.0, 1.0) * fragmentTexTransform.zw + fragmentTexTransform.xy;
 612             vec4 texColor = texture2D(s_texture, texCoord);
 613             vec3 pos = vec3(gl_FragCoord.xy, 1);
 614             float a0 = clamp(dot(edge[0], pos), 0.0, 1.0);
 615             float a1 = clamp(dot(edge[1], pos), 0.0, 1.0);
 616             float a2 = clamp(dot(edge[2], pos), 0.0, 1.0);
 617             float a3 = clamp(dot(edge[3], pos), 0.0, 1.0);
 618             float a4 = clamp(dot(edge[4], pos), 0.0, 1.0);
 619             float a5 = clamp(dot(edge[5], pos), 0.0, 1.0);
 620             float a6 = clamp(dot(edge[6], pos), 0.0, 1.0);
 621             float a7 = clamp(dot(edge[7], pos), 0.0, 1.0);
 622             gl_FragColor = vec4(texColor.z, texColor.y, texColor.x, texColor.w) * alpha * min(min(a0, a2) * min(a1, a3), min(a4, a6) * min(a5, a7));
 623         }
 624     );
 625 }
 626
 627 FragmentShaderRGBATexAlphaMask::FragmentShaderRGBATexAlphaMask()
 628     : m_samplerLocation(-1)
 629     , m_maskSamplerLocation(-1)
 630     , m_alphaLocation(-1)
 631     , m_maskTexCoordScaleLocation(-1)
 632 {
 633 }
 634
 635 void FragmentShaderRGBATexAlphaMask::init(WebGraphicsContext3D* context, unsigned program, bool usingBindUniform, int* baseUniformIndex)
 636 {
 637     static const char* shaderUniforms[] = {
 638         "s_texture",
 639         "s_mask",
 640         "alpha",
 641         "maskTexCoordScale",
 642         "maskTexCoordOffset",
 643     };
 644     int locations[5];
 645
 646     getProgramUniformLocations(context, program, shaderUniforms, arraysize(shaderUniforms), arraysize(locations), locations, usingBindUniform, baseUniformIndex);
 647
 648     m_samplerLocation = locations[0];
 649     m_maskSamplerLocation = locations[1];
 650     m_alphaLocation = locations[2];
 651     m_maskTexCoordScaleLocation = locations[3];
 652     m_maskTexCoordOffsetLocation = locations[4];
 653     DCHECK(m_samplerLocation != -1 && m_maskSamplerLocation != -1 && m_alphaLocation != -1);
 654 }
 655
 656 std::string FragmentShaderRGBATexAlphaMask::getShaderString() const
 657 {
 658     return SHADER(
 659         precision mediump float;
 660         varying vec2 v_texCoord;
 661         uniform sampler2D s_texture;
 662         uniform sampler2D s_mask;
 663         uniform vec2 maskTexCoordScale;
 664         uniform vec2 maskTexCoordOffset;
 665         uniform float alpha;
 666         void main()
 667         {
 668             vec4 texColor = texture2D(s_texture, v_texCoord);
 669             vec2 maskTexCoord = vec2(maskTexCoordOffset.x + v_texCoord.x * maskTexCoordScale.x, maskTexCoordOffset.y + v_texCoord.y * maskTexCoordScale.y);
 670             vec4 maskColor = texture2D(s_mask, maskTexCoord);
 671             gl_FragColor = vec4(texColor.x, texColor.y, texColor.z, texColor.w) * alpha * maskColor.w;
 672         }
 673     );
 674 }
 675
 676 FragmentShaderRGBATexAlphaMaskAA::FragmentShaderRGBATexAlphaMaskAA()
 677     : m_samplerLocation(-1)
 678     , m_maskSamplerLocation(-1)
 679     , m_alphaLocation(-1)
 680     , m_edgeLocation(-1)
 681     , m_maskTexCoordScaleLocation(-1)
 682 {
 683 }
 684
 685 void FragmentShaderRGBATexAlphaMaskAA::init(WebGraphicsContext3D* context, unsigned program, bool usingBindUniform, int* baseUniformIndex)
 686 {
 687     static const char* shaderUniforms[] = {
 688         "s_texture",
 689         "s_mask",
 690         "alpha",
 691         "edge",
 692         "maskTexCoordScale",
 693         "maskTexCoordOffset",
 694     };
 695     int locations[6];
 696
 697     getProgramUniformLocations(context, program, shaderUniforms, arraysize(shaderUniforms), arraysize(locations), locations, usingBindUniform, baseUniformIndex);
 698
 699     m_samplerLocation = locations[0];
 700     m_maskSamplerLocation = locations[1];
 701     m_alphaLocation = locations[2];
 702     m_edgeLocation = locations[3];
 703     m_maskTexCoordScaleLocation = locations[4];
 704     m_maskTexCoordOffsetLocation = locations[5];
 705     DCHECK(m_samplerLocation != -1 && m_maskSamplerLocation != -1 && m_alphaLocation != -1 && m_edgeLocation != -1);
 706 }
 707
 708 std::string FragmentShaderRGBATexAlphaMaskAA::getShaderString() const
 709 {
 710     return SHADER(
 711         precision mediump float;
 712         varying vec2 v_texCoord;
 713         uniform sampler2D s_texture;
 714         uniform sampler2D s_mask;
 715         uniform vec2 maskTexCoordScale;
 716         uniform vec2 maskTexCoordOffset;
 717         uniform float alpha;
 718         uniform vec3 edge[8];
 719         void main()
 720         {
 721             vec4 texColor = texture2D(s_texture, v_texCoord);
 722             vec2 maskTexCoord = vec2(maskTexCoordOffset.x + v_texCoord.x * maskTexCoordScale.x, maskTexCoordOffset.y + v_texCoord.y * maskTexCoordScale.y);
 723             vec4 maskColor = texture2D(s_mask, maskTexCoord);
 724             vec3 pos = vec3(gl_FragCoord.xy, 1);
 725             float a0 = clamp(dot(edge[0], pos), 0.0, 1.0);
 726             float a1 = clamp(dot(edge[1], pos), 0.0, 1.0);
 727             float a2 = clamp(dot(edge[2], pos), 0.0, 1.0);
 728             float a3 = clamp(dot(edge[3], pos), 0.0, 1.0);
 729             float a4 = clamp(dot(edge[4], pos), 0.0, 1.0);
 730             float a5 = clamp(dot(edge[5], pos), 0.0, 1.0);
 731             float a6 = clamp(dot(edge[6], pos), 0.0, 1.0);
 732             float a7 = clamp(dot(edge[7], pos), 0.0, 1.0);
 733             gl_FragColor = vec4(texColor.x, texColor.y, texColor.z, texColor.w) * alpha * maskColor.w * min(min(a0, a2) * min(a1, a3), min(a4, a6) * min(a5, a7));
 734         }
 735     );
 736 }
 737
 738 FragmentShaderYUVVideo::FragmentShaderYUVVideo()
 739     : m_yTextureLocation(-1)
 740     , m_uTextureLocation(-1)
 741     , m_vTextureLocation(-1)
 742     , m_alphaLocation(-1)
 743     , m_yuvMatrixLocation(-1)
 744     , m_yuvAdjLocation(-1)
 745 {
 746 }
 747
 748 void FragmentShaderYUVVideo::init(WebGraphicsContext3D* context, unsigned program, bool usingBindUniform, int* baseUniformIndex)
 749 {
 750     static const char* shaderUniforms[] = {
 751         "y_texture",
 752         "u_texture",
 753         "v_texture",
 754         "alpha",
 755         "yuv_matrix",
 756         "yuv_adj",
 757     };
 758     int locations[6];
 759
 760     getProgramUniformLocations(context, program, shaderUniforms, arraysize(shaderUniforms), arraysize(locations), locations, usingBindUniform, baseUniformIndex);
 761
 762     m_yTextureLocation = locations[0];
 763     m_uTextureLocation = locations[1];
 764     m_vTextureLocation = locations[2];
 765     m_alphaLocation = locations[3];
 766     m_yuvMatrixLocation = locations[4];
 767     m_yuvAdjLocation = locations[5];
 768
 769     DCHECK(m_yTextureLocation != -1 && m_uTextureLocation != -1 && m_vTextureLocation != -1
 770            && m_alphaLocation != -1 && m_yuvMatrixLocation != -1 && m_yuvAdjLocation != -1);
 771 }
 772
 773 std::string FragmentShaderYUVVideo::getShaderString() const
 774 {
 775     return SHADER(
 776         precision mediump float;
 777         precision mediump int;
 778         varying vec2 v_texCoord;
 779         uniform sampler2D y_texture;
 780         uniform sampler2D u_texture;
 781         uniform sampler2D v_texture;
 782         uniform float alpha;
 783         uniform vec3 yuv_adj;
 784         uniform mat3 yuv_matrix;
 785         void main()
 786         {
 787             float y_raw = texture2D(y_texture, v_texCoord).x;
 788             float u_unsigned = texture2D(u_texture, v_texCoord).x;
 789             float v_unsigned = texture2D(v_texture, v_texCoord).x;
 790             vec3 yuv = vec3(y_raw, u_unsigned, v_unsigned) + yuv_adj;
 791             vec3 rgb = yuv_matrix * yuv;
 792             gl_FragColor = vec4(rgb, float(1)) * alpha;
 793         }
 794     );
 795 }
 796
 797 FragmentShaderColor::FragmentShaderColor()
 798     : m_colorLocation(-1)
 799 {
 800 }
 801
 802 void FragmentShaderColor::init(WebGraphicsContext3D* context, unsigned program, bool usingBindUniform, int* baseUniformIndex)
 803 {
 804     static const char* shaderUniforms[] = {
 805         "color",
 806     };
 807     int locations[1];
 808
 809     getProgramUniformLocations(context, program, shaderUniforms, arraysize(shaderUniforms), arraysize(locations), locations, usingBindUniform, baseUniformIndex);
 810
 811     m_colorLocation = locations[0];
 812     DCHECK(m_colorLocation != -1);
 813 }
 814
 815 std::string FragmentShaderColor::getShaderString() const
 816 {
 817     return SHADER(
 818         precision mediump float;
 819         uniform vec4 color;
 820         void main()
 821         {
 822             gl_FragColor = color;
 823         }
 824     );
 825 }
 826
 827 FragmentShaderCheckerboard::FragmentShaderCheckerboard()
 828     : m_alphaLocation(-1)
 829     , m_texTransformLocation(-1)
 830     , m_frequencyLocation(-1)
 831 {
 832 }
 833
 834 void FragmentShaderCheckerboard::init(WebGraphicsContext3D* context, unsigned program, bool usingBindUniform, int* baseUniformIndex)
 835 {
 836     static const char* shaderUniforms[] = {
 837         "alpha",
 838         "texTransform",
 839         "frequency",
 840         "color",
 841     };
 842     int locations[4];
 843
 844     getProgramUniformLocations(context, program, shaderUniforms, arraysize(shaderUniforms), arraysize(locations), locations, usingBindUniform, baseUniformIndex);
 845
 846     m_alphaLocation = locations[0];
 847     m_texTransformLocation = locations[1];
 848     m_frequencyLocation = locations[2];
 849     m_colorLocation = locations[3];
 850     DCHECK(m_alphaLocation != -1 && m_texTransformLocation != -1 && m_frequencyLocation != -1 && m_colorLocation != -1);
 851 }
 852
 853 std::string FragmentShaderCheckerboard::getShaderString() const
 854 {
 855     // Shader based on Example 13-17 of "OpenGL ES 2.0 Programming Guide"
 856     // by Munshi, Ginsburg, Shreiner.
 857     return SHADER(
 858         precision mediump float;
 859         precision mediump int;
 860         varying vec2 v_texCoord;
 861         uniform float alpha;
 862         uniform float frequency;
 863         uniform vec4 texTransform;
 864         uniform vec4 color;
 865         void main()
 866         {
 867             vec4 color1 = vec4(1.0, 1.0, 1.0, 1.0);
 868             vec4 color2 = color;
 869             vec2 texCoord = clamp(v_texCoord, 0.0, 1.0) * texTransform.zw + texTransform.xy;
 870             vec2 coord = mod(floor(texCoord * frequency * 2.0), 2.0);
 871             float picker = abs(coord.x - coord.y);
 872             gl_FragColor = mix(color1, color2, picker) * alpha;
 873         }
 874     );
 875 }
 876
 877 }  // namespace cc