Merge "Add support for transformations." (038ecb09) · Commits · e / os / android_frameworks_base

core/java/android/view/GLES20Canvas.java

+19 −8

Original line number	Diff line number	Diff line
		@@ -212,9 +212,11 @@ class GLES20Canvas extends Canvas {

		@Override
		public void translate(float dx, float dy) {
		// TODO: Implement
		nTranslate(mRenderer, dx, dy);
		}

		private native void nTranslate(int renderer, float dx, float dy);

		@Override
		public void skew(float sx, float sy) {
		throw new UnsupportedOperationException();
		@@ -222,30 +224,39 @@ class GLES20Canvas extends Canvas {

		@Override
		public void rotate(float degrees) {
		// TODO: Implement
		nRotate(mRenderer, degrees);
		}

		private native void nRotate(int renderer, float degrees);

		@Override
		public void scale(float sx, float sy) {
		// TODO: Implement
		nScale(mRenderer, sx, sy);
		}

		private native void nScale(int renderer, float sx, float sy);

		@Override
		public void setMatrix(Matrix matrix) {
		// TODO: Implement
		nSetMatrix(mRenderer, matrix.native_instance);
		}

		private native void nSetMatrix(int renderer, int matrix);

		@Override
		public void getMatrix(Matrix ctm) {
		// TODO: Implement
		public void getMatrix(Matrix matrix) {
		nGetMatrix(mRenderer, matrix.native_instance);
		}

		private native void nGetMatrix(int renderer, int matrix);

		@Override
		public void concat(Matrix matrix) {
		// TODO: Implement
		nConcatMatrix(mRenderer, matrix.native_instance);
		}

		private native void nConcatMatrix(int renderer, int matrix);

		///////////////////////////////////////////////////////////////////////////
		// State management
		///////////////////////////////////////////////////////////////////////////

core/jni/android_view_GLES20Canvas.cpp

+69 −31

Original line number	Diff line number	Diff line
		@@ -18,12 +18,11 @@
		#include <nativehelper/JNIHelp.h>
		#include <android_runtime/AndroidRuntime.h>

		#include <SkMatrix.h>
		#include <SkXfermode.h>

		#include <OpenGLRenderer.h>

		#define UI ((OpenGLRenderer*) renderer)

		namespace android {

		// ----------------------------------------------------------------------------
		@@ -34,73 +33,104 @@ static OpenGLRenderer* android_view_GLES20Renderer_createRenderer(JNIEnv* env, j
		return new OpenGLRenderer;
		}

		static void android_view_GLES20Renderer_destroyRenderer(JNIEnv* env, jobject canvas, jint renderer) {
		delete UI;
		static void android_view_GLES20Renderer_destroyRenderer(JNIEnv* env, jobject canvas,
		OpenGLRenderer* renderer) {
		delete renderer;
		}

		// ----------------------------------------------------------------------------
		// Setup
		// ----------------------------------------------------------------------------

		static void android_view_GLES20Renderer_setViewport(JNIEnv* env, jobject canvas, jint renderer,
		jint width, jint height) {

		UI->setViewport(width, height);
		static void android_view_GLES20Renderer_setViewport(JNIEnv* env, jobject canvas,
		OpenGLRenderer* renderer, jint width, jint height) {
		renderer->setViewport(width, height);
		}

		static void android_view_GLES20Renderer_prepare(JNIEnv* env, jobject canvas, jint renderer) {

		UI->prepare();
		static void android_view_GLES20Renderer_prepare(JNIEnv* env, jobject canvas,
		OpenGLRenderer* renderer) {
		renderer->prepare();
		}

		// ----------------------------------------------------------------------------
		// State
		// ----------------------------------------------------------------------------

		static jint android_view_GLES20Renderer_save(JNIEnv* env, jobject canvas, jint renderer,
		static jint android_view_GLES20Renderer_save(JNIEnv* env, jobject canvas, OpenGLRenderer* renderer,
		jint flags) {
		return renderer->save(flags);
		}

		return UI->save(flags);
		static jint android_view_GLES20Renderer_getSaveCount(JNIEnv* env, jobject canvas,
		OpenGLRenderer* renderer) {
		return renderer->getSaveCount();
		}

		static jint android_view_GLES20Renderer_getSaveCount(JNIEnv* env, jobject canvas, jint renderer) {
		return UI->getSaveCount();
		static void android_view_GLES20Renderer_restore(JNIEnv* env, jobject canvas,
		OpenGLRenderer* renderer) {
		renderer->restore();
		}

		static void android_view_GLES20Renderer_restore(JNIEnv* env, jobject canvas, jint renderer) {
		UI->restore();
		static void android_view_GLES20Renderer_restoreToCount(JNIEnv* env, jobject canvas,
		OpenGLRenderer* renderer, jint saveCount) {
		renderer->restoreToCount(saveCount);
		}

		static void android_view_GLES20Renderer_restoreToCount(JNIEnv* env, jobject canvas, jint renderer,
		jint saveCount) {
		// ----------------------------------------------------------------------------
		// Clipping
		// ----------------------------------------------------------------------------

		static bool android_view_GLES20Renderer_clipRectF(JNIEnv* env, jobject canvas,
		OpenGLRenderer* renderer, jfloat left, jfloat top, jfloat right, jfloat bottom) {
		return renderer->clipRect(left, top, right, bottom);
		}

		UI->restoreToCount(saveCount);
		static bool android_view_GLES20Renderer_clipRect(JNIEnv* env, jobject canvas,
		OpenGLRenderer* renderer, jint left, jint top, jint right, jint bottom) {
		return renderer->clipRect(float(left), float(top), float(right), float(bottom));
		}

		// ----------------------------------------------------------------------------
		// Clipping
		// Transforms
		// ----------------------------------------------------------------------------

		static bool android_view_GLES20Renderer_clipRectF(JNIEnv* env, jobject canvas, jint renderer,
		jfloat left, jfloat top, jfloat right, jfloat bottom) {
		static void android_view_GLES20Renderer_translate(JNIEnv* env, jobject canvas,
		OpenGLRenderer* renderer, jfloat dx, jfloat dy) {
		renderer->translate(dx, dy);
		}

		return UI->clipRect(left, top, right, bottom);
		static void android_view_GLES20Renderer_rotate(JNIEnv* env, jobject canvas,
		OpenGLRenderer* renderer, jfloat degrees) {
		renderer->rotate(degrees);
		}

		static bool android_view_GLES20Renderer_clipRect(JNIEnv* env, jobject canvas, jint renderer,
		jint left, jint top, jint right, jint bottom) {
		static void android_view_GLES20Renderer_scale(JNIEnv* env, jobject canvas,
		OpenGLRenderer* renderer, jfloat sx, jfloat sy) {
		renderer->scale(sx, sy);
		}

		return UI->clipRect(float(left), float(top), float(right), float(bottom));
		static void android_view_GLES20Renderer_setMatrix(JNIEnv* env, jobject canvas,
		OpenGLRenderer* renderer, SkMatrix* matrix) {
		renderer->setMatrix(matrix);
		}

		static void android_view_GLES20Renderer_getMatrix(JNIEnv* env, jobject canvas,
		OpenGLRenderer* renderer, SkMatrix* matrix) {
		renderer->getMatrix(matrix);
		}

		static void android_view_GLES20Renderer_concatMatrix(JNIEnv* env, jobject canvas,
		OpenGLRenderer* renderer, SkMatrix* matrix) {
		renderer->concatMatrix(matrix);
		}

		// ----------------------------------------------------------------------------
		// Drawing
		// ----------------------------------------------------------------------------

		static void android_view_GLES20Renderer_drawColor(JNIEnv* env, jobject canvas, jint renderer,
		jint color, jint mode) {

		UI->drawColor(color, (SkXfermode::Mode) mode);
		static void android_view_GLES20Renderer_drawColor(JNIEnv* env, jobject canvas,
		OpenGLRenderer* renderer, jint color, jint mode) {
		renderer->drawColor(color, (SkXfermode::Mode) mode);
		}

		// ----------------------------------------------------------------------------
		@@ -123,6 +153,14 @@ static JNINativeMethod gMethods[] = {
		{ "nClipRect", "(IFFFF)Z", (void*) android_view_GLES20Renderer_clipRectF },
		{ "nClipRect", "(IIIII)Z", (void*) android_view_GLES20Renderer_clipRect },

		{ "nTranslate", "(IFF)V", (void*) android_view_GLES20Renderer_translate },
		{ "nRotate", "(IF)V", (void*) android_view_GLES20Renderer_rotate },
		{ "nScale", "(IFF)V", (void*) android_view_GLES20Renderer_scale },

		{ "nSetMatrix", "(II)V", (void*) android_view_GLES20Renderer_setMatrix },
		{ "nGetMatrix", "(II)V", (void*) android_view_GLES20Renderer_getMatrix },
		{ "nConcatMatrix", "(II)V", (void*) android_view_GLES20Renderer_concatMatrix },

		{ "nDrawColor", "(III)V", (void*) android_view_GLES20Renderer_drawColor },
		};

graphics/java/android/graphics/Matrix.java

+4 −1

Original line number	Diff line number	Diff line
		@@ -37,7 +37,10 @@ public class Matrix {
		public static final int MPERSP_1 = 7; //!< use with getValues/setValues
		public static final int MPERSP_2 = 8; //!< use with getValues/setValues

		/* package */ int native_instance;
		/**
		* @hide
		*/
		public int native_instance;

		/**
		* Create an identity matrix

libs/hwui/Matrix.cpp

+65 −29

Original line number	Diff line number	Diff line
		@@ -22,30 +22,32 @@

		#include <utils/Log.h>

		#include <SkMatrix.h>

		#include "Matrix.h"

		namespace android {

		void Matrix4::loadIdentity() {
		mMat[0] = 1;
		mMat[1] = 0;
		mMat[2] = 0;
		mMat[3] = 0;

		mMat[4] = 0;
		mMat[5] = 1;
		mMat[6] = 0;
		mMat[7] = 0;

		mMat[8] = 0;
		mMat[9] = 0;
		mMat[10] = 1;
		mMat[11] = 0;

		mMat[12] = 0;
		mMat[13] = 0;
		mMat[14] = 0;
		mMat[15] = 1;
		mMat[0] = 1.0f;
		mMat[1] = 0.0f;
		mMat[2] = 0.0f;
		mMat[3] = 0.0f;

		mMat[4] = 0.0f;
		mMat[5] = 1.0f;
		mMat[6] = 0.0f;
		mMat[7] = 0.0f;

		mMat[8] = 0.0f;
		mMat[9] = 0.0f;
		mMat[10] = 1.0f;
		mMat[11] = 0.0f;

		mMat[12] = 0.0f;
		mMat[13] = 0.0f;
		mMat[14] = 0.0f;
		mMat[15] = 1.0f;
		}

		void Matrix4::load(const float* v) {
		@@ -56,6 +58,40 @@ void Matrix4::load(const Matrix4& v) {
		memcpy(mMat, v.mMat, sizeof(mMat));
		}

		void Matrix4::load(const SkMatrix& v) {
		memset(mMat, 0, sizeof(mMat));

		mMat[0] = v[SkMatrix::kMScaleX];
		mMat[4] = v[SkMatrix::kMSkewX];
		mMat[12] = v[SkMatrix::kMTransX];

		mMat[1] = v[SkMatrix::kMSkewY];
		mMat[5] = v[SkMatrix::kMScaleY];
		mMat[13] = v[SkMatrix::kMTransY];

		mMat[3] = v[SkMatrix::kMPersp0];
		mMat[7] = v[SkMatrix::kMPersp1];
		mMat[15] = v[SkMatrix::kMPersp2];

		mMat[10] = 1.0f;
		}

		void Matrix4::copyTo(SkMatrix& v) const {
		v.reset();

		v.set(SkMatrix::kMScaleX, mMat[0]);
		v.set(SkMatrix::kMSkewX, mMat[4]);
		v.set(SkMatrix::kMTransX, mMat[12]);

		v.set(SkMatrix::kMSkewY, mMat[1]);
		v.set(SkMatrix::kMScaleY, mMat[5]);
		v.set(SkMatrix::kMTransY, mMat[13]);

		v.set(SkMatrix::kMPersp0, mMat[3]);
		v.set(SkMatrix::kMPersp1, mMat[7]);
		v.set(SkMatrix::kMPersp2, mMat[15]);
		}

		void Matrix4::copyTo(float* v) const {
		memcpy(v, mMat, sizeof(mMat));
		}
		@@ -75,13 +111,13 @@ void Matrix4::loadScale(float sx, float sy, float sz) {
		}

		void Matrix4::loadRotate(float angle, float x, float y, float z) {
		mMat[3] = 0;
		mMat[7] = 0;
		mMat[11] = 0;
		mMat[12] = 0;
		mMat[13] = 0;
		mMat[14] = 0;
		mMat[15] = 1;
		mMat[3] = 0.0f;
		mMat[7] = 0.0f;
		mMat[11] = 0.0f;
		mMat[12] = 0.0f;
		mMat[13] = 0.0f;
		mMat[14] = 0.0f;
		mMat[15] = 1.0f;

		angle *= float(M_PI / 180.0f);
		float c = cosf(angle);
		@@ -131,9 +167,9 @@ void Matrix4::loadMultiply(const Matrix4& u, const Matrix4& v) {

		void Matrix4::loadOrtho(float left, float right, float bottom, float top, float near, float far) {
		loadIdentity();
		mMat[0] = 2 / (right - left);
		mMat[5] = 2 / (top - bottom);
		mMat[10] = -2 / (far - near);
		mMat[0] = 2.0f / (right - left);
		mMat[5] = 2.0f / (top - bottom);
		mMat[10] = -2.0f / (far - near);
		mMat[12] = -(right + left) / (right - left);
		mMat[13] = -(top + bottom) / (top - bottom);
		mMat[14] = -(far + near) / (far - near);

libs/hwui/Matrix.h

+9 −1

Original line number	Diff line number	Diff line
		@@ -17,6 +17,8 @@
		#ifndef ANDROID_MATRIX_H
		#define ANDROID_MATRIX_H

		#include <SkMatrix.h>

		namespace android {

		///////////////////////////////////////////////////////////////////////////////
		@@ -37,10 +39,15 @@ public:
		load(v);
		}

		Matrix4(const SkMatrix& v) {
		load(v);
		}

		void loadIdentity();

		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);
		@@ -74,10 +81,11 @@ public:
		}

		void copyTo(float* v) const;
		void copyTo(SkMatrix& v) const;

		void dump() const;

		//private:
		private:
		inline float get(int i, int j) const {
		return mMat[i * 4 + j];
		}