Convert tabs to spaces.
Change-Id: I5d3ae48af79b19b6d293deff0521e4bb57d5114b
This commit is contained in:
Romain Guy
@@ -36,8 +36,8 @@ using namespace uirenderer;
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
static struct {
|
||||
jclass clazz;
|
||||
jmethodID set;
|
||||
jclass clazz;
|
||||
jmethodID set;
|
||||
} gRectClassInfo;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
@@ -114,12 +114,12 @@ static bool android_view_GLES20Renderer_clipRect(JNIEnv* env, jobject canvas,
|
||||
static bool android_view_GLES20Renderer_getClipBounds(JNIEnv* env, jobject canvas,
|
||||
OpenGLRenderer* renderer, jobject rect) {
|
||||
|
||||
const android::uirenderer::Rect& bounds(renderer->getClipBounds());
|
||||
const android::uirenderer::Rect& bounds(renderer->getClipBounds());
|
||||
|
||||
env->CallVoidMethod(rect, gRectClassInfo.set,
|
||||
int(bounds.left), int(bounds.top), int(bounds.right), int(bounds.bottom));
|
||||
env->CallVoidMethod(rect, gRectClassInfo.set,
|
||||
int(bounds.left), int(bounds.top), int(bounds.right), int(bounds.bottom));
|
||||
|
||||
return !bounds.isEmpty();
|
||||
return !bounds.isEmpty();
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
@@ -128,32 +128,32 @@ static bool android_view_GLES20Renderer_getClipBounds(JNIEnv* env, jobject canva
|
||||
|
||||
static void android_view_GLES20Renderer_translate(JNIEnv* env, jobject canvas,
|
||||
OpenGLRenderer* renderer, jfloat dx, jfloat dy) {
|
||||
renderer->translate(dx, dy);
|
||||
renderer->translate(dx, dy);
|
||||
}
|
||||
|
||||
static void android_view_GLES20Renderer_rotate(JNIEnv* env, jobject canvas,
|
||||
OpenGLRenderer* renderer, jfloat degrees) {
|
||||
renderer->rotate(degrees);
|
||||
renderer->rotate(degrees);
|
||||
}
|
||||
|
||||
static void android_view_GLES20Renderer_scale(JNIEnv* env, jobject canvas,
|
||||
OpenGLRenderer* renderer, jfloat sx, jfloat sy) {
|
||||
renderer->scale(sx, sy);
|
||||
renderer->scale(sx, sy);
|
||||
}
|
||||
|
||||
static void android_view_GLES20Renderer_setMatrix(JNIEnv* env, jobject canvas,
|
||||
OpenGLRenderer* renderer, SkMatrix* matrix) {
|
||||
renderer->setMatrix(matrix);
|
||||
renderer->setMatrix(matrix);
|
||||
}
|
||||
|
||||
static void android_view_GLES20Renderer_getMatrix(JNIEnv* env, jobject canvas,
|
||||
OpenGLRenderer* renderer, SkMatrix* matrix) {
|
||||
renderer->getMatrix(matrix);
|
||||
renderer->getMatrix(matrix);
|
||||
}
|
||||
|
||||
static void android_view_GLES20Renderer_concatMatrix(JNIEnv* env, jobject canvas,
|
||||
OpenGLRenderer* renderer, SkMatrix* matrix) {
|
||||
renderer->concatMatrix(matrix);
|
||||
renderer->concatMatrix(matrix);
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
@@ -217,8 +217,8 @@ static JNINativeMethod gMethods[] = {
|
||||
LOG_FATAL_IF(! var, "Unable to find method " methodName);
|
||||
|
||||
int register_android_view_GLES20Canvas(JNIEnv* env) {
|
||||
FIND_CLASS(gRectClassInfo.clazz, "android/graphics/Rect");
|
||||
GET_METHOD_ID(gRectClassInfo.set, gRectClassInfo.clazz, "set", "(IIII)V");
|
||||
FIND_CLASS(gRectClassInfo.clazz, "android/graphics/Rect");
|
||||
GET_METHOD_ID(gRectClassInfo.set, gRectClassInfo.clazz, "set", "(IIII)V");
|
||||
|
||||
return AndroidRuntime::registerNativeMethods(env, kClassPathName, gMethods, NELEM(gMethods));
|
||||
}
|
||||
|
||||
@@ -30,118 +30,118 @@ namespace android {
|
||||
namespace uirenderer {
|
||||
|
||||
void Matrix4::loadIdentity() {
|
||||
data[0] = 1.0f;
|
||||
data[1] = 0.0f;
|
||||
data[2] = 0.0f;
|
||||
data[3] = 0.0f;
|
||||
data[0] = 1.0f;
|
||||
data[1] = 0.0f;
|
||||
data[2] = 0.0f;
|
||||
data[3] = 0.0f;
|
||||
|
||||
data[4] = 0.0f;
|
||||
data[5] = 1.0f;
|
||||
data[6] = 0.0f;
|
||||
data[7] = 0.0f;
|
||||
data[4] = 0.0f;
|
||||
data[5] = 1.0f;
|
||||
data[6] = 0.0f;
|
||||
data[7] = 0.0f;
|
||||
|
||||
data[8] = 0.0f;
|
||||
data[9] = 0.0f;
|
||||
data[10] = 1.0f;
|
||||
data[11] = 0.0f;
|
||||
data[8] = 0.0f;
|
||||
data[9] = 0.0f;
|
||||
data[10] = 1.0f;
|
||||
data[11] = 0.0f;
|
||||
|
||||
data[12] = 0.0f;
|
||||
data[13] = 0.0f;
|
||||
data[14] = 0.0f;
|
||||
data[15] = 1.0f;
|
||||
data[12] = 0.0f;
|
||||
data[13] = 0.0f;
|
||||
data[14] = 0.0f;
|
||||
data[15] = 1.0f;
|
||||
}
|
||||
|
||||
void Matrix4::load(const float* v) {
|
||||
memcpy(data, v, sizeof(data));
|
||||
memcpy(data, v, sizeof(data));
|
||||
}
|
||||
|
||||
void Matrix4::load(const Matrix4& v) {
|
||||
memcpy(data, v.data, sizeof(data));
|
||||
memcpy(data, v.data, sizeof(data));
|
||||
}
|
||||
|
||||
void Matrix4::load(const SkMatrix& v) {
|
||||
memset(data, 0, sizeof(data));
|
||||
memset(data, 0, sizeof(data));
|
||||
|
||||
data[0] = v[SkMatrix::kMScaleX];
|
||||
data[4] = v[SkMatrix::kMSkewX];
|
||||
data[12] = v[SkMatrix::kMTransX];
|
||||
data[0] = v[SkMatrix::kMScaleX];
|
||||
data[4] = v[SkMatrix::kMSkewX];
|
||||
data[12] = v[SkMatrix::kMTransX];
|
||||
|
||||
data[1] = v[SkMatrix::kMSkewY];
|
||||
data[5] = v[SkMatrix::kMScaleY];
|
||||
data[13] = v[SkMatrix::kMTransY];
|
||||
data[1] = v[SkMatrix::kMSkewY];
|
||||
data[5] = v[SkMatrix::kMScaleY];
|
||||
data[13] = v[SkMatrix::kMTransY];
|
||||
|
||||
data[3] = v[SkMatrix::kMPersp0];
|
||||
data[7] = v[SkMatrix::kMPersp1];
|
||||
data[15] = v[SkMatrix::kMPersp2];
|
||||
data[3] = v[SkMatrix::kMPersp0];
|
||||
data[7] = v[SkMatrix::kMPersp1];
|
||||
data[15] = v[SkMatrix::kMPersp2];
|
||||
|
||||
data[10] = 1.0f;
|
||||
data[10] = 1.0f;
|
||||
}
|
||||
|
||||
void Matrix4::copyTo(SkMatrix& v) const {
|
||||
v.reset();
|
||||
v.reset();
|
||||
|
||||
v.set(SkMatrix::kMScaleX, data[0]);
|
||||
v.set(SkMatrix::kMSkewX, data[4]);
|
||||
v.set(SkMatrix::kMTransX, data[12]);
|
||||
v.set(SkMatrix::kMScaleX, data[0]);
|
||||
v.set(SkMatrix::kMSkewX, data[4]);
|
||||
v.set(SkMatrix::kMTransX, data[12]);
|
||||
|
||||
v.set(SkMatrix::kMSkewY, data[1]);
|
||||
v.set(SkMatrix::kMScaleY, data[5]);
|
||||
v.set(SkMatrix::kMTransY, data[13]);
|
||||
v.set(SkMatrix::kMSkewY, data[1]);
|
||||
v.set(SkMatrix::kMScaleY, data[5]);
|
||||
v.set(SkMatrix::kMTransY, data[13]);
|
||||
|
||||
v.set(SkMatrix::kMPersp0, data[3]);
|
||||
v.set(SkMatrix::kMPersp1, data[7]);
|
||||
v.set(SkMatrix::kMPersp2, data[15]);
|
||||
v.set(SkMatrix::kMPersp0, data[3]);
|
||||
v.set(SkMatrix::kMPersp1, data[7]);
|
||||
v.set(SkMatrix::kMPersp2, data[15]);
|
||||
}
|
||||
|
||||
void Matrix4::copyTo(float* v) const {
|
||||
memcpy(v, data, sizeof(data));
|
||||
memcpy(v, data, sizeof(data));
|
||||
}
|
||||
|
||||
void Matrix4::loadTranslate(float x, float y, float z) {
|
||||
loadIdentity();
|
||||
data[12] = x;
|
||||
data[13] = y;
|
||||
data[14] = z;
|
||||
loadIdentity();
|
||||
data[12] = x;
|
||||
data[13] = y;
|
||||
data[14] = z;
|
||||
}
|
||||
|
||||
void Matrix4::loadScale(float sx, float sy, float sz) {
|
||||
loadIdentity();
|
||||
data[0] = sx;
|
||||
data[5] = sy;
|
||||
data[10] = sz;
|
||||
loadIdentity();
|
||||
data[0] = sx;
|
||||
data[5] = sy;
|
||||
data[10] = sz;
|
||||
}
|
||||
|
||||
void Matrix4::loadRotate(float angle, float x, float y, float z) {
|
||||
data[3] = 0.0f;
|
||||
data[7] = 0.0f;
|
||||
data[11] = 0.0f;
|
||||
data[12] = 0.0f;
|
||||
data[13] = 0.0f;
|
||||
data[14] = 0.0f;
|
||||
data[15] = 1.0f;
|
||||
data[3] = 0.0f;
|
||||
data[7] = 0.0f;
|
||||
data[11] = 0.0f;
|
||||
data[12] = 0.0f;
|
||||
data[13] = 0.0f;
|
||||
data[14] = 0.0f;
|
||||
data[15] = 1.0f;
|
||||
|
||||
angle *= float(M_PI / 180.0f);
|
||||
float c = cosf(angle);
|
||||
float s = sinf(angle);
|
||||
angle *= float(M_PI / 180.0f);
|
||||
float c = cosf(angle);
|
||||
float s = sinf(angle);
|
||||
|
||||
const float length = sqrtf(x * x + y * y + z * z);
|
||||
const float nc = 1.0f - c;
|
||||
const float xy = x * y;
|
||||
const float yz = y * z;
|
||||
const float zx = z * x;
|
||||
const float xs = x * s;
|
||||
const float ys = y * s;
|
||||
const float zs = z * s;
|
||||
const float length = sqrtf(x * x + y * y + z * z);
|
||||
const float nc = 1.0f - c;
|
||||
const float xy = x * y;
|
||||
const float yz = y * z;
|
||||
const float zx = z * x;
|
||||
const float xs = x * s;
|
||||
const float ys = y * s;
|
||||
const float zs = z * s;
|
||||
|
||||
data[0] = x * x * nc + c;
|
||||
data[4] = xy * nc - zs;
|
||||
data[8] = zx * nc + ys;
|
||||
data[1] = xy * nc + zs;
|
||||
data[5] = y * y * nc + c;
|
||||
data[9] = yz * nc - xs;
|
||||
data[2] = zx * nc - ys;
|
||||
data[6] = yz * nc + xs;
|
||||
data[10] = z * z * nc + c;
|
||||
data[0] = x * x * nc + c;
|
||||
data[4] = xy * nc - zs;
|
||||
data[8] = zx * nc + ys;
|
||||
data[1] = xy * nc + zs;
|
||||
data[5] = y * y * nc + c;
|
||||
data[9] = yz * nc - xs;
|
||||
data[2] = zx * nc - ys;
|
||||
data[6] = yz * nc + xs;
|
||||
data[10] = z * z * nc + c;
|
||||
}
|
||||
|
||||
void Matrix4::loadMultiply(const Matrix4& u, const Matrix4& v) {
|
||||
@@ -179,25 +179,25 @@ void Matrix4::loadOrtho(float left, float right, float bottom, float top, float
|
||||
#define MUL_ADD_STORE(a, b, c) a = (a) * (b) + (c)
|
||||
|
||||
void Matrix4::mapRect(Rect& r) const {
|
||||
const float sx = data[0];
|
||||
const float sy = data[5];
|
||||
const float sx = data[0];
|
||||
const float sy = data[5];
|
||||
|
||||
const float tx = data[12];
|
||||
const float ty = data[13];
|
||||
const float tx = data[12];
|
||||
const float ty = data[13];
|
||||
|
||||
MUL_ADD_STORE(r.left, sx, tx);
|
||||
MUL_ADD_STORE(r.right, sx, tx);
|
||||
MUL_ADD_STORE(r.top, sy, ty);
|
||||
MUL_ADD_STORE(r.bottom, sy, ty);
|
||||
MUL_ADD_STORE(r.left, sx, tx);
|
||||
MUL_ADD_STORE(r.right, sx, tx);
|
||||
MUL_ADD_STORE(r.top, sy, ty);
|
||||
MUL_ADD_STORE(r.bottom, sy, ty);
|
||||
}
|
||||
|
||||
void Matrix4::dump() const {
|
||||
LOGD("Matrix4[");
|
||||
LOGD(" %f %f %f %f", data[0], data[4], data[ 8], data[12]);
|
||||
LOGD(" %f %f %f %f", data[1], data[5], data[ 9], data[13]);
|
||||
LOGD(" %f %f %f %f", data[2], data[6], data[10], data[14]);
|
||||
LOGD(" %f %f %f %f", data[3], data[7], data[11], data[15]);
|
||||
LOGD("]");
|
||||
LOGD("Matrix4[");
|
||||
LOGD(" %f %f %f %f", data[0], data[4], data[ 8], data[12]);
|
||||
LOGD(" %f %f %f %f", data[1], data[5], data[ 9], data[13]);
|
||||
LOGD(" %f %f %f %f", data[2], data[6], data[10], data[14]);
|
||||
LOGD(" %f %f %f %f", data[3], data[7], data[11], data[15]);
|
||||
LOGD("]");
|
||||
}
|
||||
|
||||
}; // namespace uirenderer
|
||||
|
||||
@@ -30,67 +30,67 @@ namespace uirenderer {
|
||||
|
||||
class Matrix4 {
|
||||
public:
|
||||
float data[16];
|
||||
float data[16];
|
||||
|
||||
Matrix4() {
|
||||
loadIdentity();
|
||||
}
|
||||
Matrix4() {
|
||||
loadIdentity();
|
||||
}
|
||||
|
||||
Matrix4(const float* v) {
|
||||
load(v);
|
||||
}
|
||||
Matrix4(const float* v) {
|
||||
load(v);
|
||||
}
|
||||
|
||||
Matrix4(const Matrix4& v) {
|
||||
load(v);
|
||||
}
|
||||
Matrix4(const Matrix4& v) {
|
||||
load(v);
|
||||
}
|
||||
|
||||
Matrix4(const SkMatrix& v) {
|
||||
load(v);
|
||||
}
|
||||
Matrix4(const SkMatrix& v) {
|
||||
load(v);
|
||||
}
|
||||
|
||||
void loadIdentity();
|
||||
void loadIdentity();
|
||||
|
||||
void load(const float* v);
|
||||
void load(const Matrix4& v);
|
||||
void load(const SkMatrix& v);
|
||||
void load(const float* v);
|
||||
void load(const Matrix4& v);
|
||||
void load(const SkMatrix& v);
|
||||
|
||||
void loadTranslate(float x, float y, float z);
|
||||
void loadScale(float sx, float sy, float sz);
|
||||
void loadRotate(float angle, float x, float y, float z);
|
||||
void loadMultiply(const Matrix4& u, const Matrix4& v);
|
||||
void loadTranslate(float x, float y, float z);
|
||||
void loadScale(float sx, float sy, float sz);
|
||||
void loadRotate(float angle, float x, float y, float z);
|
||||
void loadMultiply(const Matrix4& u, const Matrix4& v);
|
||||
|
||||
void loadOrtho(float left, float right, float bottom, float top, float near, float far);
|
||||
void loadOrtho(float left, float right, float bottom, float top, float near, float far);
|
||||
|
||||
void multiply(const Matrix4& v) {
|
||||
Matrix4 u;
|
||||
u.loadMultiply(*this, v);
|
||||
load(u);
|
||||
}
|
||||
void multiply(const Matrix4& v) {
|
||||
Matrix4 u;
|
||||
u.loadMultiply(*this, v);
|
||||
load(u);
|
||||
}
|
||||
|
||||
void translate(float x, float y, float z) {
|
||||
Matrix4 u;
|
||||
u.loadTranslate(x, y, z);
|
||||
multiply(u);
|
||||
}
|
||||
void translate(float x, float y, float z) {
|
||||
Matrix4 u;
|
||||
u.loadTranslate(x, y, z);
|
||||
multiply(u);
|
||||
}
|
||||
|
||||
void scale(float sx, float sy, float sz) {
|
||||
Matrix4 u;
|
||||
u.loadScale(sx, sy, sz);
|
||||
multiply(u);
|
||||
}
|
||||
void scale(float sx, float sy, float sz) {
|
||||
Matrix4 u;
|
||||
u.loadScale(sx, sy, sz);
|
||||
multiply(u);
|
||||
}
|
||||
|
||||
void rotate(float angle, float x, float y, float z) {
|
||||
Matrix4 u;
|
||||
u.loadRotate(angle, x, y, z);
|
||||
multiply(u);
|
||||
}
|
||||
void rotate(float angle, float x, float y, float z) {
|
||||
Matrix4 u;
|
||||
u.loadRotate(angle, x, y, z);
|
||||
multiply(u);
|
||||
}
|
||||
|
||||
void copyTo(float* v) const;
|
||||
void copyTo(SkMatrix& v) const;
|
||||
void copyTo(float* v) const;
|
||||
void copyTo(SkMatrix& v) const;
|
||||
|
||||
void mapRect(Rect& r) const;
|
||||
void mapRect(Rect& r) const;
|
||||
|
||||
void dump() const;
|
||||
void dump() const;
|
||||
|
||||
private:
|
||||
inline float get(int i, int j) const {
|
||||
@@ -98,7 +98,7 @@ private:
|
||||
}
|
||||
|
||||
inline void set(int i, int j, float v) {
|
||||
data[i * 4 + j] = v;
|
||||
data[i * 4 + j] = v;
|
||||
}
|
||||
}; // class Matrix4
|
||||
|
||||
|
||||
@@ -47,10 +47,10 @@ namespace uirenderer {
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
const SimpleVertex gDrawColorVertices[] = {
|
||||
V(0.0f, 0.0f),
|
||||
V(1.0f, 0.0f),
|
||||
V(0.0f, 1.0f),
|
||||
V(1.0f, 1.0f)
|
||||
V(0.0f, 0.0f),
|
||||
V(1.0f, 0.0f),
|
||||
V(0.0f, 1.0f),
|
||||
V(1.0f, 1.0f)
|
||||
};
|
||||
const GLsizei gDrawColorVertexStride = sizeof(SimpleVertex);
|
||||
const GLsizei gDrawColorVertexCount = 4;
|
||||
@@ -65,93 +65,93 @@ const GLsizei gDrawColorVertexCount = 4;
|
||||
#include "shaders/drawColor.frag"
|
||||
|
||||
Program::Program(const char* vertex, const char* fragment) {
|
||||
vertexShader = buildShader(vertex, GL_VERTEX_SHADER);
|
||||
fragmentShader = buildShader(fragment, GL_FRAGMENT_SHADER);
|
||||
vertexShader = buildShader(vertex, GL_VERTEX_SHADER);
|
||||
fragmentShader = buildShader(fragment, GL_FRAGMENT_SHADER);
|
||||
|
||||
id = glCreateProgram();
|
||||
glAttachShader(id, vertexShader);
|
||||
glAttachShader(id, fragmentShader);
|
||||
glLinkProgram(id);
|
||||
id = glCreateProgram();
|
||||
glAttachShader(id, vertexShader);
|
||||
glAttachShader(id, fragmentShader);
|
||||
glLinkProgram(id);
|
||||
|
||||
GLint status;
|
||||
glGetProgramiv(id, GL_LINK_STATUS, &status);
|
||||
if (status != GL_TRUE) {
|
||||
GLint infoLen = 0;
|
||||
glGetProgramiv(id, GL_INFO_LOG_LENGTH, &infoLen);
|
||||
if (infoLen > 1) {
|
||||
char* log = (char*) malloc(sizeof(char) * infoLen);
|
||||
glGetProgramInfoLog(id, infoLen, 0, log);
|
||||
LOGE("Error while linking shaders: %s", log);
|
||||
delete log;
|
||||
}
|
||||
glDeleteProgram(id);
|
||||
}
|
||||
GLint status;
|
||||
glGetProgramiv(id, GL_LINK_STATUS, &status);
|
||||
if (status != GL_TRUE) {
|
||||
GLint infoLen = 0;
|
||||
glGetProgramiv(id, GL_INFO_LOG_LENGTH, &infoLen);
|
||||
if (infoLen > 1) {
|
||||
char* log = (char*) malloc(sizeof(char) * infoLen);
|
||||
glGetProgramInfoLog(id, infoLen, 0, log);
|
||||
LOGE("Error while linking shaders: %s", log);
|
||||
delete log;
|
||||
}
|
||||
glDeleteProgram(id);
|
||||
}
|
||||
}
|
||||
|
||||
Program::~Program() {
|
||||
glDeleteShader(vertexShader);
|
||||
glDeleteShader(fragmentShader);
|
||||
glDeleteProgram(id);
|
||||
glDeleteShader(vertexShader);
|
||||
glDeleteShader(fragmentShader);
|
||||
glDeleteProgram(id);
|
||||
}
|
||||
|
||||
void Program::use() {
|
||||
glUseProgram(id);
|
||||
glUseProgram(id);
|
||||
}
|
||||
|
||||
int Program::addAttrib(const char* name) {
|
||||
int slot = glGetAttribLocation(id, name);
|
||||
attributes.add(name, slot);
|
||||
return slot;
|
||||
int slot = glGetAttribLocation(id, name);
|
||||
attributes.add(name, slot);
|
||||
return slot;
|
||||
}
|
||||
|
||||
int Program::getAttrib(const char* name) {
|
||||
return attributes.valueFor(name);
|
||||
return attributes.valueFor(name);
|
||||
}
|
||||
|
||||
int Program::addUniform(const char* name) {
|
||||
int slot = glGetUniformLocation(id, name);
|
||||
uniforms.add(name, slot);
|
||||
return slot;
|
||||
int slot = glGetUniformLocation(id, name);
|
||||
uniforms.add(name, slot);
|
||||
return slot;
|
||||
}
|
||||
|
||||
int Program::getUniform(const char* name) {
|
||||
return uniforms.valueFor(name);
|
||||
return uniforms.valueFor(name);
|
||||
}
|
||||
|
||||
GLuint Program::buildShader(const char* source, GLenum type) {
|
||||
GLuint shader = glCreateShader(type);
|
||||
glShaderSource(shader, 1, &source, 0);
|
||||
glCompileShader(shader);
|
||||
GLuint shader = glCreateShader(type);
|
||||
glShaderSource(shader, 1, &source, 0);
|
||||
glCompileShader(shader);
|
||||
|
||||
GLint status;
|
||||
glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
|
||||
if (status != GL_TRUE) {
|
||||
// Some drivers return wrong values for GL_INFO_LOG_LENGTH
|
||||
// use a fixed size instead
|
||||
GLchar log[512];
|
||||
glGetShaderInfoLog(shader, sizeof(log), 0, &log[0]);
|
||||
LOGE("Error while compiling shader: %s", log);
|
||||
glDeleteShader(shader);
|
||||
}
|
||||
GLint status;
|
||||
glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
|
||||
if (status != GL_TRUE) {
|
||||
// Some drivers return wrong values for GL_INFO_LOG_LENGTH
|
||||
// use a fixed size instead
|
||||
GLchar log[512];
|
||||
glGetShaderInfoLog(shader, sizeof(log), 0, &log[0]);
|
||||
LOGE("Error while compiling shader: %s", log);
|
||||
glDeleteShader(shader);
|
||||
}
|
||||
|
||||
return shader;
|
||||
return shader;
|
||||
}
|
||||
|
||||
DrawColorProgram::DrawColorProgram():
|
||||
Program(gDrawColorVertexShader, gDrawColorFragmentShader) {
|
||||
position = addAttrib("position");
|
||||
color = addAttrib("color");
|
||||
projection = addUniform("projection");
|
||||
modelView = addUniform("modelView");
|
||||
transform = addUniform("transform");
|
||||
Program(gDrawColorVertexShader, gDrawColorFragmentShader) {
|
||||
position = addAttrib("position");
|
||||
color = addAttrib("color");
|
||||
projection = addUniform("projection");
|
||||
modelView = addUniform("modelView");
|
||||
transform = addUniform("transform");
|
||||
}
|
||||
|
||||
void DrawColorProgram::use(const GLfloat* projectionMatrix, const GLfloat* modelViewMatrix,
|
||||
const GLfloat* transformMatrix) {
|
||||
Program::use();
|
||||
glUniformMatrix4fv(projection, 1, GL_FALSE, projectionMatrix);
|
||||
glUniformMatrix4fv(modelView, 1, GL_FALSE, modelViewMatrix);
|
||||
glUniformMatrix4fv(transform, 1, GL_FALSE, transformMatrix);
|
||||
Program::use();
|
||||
glUniformMatrix4fv(projection, 1, GL_FALSE, projectionMatrix);
|
||||
glUniformMatrix4fv(modelView, 1, GL_FALSE, modelViewMatrix);
|
||||
glUniformMatrix4fv(transform, 1, GL_FALSE, transformMatrix);
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
@@ -159,12 +159,12 @@ void DrawColorProgram::use(const GLfloat* projectionMatrix, const GLfloat* model
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
const Rect& Snapshot::getMappedClip() {
|
||||
if (flags & kFlagDirtyTransform) {
|
||||
flags &= ~kFlagDirtyTransform;
|
||||
mappedClip.set(clipRect);
|
||||
transform.mapRect(mappedClip);
|
||||
}
|
||||
return mappedClip;
|
||||
if (flags & kFlagDirtyTransform) {
|
||||
flags &= ~kFlagDirtyTransform;
|
||||
mappedClip.set(clipRect);
|
||||
transform.mapRect(mappedClip);
|
||||
}
|
||||
return mappedClip;
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
@@ -197,8 +197,8 @@ void OpenGLRenderer::setViewport(int width, int height) {
|
||||
}
|
||||
|
||||
void OpenGLRenderer::prepare() {
|
||||
mSnapshot = &mFirstSnapshot;
|
||||
mSaveCount = 0;
|
||||
mSnapshot = &mFirstSnapshot;
|
||||
mSaveCount = 0;
|
||||
|
||||
glDisable(GL_SCISSOR_TEST);
|
||||
|
||||
@@ -216,50 +216,50 @@ void OpenGLRenderer::prepare() {
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
int OpenGLRenderer::getSaveCount() const {
|
||||
return mSaveCount;
|
||||
return mSaveCount;
|
||||
}
|
||||
|
||||
int OpenGLRenderer::save(int flags) {
|
||||
return saveSnapshot();
|
||||
return saveSnapshot();
|
||||
}
|
||||
|
||||
void OpenGLRenderer::restore() {
|
||||
if (mSaveCount == 0) return;
|
||||
if (mSaveCount == 0) return;
|
||||
|
||||
if (restoreSnapshot()) {
|
||||
setScissorFromClip();
|
||||
}
|
||||
if (restoreSnapshot()) {
|
||||
setScissorFromClip();
|
||||
}
|
||||
}
|
||||
|
||||
void OpenGLRenderer::restoreToCount(int saveCount) {
|
||||
if (saveCount <= 0 || saveCount > mSaveCount) return;
|
||||
if (saveCount <= 0 || saveCount > mSaveCount) return;
|
||||
|
||||
bool restoreClip = false;
|
||||
bool restoreClip = false;
|
||||
|
||||
while (mSaveCount != saveCount - 1) {
|
||||
restoreClip |= restoreSnapshot();
|
||||
}
|
||||
while (mSaveCount != saveCount - 1) {
|
||||
restoreClip |= restoreSnapshot();
|
||||
}
|
||||
|
||||
if (restoreClip) {
|
||||
setScissorFromClip();
|
||||
}
|
||||
if (restoreClip) {
|
||||
setScissorFromClip();
|
||||
}
|
||||
}
|
||||
|
||||
int OpenGLRenderer::saveSnapshot() {
|
||||
mSnapshot = new Snapshot(mSnapshot);
|
||||
return ++mSaveCount;
|
||||
mSnapshot = new Snapshot(mSnapshot);
|
||||
return ++mSaveCount;
|
||||
}
|
||||
|
||||
bool OpenGLRenderer::restoreSnapshot() {
|
||||
bool restoreClip = mSnapshot->flags & Snapshot::kFlagClipSet;
|
||||
bool restoreClip = mSnapshot->flags & Snapshot::kFlagClipSet;
|
||||
|
||||
mSaveCount--;
|
||||
mSaveCount--;
|
||||
|
||||
// Do not merge these two lines!
|
||||
sp<Snapshot> previous = mSnapshot->previous;
|
||||
mSnapshot = previous;
|
||||
// Do not merge these two lines!
|
||||
sp<Snapshot> previous = mSnapshot->previous;
|
||||
mSnapshot = previous;
|
||||
|
||||
return restoreClip;
|
||||
return restoreClip;
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
@@ -267,33 +267,33 @@ bool OpenGLRenderer::restoreSnapshot() {
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
void OpenGLRenderer::translate(float dx, float dy) {
|
||||
mSnapshot->transform.translate(dx, dy, 0.0f);
|
||||
mSnapshot->flags |= Snapshot::kFlagDirtyTransform;
|
||||
mSnapshot->transform.translate(dx, dy, 0.0f);
|
||||
mSnapshot->flags |= Snapshot::kFlagDirtyTransform;
|
||||
}
|
||||
|
||||
void OpenGLRenderer::rotate(float degrees) {
|
||||
mSnapshot->transform.rotate(degrees, 0.0f, 0.0f, 1.0f);
|
||||
mSnapshot->flags |= Snapshot::kFlagDirtyTransform;
|
||||
mSnapshot->transform.rotate(degrees, 0.0f, 0.0f, 1.0f);
|
||||
mSnapshot->flags |= Snapshot::kFlagDirtyTransform;
|
||||
}
|
||||
|
||||
void OpenGLRenderer::scale(float sx, float sy) {
|
||||
mSnapshot->transform.scale(sx, sy, 1.0f);
|
||||
mSnapshot->flags |= Snapshot::kFlagDirtyTransform;
|
||||
mSnapshot->transform.scale(sx, sy, 1.0f);
|
||||
mSnapshot->flags |= Snapshot::kFlagDirtyTransform;
|
||||
}
|
||||
|
||||
void OpenGLRenderer::setMatrix(SkMatrix* matrix) {
|
||||
mSnapshot->transform.load(*matrix);
|
||||
mSnapshot->flags |= Snapshot::kFlagDirtyTransform;
|
||||
mSnapshot->transform.load(*matrix);
|
||||
mSnapshot->flags |= Snapshot::kFlagDirtyTransform;
|
||||
}
|
||||
|
||||
void OpenGLRenderer::getMatrix(SkMatrix* matrix) {
|
||||
mSnapshot->transform.copyTo(*matrix);
|
||||
mSnapshot->transform.copyTo(*matrix);
|
||||
}
|
||||
|
||||
void OpenGLRenderer::concatMatrix(SkMatrix* matrix) {
|
||||
mat4 m(*matrix);
|
||||
mSnapshot->transform.multiply(m);
|
||||
mSnapshot->flags |= Snapshot::kFlagDirtyTransform;
|
||||
mat4 m(*matrix);
|
||||
mSnapshot->transform.multiply(m);
|
||||
mSnapshot->flags |= Snapshot::kFlagDirtyTransform;
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
@@ -301,12 +301,12 @@ void OpenGLRenderer::concatMatrix(SkMatrix* matrix) {
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
void OpenGLRenderer::setScissorFromClip() {
|
||||
const Rect& clip = mSnapshot->getMappedClip();
|
||||
glScissor(clip.left, mHeight - clip.bottom, clip.getWidth(), clip.getHeight());
|
||||
const Rect& clip = mSnapshot->getMappedClip();
|
||||
glScissor(clip.left, mHeight - clip.bottom, clip.getWidth(), clip.getHeight());
|
||||
}
|
||||
|
||||
const Rect& OpenGLRenderer::getClipBounds() {
|
||||
return mSnapshot->clipRect;
|
||||
return mSnapshot->clipRect;
|
||||
}
|
||||
|
||||
bool OpenGLRenderer::quickReject(float left, float top, float right, float bottom) {
|
||||
@@ -328,12 +328,12 @@ bool OpenGLRenderer::quickReject(float left, float top, float right, float botto
|
||||
}
|
||||
|
||||
bool OpenGLRenderer::clipRect(float left, float top, float right, float bottom) {
|
||||
bool clipped = mSnapshot->clipRect.intersect(left, top, right, bottom);
|
||||
if (clipped) {
|
||||
mSnapshot->flags |= Snapshot::kFlagClipSet;
|
||||
setScissorFromClip();
|
||||
}
|
||||
return clipped;
|
||||
bool clipped = mSnapshot->clipRect.intersect(left, top, right, bottom);
|
||||
if (clipped) {
|
||||
mSnapshot->flags |= Snapshot::kFlagClipSet;
|
||||
setScissorFromClip();
|
||||
}
|
||||
return clipped;
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
@@ -38,88 +38,88 @@ namespace uirenderer {
|
||||
|
||||
class Snapshot: public LightRefBase<Snapshot> {
|
||||
public:
|
||||
Snapshot() {
|
||||
}
|
||||
Snapshot() {
|
||||
}
|
||||
|
||||
Snapshot(const sp<Snapshot> s):
|
||||
transform(s->transform),
|
||||
clipRect(s->clipRect),
|
||||
flags(kFlagDirtyTransform),
|
||||
previous(s) {
|
||||
}
|
||||
Snapshot(const sp<Snapshot> s):
|
||||
transform(s->transform),
|
||||
clipRect(s->clipRect),
|
||||
flags(kFlagDirtyTransform),
|
||||
previous(s) {
|
||||
}
|
||||
|
||||
enum Flags {
|
||||
kFlagClipSet = 0x1,
|
||||
kFlagDirtyTransform = 0x2,
|
||||
};
|
||||
enum Flags {
|
||||
kFlagClipSet = 0x1,
|
||||
kFlagDirtyTransform = 0x2,
|
||||
};
|
||||
|
||||
const Rect& getMappedClip();
|
||||
const Rect& getMappedClip();
|
||||
|
||||
// Local transformations
|
||||
mat4 transform;
|
||||
// Local transformations
|
||||
mat4 transform;
|
||||
|
||||
// Clipping rectangle at the time of this snapshot
|
||||
Rect clipRect;
|
||||
// Clipping rectangle at the time of this snapshot
|
||||
Rect clipRect;
|
||||
|
||||
// Dirty flags
|
||||
int flags;
|
||||
// Dirty flags
|
||||
int flags;
|
||||
|
||||
// Previous snapshot in the frames stack
|
||||
sp<Snapshot> previous;
|
||||
// Previous snapshot in the frames stack
|
||||
sp<Snapshot> previous;
|
||||
|
||||
private:
|
||||
// Clipping rectangle mapped with the transform
|
||||
Rect mappedClip;
|
||||
// Clipping rectangle mapped with the transform
|
||||
Rect mappedClip;
|
||||
}; // class Snapshot
|
||||
|
||||
struct SimpleVertex {
|
||||
float position[2];
|
||||
float position[2];
|
||||
}; // struct SimpleVertex
|
||||
|
||||
typedef char* shader;
|
||||
|
||||
class Program: public LightRefBase<Program> {
|
||||
public:
|
||||
Program(const char* vertex, const char* fragment);
|
||||
~Program();
|
||||
Program(const char* vertex, const char* fragment);
|
||||
~Program();
|
||||
|
||||
void use();
|
||||
void use();
|
||||
|
||||
protected:
|
||||
int addAttrib(const char* name);
|
||||
int getAttrib(const char* name);
|
||||
int addAttrib(const char* name);
|
||||
int getAttrib(const char* name);
|
||||
|
||||
int addUniform(const char* name);
|
||||
int getUniform(const char* name);
|
||||
int addUniform(const char* name);
|
||||
int getUniform(const char* name);
|
||||
|
||||
private:
|
||||
GLuint buildShader(const char* source, GLenum type);
|
||||
GLuint buildShader(const char* source, GLenum type);
|
||||
|
||||
// Handle of the OpenGL program
|
||||
GLuint id;
|
||||
// Handle of the OpenGL program
|
||||
GLuint id;
|
||||
|
||||
// Handles of the shaders
|
||||
GLuint vertexShader;
|
||||
GLuint fragmentShader;
|
||||
// Handles of the shaders
|
||||
GLuint vertexShader;
|
||||
GLuint fragmentShader;
|
||||
|
||||
// Keeps track of attributes and uniforms slots
|
||||
KeyedVector<const char*, int> attributes;
|
||||
KeyedVector<const char*, int> uniforms;
|
||||
// Keeps track of attributes and uniforms slots
|
||||
KeyedVector<const char*, int> attributes;
|
||||
KeyedVector<const char*, int> uniforms;
|
||||
}; // class Program
|
||||
|
||||
class DrawColorProgram: public Program {
|
||||
public:
|
||||
DrawColorProgram();
|
||||
DrawColorProgram();
|
||||
|
||||
void use(const GLfloat* projectionMatrix, const GLfloat* modelViewMatrix,
|
||||
const GLfloat* transformMatrix);
|
||||
void use(const GLfloat* projectionMatrix, const GLfloat* modelViewMatrix,
|
||||
const GLfloat* transformMatrix);
|
||||
|
||||
int position;
|
||||
int color;
|
||||
int position;
|
||||
int color;
|
||||
|
||||
int projection;
|
||||
int modelView;
|
||||
int transform;
|
||||
int projection;
|
||||
int modelView;
|
||||
int transform;
|
||||
};
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
168
libs/hwui/Rect.h
168
libs/hwui/Rect.h
@@ -25,111 +25,111 @@ namespace uirenderer {
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
struct Rect {
|
||||
float left;
|
||||
float top;
|
||||
float right;
|
||||
float bottom;
|
||||
float left;
|
||||
float top;
|
||||
float right;
|
||||
float bottom;
|
||||
|
||||
Rect():
|
||||
left(0),
|
||||
top(0),
|
||||
right(0),
|
||||
bottom(0) {
|
||||
}
|
||||
Rect():
|
||||
left(0),
|
||||
top(0),
|
||||
right(0),
|
||||
bottom(0) {
|
||||
}
|
||||
|
||||
Rect(float left, float top, float right, float bottom):
|
||||
left(left),
|
||||
top(top),
|
||||
right(right),
|
||||
bottom(bottom) {
|
||||
}
|
||||
Rect(float left, float top, float right, float bottom):
|
||||
left(left),
|
||||
top(top),
|
||||
right(right),
|
||||
bottom(bottom) {
|
||||
}
|
||||
|
||||
Rect(const Rect& r) {
|
||||
set(r);
|
||||
}
|
||||
Rect(const Rect& r) {
|
||||
set(r);
|
||||
}
|
||||
|
||||
Rect(Rect& r) {
|
||||
set(r);
|
||||
}
|
||||
Rect(Rect& r) {
|
||||
set(r);
|
||||
}
|
||||
|
||||
Rect& operator=(const Rect& r) {
|
||||
set(r);
|
||||
return *this;
|
||||
}
|
||||
Rect& operator=(const Rect& r) {
|
||||
set(r);
|
||||
return *this;
|
||||
}
|
||||
|
||||
Rect& operator=(Rect& r) {
|
||||
set(r);
|
||||
return *this;
|
||||
}
|
||||
Rect& operator=(Rect& r) {
|
||||
set(r);
|
||||
return *this;
|
||||
}
|
||||
|
||||
friend int operator==(const Rect& a, const Rect& b) {
|
||||
return !memcmp(&a, &b, sizeof(a));
|
||||
}
|
||||
friend int operator==(const Rect& a, const Rect& b) {
|
||||
return !memcmp(&a, &b, sizeof(a));
|
||||
}
|
||||
|
||||
friend int operator!=(const Rect& a, const Rect& b) {
|
||||
return memcmp(&a, &b, sizeof(a));
|
||||
}
|
||||
friend int operator!=(const Rect& a, const Rect& b) {
|
||||
return memcmp(&a, &b, sizeof(a));
|
||||
}
|
||||
|
||||
bool isEmpty() const {
|
||||
return left >= right || top >= bottom;
|
||||
}
|
||||
bool isEmpty() const {
|
||||
return left >= right || top >= bottom;
|
||||
}
|
||||
|
||||
void setEmpty() {
|
||||
memset(this, 0, sizeof(*this));
|
||||
}
|
||||
void setEmpty() {
|
||||
memset(this, 0, sizeof(*this));
|
||||
}
|
||||
|
||||
void set(float left, float top, float right, float bottom) {
|
||||
this->left = left;
|
||||
this->right = right;
|
||||
this->top = top;
|
||||
this->bottom = bottom;
|
||||
}
|
||||
void set(float left, float top, float right, float bottom) {
|
||||
this->left = left;
|
||||
this->right = right;
|
||||
this->top = top;
|
||||
this->bottom = bottom;
|
||||
}
|
||||
|
||||
void set(const Rect& r) {
|
||||
set(r.left, r.top, r.right, r.bottom);
|
||||
}
|
||||
void set(const Rect& r) {
|
||||
set(r.left, r.top, r.right, r.bottom);
|
||||
}
|
||||
|
||||
float getWidth() const {
|
||||
return right - left;
|
||||
}
|
||||
float getWidth() const {
|
||||
return right - left;
|
||||
}
|
||||
|
||||
float getHeight() const {
|
||||
return bottom - top;
|
||||
}
|
||||
float getHeight() const {
|
||||
return bottom - top;
|
||||
}
|
||||
|
||||
bool intersects(float left, float top, float right, float bottom) const {
|
||||
return left < right && top < bottom &&
|
||||
this->left < this->right && this->top < this->bottom &&
|
||||
this->left < right && left < this->right &&
|
||||
this->top < bottom && top < this->bottom;
|
||||
}
|
||||
bool intersects(float left, float top, float right, float bottom) const {
|
||||
return left < right && top < bottom &&
|
||||
this->left < this->right && this->top < this->bottom &&
|
||||
this->left < right && left < this->right &&
|
||||
this->top < bottom && top < this->bottom;
|
||||
}
|
||||
|
||||
bool intersects(const Rect& r) const {
|
||||
return intersects(r.left, r.top, r.right, r.bottom);
|
||||
}
|
||||
bool intersects(const Rect& r) const {
|
||||
return intersects(r.left, r.top, r.right, r.bottom);
|
||||
}
|
||||
|
||||
bool intersect(float left, float top, float right, float bottom) {
|
||||
if (left < right && top < bottom && !this->isEmpty() &&
|
||||
this->left < right && left < this->right &&
|
||||
this->top < bottom && top < this->bottom) {
|
||||
bool intersect(float left, float top, float right, float bottom) {
|
||||
if (left < right && top < bottom && !this->isEmpty() &&
|
||||
this->left < right && left < this->right &&
|
||||
this->top < bottom && top < this->bottom) {
|
||||
|
||||
if (this->left < left) this->left = left;
|
||||
if (this->top < top) this->top = top;
|
||||
if (this->right > right) this->right = right;
|
||||
if (this->bottom > bottom) this->bottom = bottom;
|
||||
if (this->left < left) this->left = left;
|
||||
if (this->top < top) this->top = top;
|
||||
if (this->right > right) this->right = right;
|
||||
if (this->bottom > bottom) this->bottom = bottom;
|
||||
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool intersect(const Rect& r) {
|
||||
return intersect(r.left, r.top, r.right, r.bottom);
|
||||
}
|
||||
bool intersect(const Rect& r) {
|
||||
return intersect(r.left, r.top, r.right, r.bottom);
|
||||
}
|
||||
|
||||
void dump() const {
|
||||
LOGD("Rect[l=%f t=%f r=%f b=%f]", left, top, right, bottom);
|
||||
}
|
||||
void dump() const {
|
||||
LOGD("Rect[l=%f t=%f r=%f b=%f]", left, top, right, bottom);
|
||||
}
|
||||
|
||||
}; // struct Rect
|
||||
|
||||
|
||||
@@ -10,8 +10,8 @@ uniform mat4 transform;
|
||||
varying vec4 outColor;
|
||||
|
||||
void main(void) {
|
||||
outColor = color;
|
||||
gl_Position = projection * transform * modelView * position;
|
||||
outColor = color;
|
||||
gl_Position = projection * transform * modelView * position;
|
||||
}
|
||||
|
||||
);
|
||||
|
||||
Reference in New Issue
Block a user