Merge "Add support for paths." (8cc44cb6) · Commits · e / os / android_frameworks_base

core/java/android/view/GLES20Canvas.java

+5 −2

Original line number	Diff line number	Diff line
		@@ -350,7 +350,6 @@ class GLES20Canvas extends Canvas {

		@Override
		public void setDrawFilter(DrawFilter filter) {
		// TODO: Implement PaintDrawFilter
		mFilter = filter;
		}

		@@ -522,9 +521,13 @@ class GLES20Canvas extends Canvas {

		@Override
		public void drawPath(Path path, Paint paint) {
		throw new UnsupportedOperationException();
		boolean hasModifier = setupModifiers(paint);
		nDrawPath(mRenderer, path.mNativePath, paint.mNativePaint);
		if (hasModifier) nResetModifiers(mRenderer);
		}

		private native void nDrawPath(int renderer, int path, int paint);

		@Override
		public void drawPicture(Picture picture) {
		throw new UnsupportedOperationException();

core/jni/android_view_GLES20Canvas.cpp

+6 −0

Original line number	Diff line number	Diff line
		@@ -228,6 +228,11 @@ static void android_view_GLES20Canvas_drawRect(JNIEnv* env, jobject canvas,
		renderer->drawRect(left, top, right, bottom, paint);
		}

		static void android_view_GLES20Canvas_drawPath(JNIEnv* env, jobject canvas,
		OpenGLRenderer* renderer, SkPath* path, SkPaint* paint) {
		renderer->drawPath(path, paint);
		}

		// ----------------------------------------------------------------------------
		// Shaders and color filters
		// ----------------------------------------------------------------------------
		@@ -317,6 +322,7 @@ static JNINativeMethod gMethods[] = {
		{ "nDrawPatch", "(II[BFFFFI)V", (void*) android_view_GLES20Canvas_drawPatch },
		{ "nDrawColor", "(III)V", (void*) android_view_GLES20Canvas_drawColor },
		{ "nDrawRect", "(IFFFFI)V", (void*) android_view_GLES20Canvas_drawRect },
		{ "nDrawPath", "(III)V", (void*) android_view_GLES20Canvas_drawPath },

		{ "nResetModifiers", "(I)V", (void*) android_view_GLES20Canvas_resetModifiers },
		{ "nSetupShader", "(II)V", (void*) android_view_GLES20Canvas_setupShader },

graphics/java/android/graphics/Path.java

+4 −1

Original line number	Diff line number	Diff line
		@@ -593,5 +593,8 @@ public class Path {
		private static native void native_transform(int nPath, int matrix);
		private static native void finalizer(int nPath);

		private final int mNativePath;
		/**
		* @hide
		*/
		public final int mNativePath;
		}

libs/hwui/Android.mk

+1 −0

Original line number	Diff line number	Diff line
		@@ -9,6 +9,7 @@ LOCAL_SRC_FILES:= \
		OpenGLRenderer.cpp \
		Patch.cpp \
		PatchCache.cpp \
		PathCache.cpp \
		Program.cpp \
		ProgramCache.cpp \
		SkiaColorFilter.cpp \

libs/hwui/OpenGLRenderer.cpp

+78 −2

Original line number	Diff line number	Diff line
		@@ -37,7 +37,8 @@ namespace uirenderer {
		///////////////////////////////////////////////////////////////////////////////

		#define DEFAULT_TEXTURE_CACHE_SIZE 20.0f
		#define DEFAULT_LAYER_CACHE_SIZE 10.0f
		#define DEFAULT_LAYER_CACHE_SIZE 6.0f
		#define DEFAULT_PATH_CACHE_SIZE 6.0f
		#define DEFAULT_PATCH_CACHE_SIZE 100
		#define DEFAULT_GRADIENT_CACHE_SIZE 0.5f

		@@ -105,6 +106,7 @@ OpenGLRenderer::OpenGLRenderer():
		mTextureCache(MB(DEFAULT_TEXTURE_CACHE_SIZE)),
		mLayerCache(MB(DEFAULT_LAYER_CACHE_SIZE)),
		mGradientCache(MB(DEFAULT_GRADIENT_CACHE_SIZE)),
		mPathCache(MB(DEFAULT_PATH_CACHE_SIZE)),
		mPatchCache(DEFAULT_PATCH_CACHE_SIZE) {
		LOGD("Create OpenGLRenderer");

		@@ -125,11 +127,18 @@ OpenGLRenderer::OpenGLRenderer():

		if (property_get(PROPERTY_GRADIENT_CACHE_SIZE, property, NULL) > 0) {
		LOGD(" Setting gradient cache size to %sMB", property);
		mLayerCache.setMaxSize(MB(atof(property)));
		mGradientCache.setMaxSize(MB(atof(property)));
		} else {
		LOGD(" Using default gradient cache size of %.2fMB", DEFAULT_GRADIENT_CACHE_SIZE);
		}

		if (property_get(PROPERTY_PATH_CACHE_SIZE, property, NULL) > 0) {
		LOGD(" Setting path cache size to %sMB", property);
		mPathCache.setMaxSize(MB(atof(property)));
		} else {
		LOGD(" Using default path cache size of %.2fMB", DEFAULT_PATH_CACHE_SIZE);
		}

		mCurrentProgram = NULL;
		mShader = NULL;
		mColorFilter = NULL;
		@@ -597,6 +606,73 @@ void OpenGLRenderer::drawText(const char* text, int bytesCount, int count,
		glDisableVertexAttribArray(texCoordsSlot);
		}

		void OpenGLRenderer::drawPath(SkPath* path, SkPaint* paint) {
		GLuint textureUnit = 0;
		glActiveTexture(gTextureUnits[textureUnit]);

		PathTexture* texture = mPathCache.get(path, paint);

		int alpha;
		SkXfermode::Mode mode;
		getAlphaAndMode(paint, &alpha, &mode);

		uint32_t color = paint->getColor();
		const GLfloat a = alpha / 255.0f;
		const GLfloat r = a * ((color >> 16) & 0xFF) / 255.0f;
		const GLfloat g = a * ((color >> 8) & 0xFF) / 255.0f;
		const GLfloat b = a * ((color ) & 0xFF) / 255.0f;

		// Describe the required shaders
		ProgramDescription description;
		description.hasTexture = true;
		description.hasAlpha8Texture = true;
		if (mShader) {
		mShader->describe(description, mExtensions);
		}
		if (mColorFilter) {
		mColorFilter->describe(description, mExtensions);
		}

		// Build and use the appropriate shader
		useProgram(mProgramCache.get(description));

		// Setup the blending mode
		chooseBlending(true, mode);
		bindTexture(texture->id, GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE, textureUnit);
		glUniform1i(mCurrentProgram->getUniform("sampler"), textureUnit);

		int texCoordsSlot = mCurrentProgram->getAttrib("texCoords");
		glEnableVertexAttribArray(texCoordsSlot);

		// Setup attributes
		glVertexAttribPointer(mCurrentProgram->position, 2, GL_FLOAT, GL_FALSE,
		gMeshStride, &mMeshVertices[0].position[0]);
		glVertexAttribPointer(texCoordsSlot, 2, GL_FLOAT, GL_FALSE,
		gMeshStride, &mMeshVertices[0].texture[0]);

		// Setup uniforms
		mModelView.loadTranslate(texture->left - texture->offset,
		texture->top - texture->offset, 0.0f);
		mModelView.scale(texture->width, texture->height, 1.0f);
		mCurrentProgram->set(mOrthoMatrix, mModelView, mSnapshot->transform);

		glUniform4f(mCurrentProgram->color, r, g, b, a);

		textureUnit++;
		// Setup attributes and uniforms required by the shaders
		if (mShader) {
		mShader->setupProgram(mCurrentProgram, mModelView, *mSnapshot, &textureUnit);
		}
		if (mColorFilter) {
		mColorFilter->setupProgram(mCurrentProgram);
		}

		// Draw the mesh
		glDrawArrays(GL_TRIANGLE_STRIP, 0, gMeshCount);

		glDisableVertexAttribArray(texCoordsSlot);
		}

		///////////////////////////////////////////////////////////////////////////////
		// Shaders
		///////////////////////////////////////////////////////////////////////////////