Merge "Correctly support pre-multiplied alpha, optimizations, more stuff." (c7f3ce84) · Commits · e / os / android_frameworks_base

core/java/android/view/GLES20Canvas.java

+20 −6

Original line number	Diff line number	Diff line
		@@ -46,6 +46,10 @@ class GLES20Canvas extends Canvas {
		private final float[] mPoint = new float[2];
		private final float[] mLine = new float[4];

		private final Rect mClipBounds = new Rect();

		private DrawFilter mFilter;

		///////////////////////////////////////////////////////////////////////////
		// Constructors
		///////////////////////////////////////////////////////////////////////////
		@@ -164,6 +168,7 @@ class GLES20Canvas extends Canvas {

		@Override
		public boolean clipRect(Rect rect, Region.Op op) {
		// TODO: Implement
		throw new UnsupportedOperationException();
		}

		@@ -174,6 +179,7 @@ class GLES20Canvas extends Canvas {

		@Override
		public boolean clipRect(RectF rect, Region.Op op) {
		// TODO: Implement
		throw new UnsupportedOperationException();
		}

		@@ -336,12 +342,14 @@ class GLES20Canvas extends Canvas {

		@Override
		public void setDrawFilter(DrawFilter filter) {
		throw new UnsupportedOperationException();
		// Don't crash, but ignore the draw filter
		// TODO: Implement PaintDrawFilter
		mFilter = filter;
		}

		@Override
		public DrawFilter getDrawFilter() {
		throw new UnsupportedOperationException();
		return mFilter;
		}

		///////////////////////////////////////////////////////////////////////////
		@@ -408,7 +416,11 @@ class GLES20Canvas extends Canvas {
		@Override
		public void drawBitmap(int[] colors, int offset, int stride, float x, float y,
		int width, int height, boolean hasAlpha, Paint paint) {
		// TODO: Implement
		final Bitmap.Config config = hasAlpha ? Bitmap.Config.ARGB_8888 : Bitmap.Config.RGB_565;
		final Bitmap b = Bitmap.createBitmap(colors, offset, stride, width, height, config);
		final int nativePaint = paint == null ? 0 : paint.mNativePaint;
		nDrawBitmap(mRenderer, b.mNativeBitmap, x, y, nativePaint);
		b.recycle();
		}

		@Override
		@@ -420,7 +432,7 @@ class GLES20Canvas extends Canvas {
		@Override
		public void drawBitmapMesh(Bitmap bitmap, int meshWidth, int meshHeight, float[] verts,
		int vertOffset, int[] colors, int colorOffset, Paint paint) {
		throw new UnsupportedOperationException();
		// TODO: Implement
		}

		@Override
		@@ -466,7 +478,9 @@ class GLES20Canvas extends Canvas {

		@Override
		public void drawPaint(Paint paint) {
		// TODO: Implement
		final Rect r = mClipBounds;
		nGetClipBounds(mRenderer, r);
		drawRect(r.left, r.top, r.right, r.bottom, paint);
		}

		@Override
		@@ -591,6 +605,6 @@ class GLES20Canvas extends Canvas {
		public void drawVertices(VertexMode mode, int vertexCount, float[] verts, int vertOffset,
		float[] texs, int texOffset, int[] colors, int colorOffset, short[] indices,
		int indexOffset, int indexCount, Paint paint) {
		throw new UnsupportedOperationException();
		// TODO: Implement
		}
		}

graphics/java/android/graphics/BitmapShader.java

+23 −9

Original line number	Diff line number	Diff line
		@@ -16,10 +16,25 @@

		package android.graphics;

		/**
		* Shader used to draw a bitmap as a texture. The bitmap can be repeated or
		* mirrored by setting the tiling mode.
		*/
		public class BitmapShader extends Shader {

		// we hold on just for the GC, since our native counterpart is using it
		private Bitmap mBitmap;
		/**
		* We hold on just for the GC, since our native counterpart is using it.
		*
		* @hide
		*/
		public Bitmap mBitmap;
		/**
		* @hide
		*/
		public int mTileX;
		/**
		* @hide
		*/
		public int mTileY;

		/**
		* Call this to create a new shader that will draw with a bitmap.
		@@ -30,12 +45,11 @@ public class BitmapShader extends Shader {
		*/
		public BitmapShader(Bitmap bitmap, TileMode tileX, TileMode tileY) {
		mBitmap = bitmap;
		native_instance = nativeCreate(bitmap.ni(),
		tileX.nativeInt, tileY.nativeInt);
		mTileX = tileX.nativeInt;
		mTileY = tileY.nativeInt;
		native_instance = nativeCreate(bitmap.ni(), mTileX, mTileY);
		}

		private static native int nativeCreate(int native_bitmap,
		int shaderTileModeX,
		private static native int nativeCreate(int native_bitmap, int shaderTileModeX,
		int shaderTileModeY);
		}

libs/hwui/OpenGLRenderer.cpp

+50 −23

Original line number	Diff line number	Diff line
		@@ -128,6 +128,7 @@ OpenGLRenderer::~OpenGLRenderer() {

		mTextureCache.clear();
		mLayerCache.clear();
		mPatchCache.clear();
		}

		///////////////////////////////////////////////////////////////////////////////
		@@ -242,7 +243,7 @@ void OpenGLRenderer::composeLayer(sp<Snapshot> current, sp<Snapshot> previous) {
		const Rect& rect = layer->layer;

		drawTextureRect(rect.left, rect.top, rect.right, rect.bottom,
		layer->texture, layer->alpha, layer->mode, layer->blend);
		layer->texture, layer->alpha, layer->mode, layer->blend, true);

		LayerSize size(rect.getWidth(), rect.getHeight());
		// Failing to add the layer to the cache should happen only if the
		@@ -418,8 +419,15 @@ bool OpenGLRenderer::clipRect(float left, float top, float right, float bottom)
		///////////////////////////////////////////////////////////////////////////////

		void OpenGLRenderer::drawBitmap(SkBitmap* bitmap, float left, float top, const SkPaint* paint) {
		const float right = left + bitmap->width();
		const float bottom = top + bitmap->height();

		if (quickReject(left, top, right, bottom)) {
		return;
		}

		const Texture* texture = mTextureCache.get(bitmap);
		drawTextureRect(left, top, left + texture->width, top + texture->height, texture, paint);
		drawTextureRect(left, top, right, bottom, texture, paint);
		}

		void OpenGLRenderer::drawBitmap(SkBitmap* bitmap, const SkMatrix* matrix, const SkPaint* paint) {
		@@ -427,6 +435,10 @@ void OpenGLRenderer::drawBitmap(SkBitmap* bitmap, const SkMatrix* matrix, const
		const mat4 transform(*matrix);
		transform.mapRect(r);

		if (quickReject(r.left, r.top, r.right, r.bottom)) {
		return;
		}

		const Texture* texture = mTextureCache.get(bitmap);
		drawTextureRect(r.left, r.top, r.right, r.bottom, texture, paint);
		}
		@@ -435,6 +447,10 @@ void OpenGLRenderer::drawBitmap(SkBitmap* bitmap,
		float srcLeft, float srcTop, float srcRight, float srcBottom,
		float dstLeft, float dstTop, float dstRight, float dstBottom,
		const SkPaint* paint) {
		if (quickReject(dstLeft, dstTop, dstRight, dstBottom)) {
		return;
		}

		const Texture* texture = mTextureCache.get(bitmap);

		const float width = texture->width;
		@@ -454,6 +470,10 @@ void OpenGLRenderer::drawBitmap(SkBitmap* bitmap,

		void OpenGLRenderer::drawPatch(SkBitmap* bitmap, Res_png_9patch* patch,
		float left, float top, float right, float bottom, const SkPaint* paint) {
		if (quickReject(left, top, right, bottom)) {
		return;
		}

		const Texture* texture = mTextureCache.get(bitmap);

		int alpha;
		@@ -477,6 +497,10 @@ void OpenGLRenderer::drawColor(int color, SkXfermode::Mode mode) {
		}

		void OpenGLRenderer::drawRect(float left, float top, float right, float bottom, const SkPaint* p) {
		if (quickReject(left, top, right, bottom)) {
		return;
		}

		SkXfermode::Mode mode;

		const bool isMode = SkXfermode::IsMode(p->getXfermode(), &mode);
		@@ -495,6 +519,10 @@ void OpenGLRenderer::drawRect(float left, float top, float right, float bottom,
		drawColorRect(left, top, right, bottom, color, mode);
		}

		///////////////////////////////////////////////////////////////////////////////
		// Drawing implementation
		///////////////////////////////////////////////////////////////////////////////

		void OpenGLRenderer::drawColorRect(float left, float top, float right, float bottom,
		int color, SkXfermode::Mode mode) {
		const int alpha = (color >> 24) & 0xFF;
		@@ -503,24 +531,24 @@ void OpenGLRenderer::drawColorRect(float left, float top, float right, float bot
		const GLfloat g = ((color >> 8) & 0xFF) / 255.0f;
		const GLfloat b = ((color ) & 0xFF) / 255.0f;

		// Pre-multiplication happens when setting the shader color
		chooseBlending(alpha < 255, mode, true);

		mModelView.loadTranslate(left, top, 0.0f);
		mModelView.scale(right - left, bottom - top, 1.0f);

		useShader(mDrawColorShader);
		const bool inUse = useShader(mDrawColorShader);
		mDrawColorShader->set(mOrthoMatrix, mModelView, mSnapshot->transform);

		if (!inUse) {
		const GLvoid* p = &gDrawColorVertices[0].position[0];

		glEnableVertexAttribArray(mDrawColorShader->position);
		glVertexAttribPointer(mDrawColorShader->position, 2, GL_FLOAT, GL_FALSE,
		gDrawColorVertexStride, p);
		glUniform4f(mDrawColorShader->color, r, g, b, a);
		}
		// Render using pre-multiplied alpha
		glUniform4f(mDrawColorShader->color, r * a, g * a, b * a, a);

		glDrawArrays(GL_TRIANGLE_STRIP, 0, gDrawColorVertexCount);

		glDisableVertexAttribArray(mDrawColorShader->position);
		}

		void OpenGLRenderer::drawTextureRect(float left, float top, float right, float bottom,
		@@ -529,8 +557,8 @@ void OpenGLRenderer::drawTextureRect(float left, float top, float right, float b
		SkXfermode::Mode mode;
		getAlphaAndMode(paint, &alpha, &mode);

		drawTextureMesh(left, top, right, bottom, texture->id, alpha / 255.0f, mode, texture->blend,
		isPremultiplied, &mDrawTextureVertices[0].position[0],
		drawTextureMesh(left, top, right, bottom, texture->id, alpha / 255.0f, mode,
		texture->blend, texture->blend, &mDrawTextureVertices[0].position[0],
		&mDrawTextureVertices[0].texture[0], NULL);
		}

		@@ -555,27 +583,24 @@ void OpenGLRenderer::drawTextureMesh(float left, float top, float right, float b

		// TODO handle tiling and filtering here

		glActiveTexture(GL_TEXTURE0);
		glUniform1i(mDrawTextureShader->sampler, 0);
		if (isPremultiplied) {
		glUniform4f(mDrawTextureShader->color, alpha, alpha, alpha, alpha);
		} else {
		glUniform4f(mDrawTextureShader->color, 1.0f, 1.0f, 1.0f, alpha);
		}

		glEnableVertexAttribArray(mDrawTextureShader->position);
		glVertexAttribPointer(mDrawTextureShader->position, 2, GL_FLOAT, GL_FALSE,
		gDrawTextureVertexStride, vertices);

		glEnableVertexAttribArray(mDrawTextureShader->texCoords);
		glVertexAttribPointer(mDrawTextureShader->texCoords, 2, GL_FLOAT, GL_FALSE,
		gDrawTextureVertexStride, texCoords);

		if (!indices) {
		glDrawArrays(GL_TRIANGLE_STRIP, 0, gDrawTextureVertexCount);
		} else {
		// TODO: Use triangle strip instead
		glDrawElements(GL_TRIANGLES, elementsCount, GL_UNSIGNED_SHORT, indices);
		}

		glDisableVertexAttribArray(mDrawTextureShader->position);
		glDisableVertexAttribArray(mDrawTextureShader->texCoords);

		glBindTexture(GL_TEXTURE_2D, 0);
		}

		@@ -605,12 +630,14 @@ void OpenGLRenderer::chooseBlending(bool blend, SkXfermode::Mode mode, bool isPr
		mBlend = blend;
		}

		void OpenGLRenderer::useShader(const sp<Program>& shader) {
		bool OpenGLRenderer::useShader(const sp<Program>& shader) {
		if (!shader->isInUse()) {
		mCurrentShader->remove();
		shader->use();
		mCurrentShader = shader;
		return false;
		}
		return true;
		}

		void OpenGLRenderer::resetDrawTextureTexCoords(float u1, float v1, float u2, float v2) {

libs/hwui/OpenGLRenderer.h

+5 −3

Original line number	Diff line number	Diff line
		@@ -179,7 +179,7 @@ private:
		* @param isPremultiplied Indicates whether the texture has premultiplied alpha
		*/
		void drawTextureRect(float left, float top, float right, float bottom, GLuint texture,
		float alpha, SkXfermode::Mode mode, bool blend, bool isPremultiplied = true);
		float alpha, SkXfermode::Mode mode, bool blend, bool isPremultiplied = false);

		/**
		* Draws a textured rectangle with the specified texture. The specified coordinates
		@@ -194,7 +194,7 @@ private:
		* @param isPremultiplied Indicates whether the texture has premultiplied alpha
		*/
		void drawTextureRect(float left, float top, float right, float bottom, const Texture* texture,
		const SkPaint* paint, bool isPremultiplied = true);
		const SkPaint* paint, bool isPremultiplied = false);

		/**
		* Draws a textured mesh with the specified texture. If the indices are omitted, the
		@@ -252,8 +252,10 @@ private:
		* in use, it will not be bound again. If it is not in use, the current shader is
		* marked unused and the specified shader becomes used and becomes the new
		* current shader.
		*
		* @return true If the specified shader was already in use, false otherwise.
		*/
		inline void useShader(const sp<Program>& shader);
		inline bool useShader(const sp<Program>& shader);

		// Dimensions of the drawing surface
		int mWidth, mHeight;

libs/hwui/Program.cpp

+22 −0

Original line number	Diff line number	Diff line
		@@ -146,6 +146,16 @@ void DrawColorProgram::set(const mat4& projectionMatrix, const mat4& modelViewMa
		glUniformMatrix4fv(transform, 1, GL_FALSE, &t.data[0]);
		}

		void DrawColorProgram::use() {
		Program::use();
		glEnableVertexAttribArray(position);
		}

		void DrawColorProgram::remove() {
		Program::remove();
		glDisableVertexAttribArray(position);
		}

		///////////////////////////////////////////////////////////////////////////////
		// Draw texture
		///////////////////////////////////////////////////////////////////////////////
		@@ -156,5 +166,17 @@ DrawTextureProgram::DrawTextureProgram():
		sampler = addUniform("sampler");
		}

		void DrawTextureProgram::use() {
		DrawColorProgram::use();
		glActiveTexture(GL_TEXTURE0);
		glUniform1i(sampler, 0);
		glEnableVertexAttribArray(texCoords);
		}

		void DrawTextureProgram::remove() {
		DrawColorProgram::remove();
		glDisableVertexAttribArray(texCoords);
		}

		}; // namespace uirenderer
		}; // namespace android