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