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