mirror of
https://github.com/flutter/flutter.git
synced 2026-02-20 02:29:02 +08:00
451 lines
15 KiB
C++
451 lines
15 KiB
C++
// 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 <algorithm>
|
|
|
|
#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(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);
|
|
});
|
|
break;
|
|
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;
|
|
});
|
|
break;
|
|
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;
|
|
});
|
|
break;
|
|
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;
|
|
});
|
|
break;
|
|
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;
|
|
});
|
|
break;
|
|
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;
|
|
});
|
|
break;
|
|
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);
|
|
scoped_ptr<GLchar[]> log(new GLchar[length+1]);
|
|
glGetShaderInfoLog(shader, length, NULL, 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);
|
|
}
|
|
|