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