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