gpu/tools/compositor_model_bench/shaders.cc - chromium/src.git - Git at Google

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "gpu/tools/compositor_model_bench/shaders.h"

 #include <stdint.h>

 #include <algorithm>
 #include <memory>

 #include "gpu/tools/compositor_model_bench/render_model_utils.h"
 #include "gpu/tools/compositor_model_bench/render_tree.h"

 using std::min;

 static const int kPositionLocation = 0;
 static const int kTexCoordLocation = 1;

 static unsigned g_quad_vertices_vbo;
 static unsigned g_quad_elements_vbo;

 // Store a pointer to the transform matrix of the active layer (the complete
 // transform isn't build until we draw the quad; then we can apply
 // translation/scaling/projection)
 static float* g_current_layer_transform;

 // In addition to the transform, store other useful information about tiled
 // layers that we'll need to render each tile's quad
 static float g_current_tile_layer_width;
 static float g_current_tile_layer_height;
 static float g_current_tile_width;
 static float g_current_tile_height;

 static const float yuv2RGB[9] = {
   1.164f, 1.164f, 1.164f,
   0.f, -.391f, 2.018f,
   1.596f, -.813f, 0.f
 };

 // Store shader programs in a sparse array so that they can be addressed easily.
 static int g_program_objects[SHADER_ID_MAX*SHADER_ID_MAX];
 static int g_active_index = -1;

 ///////////////////////////////////////////////////////////////////////////////
 //              L        R           B          T   N  F
 //      glOrtho(0, WINDOW_WIDTH, WINDOW_HEIGHT, 0, -1, 1);   // column major

 static float g_projection_matrix[] = {
   2.0 / WINDOW_WIDTH, 0.0, 0.0, 0.0,
   0.0, 2.0 / -WINDOW_HEIGHT, 0.0, 0.0,
   0.0, 0.0, -1.0, 0.0,
   -1.0, 1.0, 0.0, 1.0
 };

 #define ADDR(i, j) (i*4 + j) /* column major */
 static void Project(const float* v, float* p) {
   for (int i = 0; i < 4; ++i) {
     for (int j = 0; j < 4; ++j) {
       p[ADDR(i, j)] = 0;
       for (int k = 0; k < 4; ++k) {
         p[ADDR(i, j)] += g_projection_matrix[ADDR(k, i)] * v[ADDR(j, k)];
       }
     }
   }
 }

 static void Scale(const float* in, float* out, float sx, float sy, float sz) {
   for (int i = 0; i < 4; ++i)
     out[i] = in[i] * sx;
   for (int j = 4; j < 8; ++j)
     out[j] = in[j] * sy;
   for (int k = 8; k < 12; ++k)
     out[k] = in[k] * sz;
   for (int l = 12; l < 16; ++l)
     out[l] = in[l];
 }

 static void TranslateInPlace(float* m, float tx, float ty, float tz) {
   m[12] += tx;
   m[13] += ty;
   m[14] += tz;
 }

 ///////////////////////////////////////////////////////////////////////////////

 ShaderID ShaderIDFromString(const std::string& name) {
   if (name == "VertexShaderPosTexYUVStretch")
     return VERTEX_SHADER_POS_TEX_YUV_STRETCH;
   if (name == "VertexShaderPosTex")
     return VERTEX_SHADER_POS_TEX;
   if (name == "VertexShaderPosTexTransform")
     return VERTEX_SHADER_POS_TEX_TRANSFORM;
   if (name == "FragmentShaderYUVVideo")
     return FRAGMENT_SHADER_YUV_VIDEO;
   if (name == "FragmentShaderRGBATexFlipAlpha")
     return FRAGMENT_SHADER_RGBA_TEX_FLIP_ALPHA;
   if (name == "FragmentShaderRGBATexAlpha")
     return FRAGMENT_SHADER_RGBA_TEX_ALPHA;
   return SHADER_UNRECOGNIZED;
 }

 std::string ShaderNameFromID(ShaderID id) {
   switch (id) {
     case VERTEX_SHADER_POS_TEX_YUV_STRETCH:
       return "VertexShaderPosTexYUVStretch";
     case VERTEX_SHADER_POS_TEX:
       return "VertexShaderPosTex";
     case VERTEX_SHADER_POS_TEX_TRANSFORM:
       return "VertexShaderPosTexTransform";
     case FRAGMENT_SHADER_YUV_VIDEO:
       return "FragmentShaderYUVVideo";
     case FRAGMENT_SHADER_RGBA_TEX_FLIP_ALPHA:
       return "FragmentShaderRGBATexFlipAlpha";
     case FRAGMENT_SHADER_RGBA_TEX_ALPHA:
       return "FragmentShaderRGBATexAlpha";
     default:
       return "(unknown shader)";
   }
 }

 #define SHADER0(Src) #Src
 #define SHADER(Src) SHADER0(Src)

 const char* GetShaderSource(ShaderID shader) {
   switch (shader) {
     case VERTEX_SHADER_POS_TEX_YUV_STRETCH:
       return SHADER(
         #ifdef GL_ES
         precision mediump float;
         #endif
         attribute vec4 a_position;
         attribute vec2 a_texCoord;
         uniform mat4 matrix;
         varying vec2 y_texCoord;
         varying vec2 uv_texCoord;
         uniform float y_widthScaleFactor;
         uniform float uv_widthScaleFactor;
         void main() {
           gl_Position = matrix * a_position;
           y_texCoord = vec2(y_widthScaleFactor * a_texCoord.x,
             a_texCoord.y);
           uv_texCoord = vec2(uv_widthScaleFactor * a_texCoord.x,
             a_texCoord.y);
         });
     case VERTEX_SHADER_POS_TEX:
       return SHADER(
         attribute vec4 a_position;
         attribute vec2 a_texCoord;
         uniform mat4 matrix;
         varying vec2 v_texCoord;
         void main() {
           gl_Position = matrix * a_position;
           v_texCoord = a_texCoord;
         });
     case VERTEX_SHADER_POS_TEX_TRANSFORM:
       return SHADER(
         attribute vec4 a_position;
         attribute vec2 a_texCoord;
         uniform mat4 matrix;
         uniform vec4 texTransform;
         varying vec2 v_texCoord;
         void main() {
           gl_Position = matrix * a_position;
           v_texCoord = a_texCoord*texTransform.zw + texTransform.xy;
         });
     case FRAGMENT_SHADER_YUV_VIDEO:
       return SHADER(
         #ifdef GL_ES
         precision mediump float;
         precision mediump int;
         #endif
         varying vec2 y_texCoord;
         varying vec2 uv_texCoord;
         uniform sampler2D y_texture;
         uniform sampler2D u_texture;
         uniform sampler2D v_texture;
         uniform float alpha;
         uniform vec3 yuv_adj;
         uniform mat3 cc_matrix;
         void main() {
           float y_raw = texture2D(y_texture, y_texCoord).x;
           float u_unsigned = texture2D(u_texture, uv_texCoord).x;
           float v_unsigned = texture2D(v_texture, uv_texCoord).x;
           vec3 yuv = vec3(y_raw, u_unsigned, v_unsigned) + yuv_adj;
           vec3 rgb = cc_matrix * yuv;
           gl_FragColor = vec4(rgb, 1.0) * alpha;
         });
     case FRAGMENT_SHADER_RGBA_TEX_FLIP_ALPHA:
       return SHADER(
         #ifdef GL_ES
         precision mediump float;
         #endif
         varying vec2 v_texCoord;
         uniform sampler2D s_texture;
         uniform float alpha;
         void main() {
           vec4 texColor = texture2D(s_texture,
             vec2(v_texCoord.x, 1.0 - v_texCoord.y));
           gl_FragColor = vec4(texColor.x,
             texColor.y,
             texColor.z,
             texColor.w) * alpha;
         });
     case FRAGMENT_SHADER_RGBA_TEX_ALPHA:
       return SHADER(
         #ifdef GL_ES
         precision mediump float;
         #endif
         varying vec2 v_texCoord;
         uniform sampler2D s_texture;
         uniform float alpha;
         void main() {
           vec4 texColor = texture2D(s_texture, v_texCoord);
           gl_FragColor = texColor * alpha;
         });
     default:
       printf("Shader source requested for unknown shader\n");
       return "";
   }
 }

 int GetProgramIdx(ShaderID v, ShaderID f) {
   return v * SHADER_ID_MAX + f;
 }

 static void ReportAnyShaderCompilationErrors(GLuint shader, ShaderID id) {
   GLint status;
   glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
   if (status)
     return;
   // Get the length of the log string
   GLsizei length;
   glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &length);
   std::unique_ptr<GLchar[]> log(new GLchar[length + 1]);
   glGetShaderInfoLog(shader, length, nullptr, log.get());
   LOG(ERROR) << log.get() << " in shader " << ShaderNameFromID(id);
 }

 static int ActivateShader(ShaderID v, ShaderID f, float* layer_transform) {
   int program_index = GetProgramIdx(v, f);
   if (!g_program_objects[program_index]) {
     g_program_objects[program_index] = glCreateProgramObjectARB();
     GLenum vs = glCreateShaderObjectARB(GL_VERTEX_SHADER);
     GLenum fs = glCreateShaderObjectARB(GL_FRAGMENT_SHADER);
     const char* vs_source = GetShaderSource(v);
     const char* fs_source = GetShaderSource(f);
     glShaderSourceARB(vs, 1, &vs_source, 0);
     glShaderSourceARB(fs, 1, &fs_source, 0);
     glCompileShaderARB(vs);
     ReportAnyShaderCompilationErrors(vs, v);
     glCompileShaderARB(fs);
     ReportAnyShaderCompilationErrors(fs, f);
     glAttachObjectARB(g_program_objects[program_index], vs);
     glAttachObjectARB(g_program_objects[program_index], fs);
     glBindAttribLocationARB(g_program_objects[program_index],
                             kPositionLocation,
                             "a_position");
     glBindAttribLocationARB(g_program_objects[program_index],
                             kTexCoordLocation,
                             "a_texCoord");
     glLinkProgramARB(g_program_objects[program_index]);
   }
   if (g_active_index != program_index)
     glUseProgramObjectARB(g_program_objects[program_index]);
   g_active_index = program_index;

   g_current_layer_transform = layer_transform;

   return g_program_objects[program_index];
 }

 void ConfigAndActivateShaderForNode(CCNode* n) {
   ShaderID vs = n->vertex_shader();
   ShaderID fs = n->fragment_shader();
   float* transform = n->transform();
   int program = ActivateShader(vs, fs, transform);
   if (vs == VERTEX_SHADER_POS_TEX_YUV_STRETCH) {
     GLint y_scale = glGetUniformLocationARB(program, "y_widthScaleFactor");
     GLint uv_scale = glGetUniformLocationARB(program, "uv_widthScaleFactor");
     glUniform1fARB(y_scale, 1.0);
     glUniform1fARB(uv_scale, 1.0);
   }
   if (vs == VERTEX_SHADER_POS_TEX_TRANSFORM) {
     GLint texTrans = glGetUniformLocationARB(program, "texTransform");
     glUniform4fARB(texTrans, 0.0, 0.0, 0.0, 0.0);
   }
   if (fs == FRAGMENT_SHADER_RGBA_TEX_FLIP_ALPHA) {
     DCHECK_EQ(n->num_textures(), 1u);
     DCHECK_NE(n->texture(0)->texID, -1);
     glActiveTexture(GL_TEXTURE0);
     glBindTexture(GL_TEXTURE_2D, n->texture(0)->texID);
     int sTexLoc = glGetUniformLocationARB(program, "s_texture");
     glUniform1iARB(sTexLoc, 0);
   }
   if (fs == FRAGMENT_SHADER_YUV_VIDEO) {
     DCHECK_EQ(n->num_textures(), 3u);
     DCHECK_NE(n->texture(0)->texID, -1);
     DCHECK_NE(n->texture(1)->texID, -1);
     DCHECK_NE(n->texture(2)->texID, -1);
     // Bind Y tex.
     glActiveTexture(GL_TEXTURE0);
     glBindTexture(GL_TEXTURE_2D, n->texture(0)->texID);
     int yTexLoc = glGetUniformLocationARB(program, "y_texture");
     glUniform1iARB(yTexLoc, 0);
     // Bind U tex.
     glActiveTexture(GL_TEXTURE0 + 1);
     glBindTexture(GL_TEXTURE_2D, n->texture(1)->texID);
     int uTexLoc = glGetUniformLocationARB(program, "u_texture");
     glUniform1iARB(uTexLoc, 1);
     // Bind V tex.
     glActiveTexture(GL_TEXTURE0 + 2);
     glBindTexture(GL_TEXTURE_2D, n->texture(2)->texID);
     int vTexLoc = glGetUniformLocationARB(program, "v_texture");
     glUniform1iARB(vTexLoc, 2);
     // Set YUV offset.
     int yuvAdjLoc = glGetUniformLocationARB(program, "yuv_adj");
     glUniform3fARB(yuvAdjLoc, -0.0625f, -0.5f, -0.5f);
     // Set YUV matrix.
     int ccMatLoc = glGetUniformLocationARB(program, "cc_matrix");
     glUniformMatrix3fvARB(ccMatLoc, 1, false, yuv2RGB);
   }
   GLint alpha = glGetUniformLocationARB(program, "alpha");
   glUniform1fARB(alpha, 0.9);
 }

 void ConfigAndActivateShaderForTiling(ContentLayerNode* n) {
   int program = ActivateShader(VERTEX_SHADER_POS_TEX_TRANSFORM,
                                FRAGMENT_SHADER_RGBA_TEX_ALPHA,
                                n->transform());
   GLint texTrans = glGetUniformLocationARB(program, "texTransform");
   glUniform4fARB(texTrans, 0.0, 0.0, 1.0, 1.0);
   GLint alpha = glGetUniformLocationARB(program, "alpha");
   glUniform1fARB(alpha, 0.9);

   g_current_tile_layer_width = n->width();
   g_current_tile_layer_height = n->height();
   g_current_tile_width = n->tile_width();
   g_current_tile_height = n->tile_height();
 }

 void DeleteShaders() {
   g_active_index = -1;
   glUseProgramObjectARB(0);
   for (int i = 0; i < SHADER_ID_MAX*SHADER_ID_MAX; ++i) {
     if (g_program_objects[i]) {
       glDeleteObjectARB(g_program_objects[i]);
     }
     g_program_objects[i] = 0;
   }
 }

 void InitBuffers() {
   // Vertex positions and texture coordinates for the 4 corners of a 1x1 quad.
   float vertices[] = { -0.5f,  0.5f, 0.0f, 0.0f,  1.0f,
                        -0.5f, -0.5f, 0.0f, 0.0f,  0.0f,
                        0.5f,  -0.5f, 0.0f, 1.0f,  0.0f,
                        0.5f,   0.5f, 0.0f, 1.0f,  1.0f };
   uint16_t indices[] = { 0, 1, 2, 0, 2, 3};

   glGenBuffers(1, &g_quad_vertices_vbo);
   glGenBuffers(1, &g_quad_elements_vbo);
   glBindBuffer(GL_ARRAY_BUFFER, g_quad_vertices_vbo);
   glBufferData(GL_ARRAY_BUFFER,
                sizeof(vertices),
                vertices,
                GL_STATIC_DRAW);
   glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_quad_elements_vbo);
   glBufferData(GL_ELEMENT_ARRAY_BUFFER,
                sizeof(indices),
                indices,
                GL_STATIC_DRAW);
 }

 void BeginFrame() {
   glBindBuffer(GL_ARRAY_BUFFER, g_quad_vertices_vbo);
   glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_quad_elements_vbo);
   unsigned offset = 0;
   glVertexAttribPointer(kPositionLocation,
                         3,
                         GL_FLOAT,
                         false,
                         5 * sizeof(float),
                         reinterpret_cast<void*>(offset));
   offset += 3 * sizeof(float);
   glVertexAttribPointer(kTexCoordLocation,
                         2,
                         GL_FLOAT,
                         false,
                         5 * sizeof(float),
                         reinterpret_cast<void*>(offset));
   glEnableVertexAttribArray(kPositionLocation);
   glEnableVertexAttribArray(kTexCoordLocation);
 }

 void DrawQuad(float width, float height) {
   float mv_transform[16];
   float proj_transform[16];
   Scale(g_current_layer_transform, mv_transform, width, height, 1.0);
   Project(mv_transform, proj_transform);
   GLint mat = glGetUniformLocationARB(g_program_objects[g_active_index],
                                       "matrix");
   glUniformMatrix4fvARB(mat, 1, GL_TRUE, proj_transform);

   glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0);
 }

 void DrawTileQuad(GLuint texID, int x, int y) {
   float left = g_current_tile_width*x;
   float top = g_current_tile_height*y;
   if (left > g_current_tile_layer_width || top > g_current_tile_layer_height)
     return;

   float right = min(left+g_current_tile_width, g_current_tile_layer_width);
   float bottom = min(top+g_current_tile_height, g_current_tile_layer_height);
   float width = right-left;
   float height = bottom-top;

   int prog = g_program_objects[g_active_index];

   // Scale the texture if the full tile rectangle doesn't get drawn.
   float u_scale = width / g_current_tile_width;
   float v_scale = height / g_current_tile_height;
   GLint texTrans = glGetUniformLocationARB(prog, "texTransform");
   glUniform4fARB(texTrans, 0.0, 0.0, u_scale, v_scale);

   glActiveTexture(GL_TEXTURE0);
   glBindTexture(GL_TEXTURE_2D, texID);
   int texLoc = glGetUniformLocationARB(prog, "s_texture");
   glUniform1iARB(texLoc, 0);

   float mv_transform[16];
   float proj_transform[16];
   Scale(g_current_layer_transform, mv_transform, width, height, 1.0);

   // We have to position the tile by its center.
   float center_x = (left+right)/2 - g_current_tile_layer_width/2;
   float center_y = (top+bottom)/2 - g_current_tile_layer_height/2;
   TranslateInPlace(mv_transform, center_x, center_y, 0.0);

   Project(mv_transform, proj_transform);
   GLint mat = glGetUniformLocationARB(prog, "matrix");
   glUniformMatrix4fvARB(mat, 1, GL_TRUE, proj_transform);

   glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0);
 }
	// Copyright (c) 2011 The Chromium Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "gpu/tools/compositor_model_bench/shaders.h"

	#include <stdint.h>

	#include <algorithm>
	#include <memory>

	#include "gpu/tools/compositor_model_bench/render_model_utils.h"
	#include "gpu/tools/compositor_model_bench/render_tree.h"

	using std::min;

	static const int kPositionLocation = 0;
	static const int kTexCoordLocation = 1;

	static unsigned g_quad_vertices_vbo;
	static unsigned g_quad_elements_vbo;

	// Store a pointer to the transform matrix of the active layer (the complete
	// transform isn't build until we draw the quad; then we can apply
	// translation/scaling/projection)
	static float* g_current_layer_transform;

	// In addition to the transform, store other useful information about tiled
	// layers that we'll need to render each tile's quad
	static float g_current_tile_layer_width;
	static float g_current_tile_layer_height;
	static float g_current_tile_width;
	static float g_current_tile_height;

	static const float yuv2RGB[9] = {
	1.164f, 1.164f, 1.164f,
	0.f, -.391f, 2.018f,
	1.596f, -.813f, 0.f
	};

	// Store shader programs in a sparse array so that they can be addressed easily.
	static int g_program_objects[SHADER_ID_MAX*SHADER_ID_MAX];
	static int g_active_index = -1;

	///////////////////////////////////////////////////////////////////////////////
	// L R B T N F
	// glOrtho(0, WINDOW_WIDTH, WINDOW_HEIGHT, 0, -1, 1); // column major

	static float g_projection_matrix[] = {
	2.0 / WINDOW_WIDTH, 0.0, 0.0, 0.0,
	0.0, 2.0 / -WINDOW_HEIGHT, 0.0, 0.0,
	0.0, 0.0, -1.0, 0.0,
	-1.0, 1.0, 0.0, 1.0
	};

	#define ADDR(i, j) (i4 + j) / column major */
	static void Project(const float* v, float* p) {
	for (int i = 0; i < 4; ++i) {
	for (int j = 0; j < 4; ++j) {
	p[ADDR(i, j)] = 0;
	for (int k = 0; k < 4; ++k) {
	p[ADDR(i, j)] += g_projection_matrix[ADDR(k, i)] * v[ADDR(j, k)];
	}
	}
	}
	}

	static void Scale(const float* in, float* out, float sx, float sy, float sz) {
	for (int i = 0; i < 4; ++i)
	out[i] = in[i] * sx;
	for (int j = 4; j < 8; ++j)
	out[j] = in[j] * sy;
	for (int k = 8; k < 12; ++k)
	out[k] = in[k] * sz;
	for (int l = 12; l < 16; ++l)
	out[l] = in[l];
	}

	static void TranslateInPlace(float* m, float tx, float ty, float tz) {
	m[12] += tx;
	m[13] += ty;
	m[14] += tz;
	}

	///////////////////////////////////////////////////////////////////////////////

	ShaderID ShaderIDFromString(const std::string& name) {
	if (name == "VertexShaderPosTexYUVStretch")
	return VERTEX_SHADER_POS_TEX_YUV_STRETCH;
	if (name == "VertexShaderPosTex")
	return VERTEX_SHADER_POS_TEX;
	if (name == "VertexShaderPosTexTransform")
	return VERTEX_SHADER_POS_TEX_TRANSFORM;
	if (name == "FragmentShaderYUVVideo")
	return FRAGMENT_SHADER_YUV_VIDEO;
	if (name == "FragmentShaderRGBATexFlipAlpha")
	return FRAGMENT_SHADER_RGBA_TEX_FLIP_ALPHA;
	if (name == "FragmentShaderRGBATexAlpha")
	return FRAGMENT_SHADER_RGBA_TEX_ALPHA;
	return SHADER_UNRECOGNIZED;
	}

	std::string ShaderNameFromID(ShaderID id) {
	switch (id) {
	case VERTEX_SHADER_POS_TEX_YUV_STRETCH:
	return "VertexShaderPosTexYUVStretch";
	case VERTEX_SHADER_POS_TEX:
	return "VertexShaderPosTex";
	case VERTEX_SHADER_POS_TEX_TRANSFORM:
	return "VertexShaderPosTexTransform";
	case FRAGMENT_SHADER_YUV_VIDEO:
	return "FragmentShaderYUVVideo";
	case FRAGMENT_SHADER_RGBA_TEX_FLIP_ALPHA:
	return "FragmentShaderRGBATexFlipAlpha";
	case FRAGMENT_SHADER_RGBA_TEX_ALPHA:
	return "FragmentShaderRGBATexAlpha";
	default:
	return "(unknown shader)";
	}
	}

	#define SHADER0(Src) #Src
	#define SHADER(Src) SHADER0(Src)

	const char* GetShaderSource(ShaderID shader) {
	switch (shader) {
	case VERTEX_SHADER_POS_TEX_YUV_STRETCH:
	return SHADER(
	#ifdef GL_ES
	precision mediump float;
	#endif
	attribute vec4 a_position;
	attribute vec2 a_texCoord;
	uniform mat4 matrix;
	varying vec2 y_texCoord;
	varying vec2 uv_texCoord;
	uniform float y_widthScaleFactor;
	uniform float uv_widthScaleFactor;
	void main() {
	gl_Position = matrix * a_position;
	y_texCoord = vec2(y_widthScaleFactor * a_texCoord.x,
	a_texCoord.y);
	uv_texCoord = vec2(uv_widthScaleFactor * a_texCoord.x,
	a_texCoord.y);
	});
	case VERTEX_SHADER_POS_TEX:
	return SHADER(
	attribute vec4 a_position;
	attribute vec2 a_texCoord;
	uniform mat4 matrix;
	varying vec2 v_texCoord;
	void main() {
	gl_Position = matrix * a_position;
	v_texCoord = a_texCoord;
	});
	case VERTEX_SHADER_POS_TEX_TRANSFORM:
	return SHADER(
	attribute vec4 a_position;
	attribute vec2 a_texCoord;
	uniform mat4 matrix;
	uniform vec4 texTransform;
	varying vec2 v_texCoord;
	void main() {
	gl_Position = matrix * a_position;
	v_texCoord = a_texCoord*texTransform.zw + texTransform.xy;
	});
	case FRAGMENT_SHADER_YUV_VIDEO:
	return SHADER(
	#ifdef GL_ES
	precision mediump float;
	precision mediump int;
	#endif
	varying vec2 y_texCoord;
	varying vec2 uv_texCoord;
	uniform sampler2D y_texture;
	uniform sampler2D u_texture;
	uniform sampler2D v_texture;
	uniform float alpha;
	uniform vec3 yuv_adj;
	uniform mat3 cc_matrix;
	void main() {
	float y_raw = texture2D(y_texture, y_texCoord).x;
	float u_unsigned = texture2D(u_texture, uv_texCoord).x;
	float v_unsigned = texture2D(v_texture, uv_texCoord).x;
	vec3 yuv = vec3(y_raw, u_unsigned, v_unsigned) + yuv_adj;
	vec3 rgb = cc_matrix * yuv;
	gl_FragColor = vec4(rgb, 1.0) * alpha;
	});
	case FRAGMENT_SHADER_RGBA_TEX_FLIP_ALPHA:
	return SHADER(
	#ifdef GL_ES
	precision mediump float;
	#endif
	varying vec2 v_texCoord;
	uniform sampler2D s_texture;
	uniform float alpha;
	void main() {
	vec4 texColor = texture2D(s_texture,
	vec2(v_texCoord.x, 1.0 - v_texCoord.y));
	gl_FragColor = vec4(texColor.x,
	texColor.y,
	texColor.z,
	texColor.w) * alpha;
	});
	case FRAGMENT_SHADER_RGBA_TEX_ALPHA:
	return SHADER(
	#ifdef GL_ES
	precision mediump float;
	#endif
	varying vec2 v_texCoord;
	uniform sampler2D s_texture;
	uniform float alpha;
	void main() {
	vec4 texColor = texture2D(s_texture, v_texCoord);
	gl_FragColor = texColor * alpha;
	});
	default:
	printf("Shader source requested for unknown shader\n");
	return "";
	}
	}

	int GetProgramIdx(ShaderID v, ShaderID f) {
	return v * SHADER_ID_MAX + f;
	}

	static void ReportAnyShaderCompilationErrors(GLuint shader, ShaderID id) {
	GLint status;
	glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
	if (status)
	return;
	// Get the length of the log string
	GLsizei length;
	glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &length);
	std::unique_ptr<GLchar[]> log(new GLchar[length + 1]);
	glGetShaderInfoLog(shader, length, nullptr, log.get());
	LOG(ERROR) << log.get() << " in shader " << ShaderNameFromID(id);
	}

	static int ActivateShader(ShaderID v, ShaderID f, float* layer_transform) {
	int program_index = GetProgramIdx(v, f);
	if (!g_program_objects[program_index]) {
	g_program_objects[program_index] = glCreateProgramObjectARB();
	GLenum vs = glCreateShaderObjectARB(GL_VERTEX_SHADER);
	GLenum fs = glCreateShaderObjectARB(GL_FRAGMENT_SHADER);
	const char* vs_source = GetShaderSource(v);
	const char* fs_source = GetShaderSource(f);
	glShaderSourceARB(vs, 1, &vs_source, 0);
	glShaderSourceARB(fs, 1, &fs_source, 0);
	glCompileShaderARB(vs);
	ReportAnyShaderCompilationErrors(vs, v);
	glCompileShaderARB(fs);
	ReportAnyShaderCompilationErrors(fs, f);
	glAttachObjectARB(g_program_objects[program_index], vs);
	glAttachObjectARB(g_program_objects[program_index], fs);
	glBindAttribLocationARB(g_program_objects[program_index],
	kPositionLocation,
	"a_position");
	glBindAttribLocationARB(g_program_objects[program_index],
	kTexCoordLocation,
	"a_texCoord");
	glLinkProgramARB(g_program_objects[program_index]);
	}
	if (g_active_index != program_index)
	glUseProgramObjectARB(g_program_objects[program_index]);
	g_active_index = program_index;

	g_current_layer_transform = layer_transform;

	return g_program_objects[program_index];
	}

	void ConfigAndActivateShaderForNode(CCNode* n) {
	ShaderID vs = n->vertex_shader();
	ShaderID fs = n->fragment_shader();
	float* transform = n->transform();
	int program = ActivateShader(vs, fs, transform);
	if (vs == VERTEX_SHADER_POS_TEX_YUV_STRETCH) {
	GLint y_scale = glGetUniformLocationARB(program, "y_widthScaleFactor");
	GLint uv_scale = glGetUniformLocationARB(program, "uv_widthScaleFactor");
	glUniform1fARB(y_scale, 1.0);
	glUniform1fARB(uv_scale, 1.0);
	}
	if (vs == VERTEX_SHADER_POS_TEX_TRANSFORM) {
	GLint texTrans = glGetUniformLocationARB(program, "texTransform");
	glUniform4fARB(texTrans, 0.0, 0.0, 0.0, 0.0);
	}
	if (fs == FRAGMENT_SHADER_RGBA_TEX_FLIP_ALPHA) {
	DCHECK_EQ(n->num_textures(), 1u);
	DCHECK_NE(n->texture(0)->texID, -1);
	glActiveTexture(GL_TEXTURE0);
	glBindTexture(GL_TEXTURE_2D, n->texture(0)->texID);
	int sTexLoc = glGetUniformLocationARB(program, "s_texture");
	glUniform1iARB(sTexLoc, 0);
	}
	if (fs == FRAGMENT_SHADER_YUV_VIDEO) {
	DCHECK_EQ(n->num_textures(), 3u);
	DCHECK_NE(n->texture(0)->texID, -1);
	DCHECK_NE(n->texture(1)->texID, -1);
	DCHECK_NE(n->texture(2)->texID, -1);
	// Bind Y tex.
	glActiveTexture(GL_TEXTURE0);
	glBindTexture(GL_TEXTURE_2D, n->texture(0)->texID);
	int yTexLoc = glGetUniformLocationARB(program, "y_texture");
	glUniform1iARB(yTexLoc, 0);
	// Bind U tex.
	glActiveTexture(GL_TEXTURE0 + 1);
	glBindTexture(GL_TEXTURE_2D, n->texture(1)->texID);
	int uTexLoc = glGetUniformLocationARB(program, "u_texture");
	glUniform1iARB(uTexLoc, 1);
	// Bind V tex.
	glActiveTexture(GL_TEXTURE0 + 2);
	glBindTexture(GL_TEXTURE_2D, n->texture(2)->texID);
	int vTexLoc = glGetUniformLocationARB(program, "v_texture");
	glUniform1iARB(vTexLoc, 2);
	// Set YUV offset.
	int yuvAdjLoc = glGetUniformLocationARB(program, "yuv_adj");
	glUniform3fARB(yuvAdjLoc, -0.0625f, -0.5f, -0.5f);
	// Set YUV matrix.
	int ccMatLoc = glGetUniformLocationARB(program, "cc_matrix");
	glUniformMatrix3fvARB(ccMatLoc, 1, false, yuv2RGB);
	}
	GLint alpha = glGetUniformLocationARB(program, "alpha");
	glUniform1fARB(alpha, 0.9);
	}

	void ConfigAndActivateShaderForTiling(ContentLayerNode* n) {
	int program = ActivateShader(VERTEX_SHADER_POS_TEX_TRANSFORM,
	FRAGMENT_SHADER_RGBA_TEX_ALPHA,
	n->transform());
	GLint texTrans = glGetUniformLocationARB(program, "texTransform");
	glUniform4fARB(texTrans, 0.0, 0.0, 1.0, 1.0);
	GLint alpha = glGetUniformLocationARB(program, "alpha");
	glUniform1fARB(alpha, 0.9);

	g_current_tile_layer_width = n->width();
	g_current_tile_layer_height = n->height();
	g_current_tile_width = n->tile_width();
	g_current_tile_height = n->tile_height();
	}

	void DeleteShaders() {
	g_active_index = -1;
	glUseProgramObjectARB(0);
	for (int i = 0; i < SHADER_ID_MAX*SHADER_ID_MAX; ++i) {
	if (g_program_objects[i]) {
	glDeleteObjectARB(g_program_objects[i]);
	}
	g_program_objects[i] = 0;
	}
	}

	void InitBuffers() {
	// Vertex positions and texture coordinates for the 4 corners of a 1x1 quad.
	float vertices[] = { -0.5f, 0.5f, 0.0f, 0.0f, 1.0f,
	-0.5f, -0.5f, 0.0f, 0.0f, 0.0f,
	0.5f, -0.5f, 0.0f, 1.0f, 0.0f,
	0.5f, 0.5f, 0.0f, 1.0f, 1.0f };
	uint16_t indices[] = { 0, 1, 2, 0, 2, 3};

	glGenBuffers(1, &g_quad_vertices_vbo);
	glGenBuffers(1, &g_quad_elements_vbo);
	glBindBuffer(GL_ARRAY_BUFFER, g_quad_vertices_vbo);
	glBufferData(GL_ARRAY_BUFFER,
	sizeof(vertices),
	vertices,
	GL_STATIC_DRAW);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_quad_elements_vbo);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER,
	sizeof(indices),
	indices,
	GL_STATIC_DRAW);
	}

	void BeginFrame() {
	glBindBuffer(GL_ARRAY_BUFFER, g_quad_vertices_vbo);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_quad_elements_vbo);
	unsigned offset = 0;
	glVertexAttribPointer(kPositionLocation,
	3,
	GL_FLOAT,
	false,
	5 * sizeof(float),
	reinterpret_cast<void*>(offset));
	offset += 3 * sizeof(float);
	glVertexAttribPointer(kTexCoordLocation,
	2,
	GL_FLOAT,
	false,
	5 * sizeof(float),
	reinterpret_cast<void*>(offset));
	glEnableVertexAttribArray(kPositionLocation);
	glEnableVertexAttribArray(kTexCoordLocation);
	}

	void DrawQuad(float width, float height) {
	float mv_transform[16];
	float proj_transform[16];
	Scale(g_current_layer_transform, mv_transform, width, height, 1.0);
	Project(mv_transform, proj_transform);
	GLint mat = glGetUniformLocationARB(g_program_objects[g_active_index],
	"matrix");
	glUniformMatrix4fvARB(mat, 1, GL_TRUE, proj_transform);

	glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0);
	}

	void DrawTileQuad(GLuint texID, int x, int y) {
	float left = g_current_tile_width*x;
	float top = g_current_tile_height*y;
	if (left > g_current_tile_layer_width \|\| top > g_current_tile_layer_height)
	return;

	float right = min(left+g_current_tile_width, g_current_tile_layer_width);
	float bottom = min(top+g_current_tile_height, g_current_tile_layer_height);
	float width = right-left;
	float height = bottom-top;

	int prog = g_program_objects[g_active_index];

	// Scale the texture if the full tile rectangle doesn't get drawn.
	float u_scale = width / g_current_tile_width;
	float v_scale = height / g_current_tile_height;
	GLint texTrans = glGetUniformLocationARB(prog, "texTransform");
	glUniform4fARB(texTrans, 0.0, 0.0, u_scale, v_scale);

	glActiveTexture(GL_TEXTURE0);
	glBindTexture(GL_TEXTURE_2D, texID);
	int texLoc = glGetUniformLocationARB(prog, "s_texture");
	glUniform1iARB(texLoc, 0);

	float mv_transform[16];
	float proj_transform[16];
	Scale(g_current_layer_transform, mv_transform, width, height, 1.0);

	// We have to position the tile by its center.
	float center_x = (left+right)/2 - g_current_tile_layer_width/2;
	float center_y = (top+bottom)/2 - g_current_tile_layer_height/2;
	TranslateInPlace(mv_transform, center_x, center_y, 0.0);

	Project(mv_transform, proj_transform);
	GLint mat = glGetUniformLocationARB(prog, "matrix");
	glUniformMatrix4fvARB(mat, 1, GL_TRUE, proj_transform);

	glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0);
	}