Convert tabs to spaces.
Change-Id: I5d3ae48af79b19b6d293deff0521e4bb57d5114b
diff --git a/core/jni/android_view_GLES20Canvas.cpp b/core/jni/android_view_GLES20Canvas.cpp
index aca63e8..d3b6558 100644
--- a/core/jni/android_view_GLES20Canvas.cpp
+++ b/core/jni/android_view_GLES20Canvas.cpp
@@ -36,8 +36,8 @@
// ----------------------------------------------------------------------------
static struct {
- jclass clazz;
- jmethodID set;
+ jclass clazz;
+ jmethodID set;
} gRectClassInfo;
// ----------------------------------------------------------------------------
@@ -114,12 +114,12 @@
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 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 @@
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));
}
diff --git a/libs/hwui/Matrix.cpp b/libs/hwui/Matrix.cpp
index 59b7fef..c772f00 100644
--- a/libs/hwui/Matrix.cpp
+++ b/libs/hwui/Matrix.cpp
@@ -30,118 +30,118 @@
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 @@
#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
diff --git a/libs/hwui/Matrix.h b/libs/hwui/Matrix.h
index 8fa5e4d..fa9638b 100644
--- a/libs/hwui/Matrix.h
+++ b/libs/hwui/Matrix.h
@@ -30,67 +30,67 @@
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 @@
}
inline void set(int i, int j, float v) {
- data[i * 4 + j] = v;
+ data[i * 4 + j] = v;
}
}; // class Matrix4
diff --git a/libs/hwui/OpenGLRenderer.cpp b/libs/hwui/OpenGLRenderer.cpp
index 2ebd7cd..830e0c3 100644
--- a/libs/hwui/OpenGLRenderer.cpp
+++ b/libs/hwui/OpenGLRenderer.cpp
@@ -47,10 +47,10 @@
///////////////////////////////////////////////////////////////////////////////
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 @@
#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 @@
///////////////////////////////////////////////////////////////////////////////
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::prepare() {
- mSnapshot = &mFirstSnapshot;
- mSaveCount = 0;
+ mSnapshot = &mFirstSnapshot;
+ mSaveCount = 0;
glDisable(GL_SCISSOR_TEST);
@@ -216,50 +216,50 @@
///////////////////////////////////////////////////////////////////////////////
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 @@
///////////////////////////////////////////////////////////////////////////////
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::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::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;
}
///////////////////////////////////////////////////////////////////////////////
diff --git a/libs/hwui/OpenGLRenderer.h b/libs/hwui/OpenGLRenderer.h
index bef4193..6f6b997 100644
--- a/libs/hwui/OpenGLRenderer.h
+++ b/libs/hwui/OpenGLRenderer.h
@@ -38,88 +38,88 @@
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;
};
///////////////////////////////////////////////////////////////////////////////
diff --git a/libs/hwui/Rect.h b/libs/hwui/Rect.h
index fcf11e9..b382dc3 100644
--- a/libs/hwui/Rect.h
+++ b/libs/hwui/Rect.h
@@ -25,111 +25,111 @@
///////////////////////////////////////////////////////////////////////////////
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
diff --git a/libs/hwui/shaders/drawColor.vert b/libs/hwui/shaders/drawColor.vert
index 4b7f883..cef6e49 100644
--- a/libs/hwui/shaders/drawColor.vert
+++ b/libs/hwui/shaders/drawColor.vert
@@ -10,8 +10,8 @@
varying vec4 outColor;
void main(void) {
- outColor = color;
- gl_Position = projection * transform * modelView * position;
+ outColor = color;
+ gl_Position = projection * transform * modelView * position;
}
);