pass Paint not SkPaint to Canvas (c2dbc03a) · Commits · e / os / android_frameworks_base

libs/hwui/SkiaCanvas.cpp

+87 −52

Original line number	Diff line number	Diff line
		@@ -454,7 +454,7 @@ void SkiaCanvas::drawPaint(const SkPaint& paint) {
		// Canvas draw operations: Geometry
		// ----------------------------------------------------------------------------

		void SkiaCanvas::drawPoints(const float* points, int count, const SkPaint& paint,
		void SkiaCanvas::drawPoints(const float* points, int count, const Paint& paint,
		SkCanvas::PointMode mode) {
		if (CC_UNLIKELY(count < 2 \|\| paint.nothingToDraw())) return;
		// convert the floats into SkPoints
		@@ -464,109 +464,142 @@ void SkiaCanvas::drawPoints(const float* points, int count, const SkPaint& paint
		pts[i].set(points[0], points[1]);
		points += 2;
		}
		mCanvas->drawPoints(mode, count, pts.get(), *filterPaint(paint));

		apply_looper(&paint, [&](const SkPaint& p) {
		mCanvas->drawPoints(mode, count, pts.get(), p);
		});
		}

		void SkiaCanvas::drawPoint(float x, float y, const SkPaint& paint) {
		mCanvas->drawPoint(x, y, *filterPaint(paint));
		void SkiaCanvas::drawPoint(float x, float y, const Paint& paint) {
		apply_looper(&paint, [&](const SkPaint& p) {
		mCanvas->drawPoint(x, y, p);
		});
		}

		void SkiaCanvas::drawPoints(const float* points, int count, const SkPaint& paint) {
		this->drawPoints(points, count, *filterPaint(paint), SkCanvas::kPoints_PointMode);
		void SkiaCanvas::drawPoints(const float* points, int count, const Paint& paint) {
		this->drawPoints(points, count, paint, SkCanvas::kPoints_PointMode);
		}

		void SkiaCanvas::drawLine(float startX, float startY, float stopX, float stopY,
		const SkPaint& paint) {
		mCanvas->drawLine(startX, startY, stopX, stopY, *filterPaint(paint));
		const Paint& paint) {
		apply_looper(&paint, [&](const SkPaint& p) {
		mCanvas->drawLine(startX, startY, stopX, stopY, p);
		});
		}

		void SkiaCanvas::drawLines(const float* points, int count, const SkPaint& paint) {
		void SkiaCanvas::drawLines(const float* points, int count, const Paint& paint) {
		if (CC_UNLIKELY(count < 4 \|\| paint.nothingToDraw())) return;
		this->drawPoints(points, count, *filterPaint(paint), SkCanvas::kLines_PointMode);
		this->drawPoints(points, count, paint, SkCanvas::kLines_PointMode);
		}

		void SkiaCanvas::drawRect(float left, float top, float right, float bottom, const SkPaint& paint) {
		void SkiaCanvas::drawRect(float left, float top, float right, float bottom, const Paint& paint) {
		if (CC_UNLIKELY(paint.nothingToDraw())) return;
		mCanvas->drawRect({left, top, right, bottom}, *filterPaint(paint));
		apply_looper(&paint, [&](const SkPaint& p) {
		mCanvas->drawRect({left, top, right, bottom}, p);
		});
		}

		void SkiaCanvas::drawRegion(const SkRegion& region, const SkPaint& paint) {
		void SkiaCanvas::drawRegion(const SkRegion& region, const Paint& paint) {
		if (CC_UNLIKELY(paint.nothingToDraw())) return;
		mCanvas->drawRegion(region, *filterPaint(paint));
		apply_looper(&paint, [&](const SkPaint& p) {
		mCanvas->drawRegion(region, p);
		});
		}

		void SkiaCanvas::drawRoundRect(float left, float top, float right, float bottom, float rx, float ry,
		const SkPaint& paint) {
		const Paint& paint) {
		if (CC_UNLIKELY(paint.nothingToDraw())) return;
		SkRect rect = SkRect::MakeLTRB(left, top, right, bottom);
		mCanvas->drawRoundRect(rect, rx, ry, *filterPaint(paint));
		apply_looper(&paint, [&](const SkPaint& p) {
		mCanvas->drawRoundRect(rect, rx, ry, p);
		});
		}

		void SkiaCanvas::drawDoubleRoundRect(const SkRRect& outer, const SkRRect& inner,
		const SkPaint& paint) {
		mCanvas->drawDRRect(outer, inner, *filterPaint(paint));
		const Paint& paint) {
		apply_looper(&paint, [&](const SkPaint& p) {
		mCanvas->drawDRRect(outer, inner, p);
		});
		}

		void SkiaCanvas::drawCircle(float x, float y, float radius, const SkPaint& paint) {
		void SkiaCanvas::drawCircle(float x, float y, float radius, const Paint& paint) {
		if (CC_UNLIKELY(radius <= 0 \|\| paint.nothingToDraw())) return;
		mCanvas->drawCircle(x, y, radius, *filterPaint(paint));
		apply_looper(&paint, [&](const SkPaint& p) {
		mCanvas->drawCircle(x, y, radius, p);
		});
		}

		void SkiaCanvas::drawOval(float left, float top, float right, float bottom, const SkPaint& paint) {
		void SkiaCanvas::drawOval(float left, float top, float right, float bottom, const Paint& paint) {
		if (CC_UNLIKELY(paint.nothingToDraw())) return;
		SkRect oval = SkRect::MakeLTRB(left, top, right, bottom);
		mCanvas->drawOval(oval, *filterPaint(paint));
		apply_looper(&paint, [&](const SkPaint& p) {
		mCanvas->drawOval(oval, p);
		});
		}

		void SkiaCanvas::drawArc(float left, float top, float right, float bottom, float startAngle,
		float sweepAngle, bool useCenter, const SkPaint& paint) {
		float sweepAngle, bool useCenter, const Paint& paint) {
		if (CC_UNLIKELY(paint.nothingToDraw())) return;
		SkRect arc = SkRect::MakeLTRB(left, top, right, bottom);
		apply_looper(&paint, [&](const SkPaint& p) {
		if (fabs(sweepAngle) >= 360.0f) {
		mCanvas->drawOval(arc, *filterPaint(paint));
		mCanvas->drawOval(arc, p);
		} else {
		mCanvas->drawArc(arc, startAngle, sweepAngle, useCenter, *filterPaint(paint));
		mCanvas->drawArc(arc, startAngle, sweepAngle, useCenter, p);
		}
		});
		}

		void SkiaCanvas::drawPath(const SkPath& path, const SkPaint& paint) {
		void SkiaCanvas::drawPath(const SkPath& path, const Paint& paint) {
		if (CC_UNLIKELY(paint.nothingToDraw())) return;
		if (CC_UNLIKELY(path.isEmpty() && (!path.isInverseFillType()))) {
		return;
		}
		mCanvas->drawPath(path, *filterPaint(paint));
		apply_looper(&paint, [&](const SkPaint& p) {
		mCanvas->drawPath(path, p);
		});
		}

		void SkiaCanvas::drawVertices(const SkVertices* vertices, SkBlendMode mode, const SkPaint& paint) {
		mCanvas->drawVertices(vertices, mode, *filterPaint(paint));
		void SkiaCanvas::drawVertices(const SkVertices* vertices, SkBlendMode mode, const Paint& paint) {
		apply_looper(&paint, [&](const SkPaint& p) {
		mCanvas->drawVertices(vertices, mode, p);
		});
		}

		// ----------------------------------------------------------------------------
		// Canvas draw operations: Bitmaps
		// ----------------------------------------------------------------------------

		void SkiaCanvas::drawBitmap(Bitmap& bitmap, float left, float top, const SkPaint* paint) {
		mCanvas->drawImage(bitmap.makeImage(), left, top, filterPaint(paint));
		void SkiaCanvas::drawBitmap(Bitmap& bitmap, float left, float top, const Paint* paint) {
		auto image = bitmap.makeImage();
		apply_looper(paint, [&](const SkPaint& p) {
		mCanvas->drawImage(image, left, top, &p);
		});
		}

		void SkiaCanvas::drawBitmap(Bitmap& bitmap, const SkMatrix& matrix, const SkPaint* paint) {
		void SkiaCanvas::drawBitmap(Bitmap& bitmap, const SkMatrix& matrix, const Paint* paint) {
		auto image = bitmap.makeImage();
		SkAutoCanvasRestore acr(mCanvas, true);
		mCanvas->concat(matrix);
		mCanvas->drawImage(bitmap.makeImage(), 0, 0, filterPaint(paint));
		apply_looper(paint, [&](const SkPaint& p) {
		mCanvas->drawImage(image, 0, 0, &p);
		});
		}

		void SkiaCanvas::drawBitmap(Bitmap& bitmap, float srcLeft, float srcTop, float srcRight,
		float srcBottom, float dstLeft, float dstTop, float dstRight,
		float dstBottom, const SkPaint* paint) {
		float dstBottom, const Paint* paint) {
		auto image = bitmap.makeImage();
		SkRect srcRect = SkRect::MakeLTRB(srcLeft, srcTop, srcRight, srcBottom);
		SkRect dstRect = SkRect::MakeLTRB(dstLeft, dstTop, dstRight, dstBottom);

		mCanvas->drawImageRect(bitmap.makeImage(), srcRect, dstRect, filterPaint(paint),
		SkCanvas::kFast_SrcRectConstraint);
		apply_looper(paint, [&](const SkPaint& p) {
		mCanvas->drawImageRect(image, srcRect, dstRect, &p, SkCanvas::kFast_SrcRectConstraint);
		});
		}

		void SkiaCanvas::drawBitmapMesh(Bitmap& bitmap, int meshWidth, int meshHeight,
		const float* vertices, const int* colors, const SkPaint* paint) {
		const float* vertices, const int* colors, const Paint* paint) {
		const int ptCount = (meshWidth + 1) * (meshHeight + 1);
		const int indexCount = meshWidth * meshHeight * 6;
		uint32_t flags = SkVertices::kHasTexCoords_BuilderFlag;
		@@ -640,20 +673,20 @@ void SkiaCanvas::drawBitmapMesh(Bitmap& bitmap, int meshWidth, int meshHeight,
		#endif

		// cons-up a shader for the bitmap
		PaintCoW paintCoW(paint);
		SkPaint& tmpPaint = paintCoW.writeable();

		sk_sp<SkImage> image = bitmap.makeImage();
		sk_sp<SkShader> shader = image->makeShader();
		tmpPaint.setShader(std::move(shader));

		mCanvas->drawVertices(builder.detach(), SkBlendMode::kModulate,
		*filterPaint(std::move(paintCoW)));
		Paint pnt;
		if (paint) {
		pnt = *paint;
		}
		pnt.setShader(bitmap.makeImage()->makeShader());
		auto v = builder.detach();
		apply_looper(&pnt, [&](const SkPaint& p) {
		mCanvas->drawVertices(v, SkBlendMode::kModulate, p);
		});
		}

		void SkiaCanvas::drawNinePatch(Bitmap& bitmap, const Res_png_9patch& chunk, float dstLeft,
		float dstTop, float dstRight, float dstBottom,
		const SkPaint* paint) {
		const Paint* paint) {
		SkCanvas::Lattice lattice;
		NinePatchUtils::SetLatticeDivs(&lattice, chunk, bitmap.width(), bitmap.height());

		@@ -674,8 +707,10 @@ void SkiaCanvas::drawNinePatch(Bitmap& bitmap, const Res_png_9patch& chunk, floa

		lattice.fBounds = nullptr;
		SkRect dst = SkRect::MakeLTRB(dstLeft, dstTop, dstRight, dstBottom);

		mCanvas->drawImageLattice(bitmap.makeImage().get(), lattice, dst, filterPaint(paint));
		auto image = bitmap.makeImage();
		apply_looper(paint, [&](const SkPaint& p) {
		mCanvas->drawImageLattice(image.get(), lattice, dst, &p);
		});
		}

		double SkiaCanvas::drawAnimatedImage(AnimatedImageDrawable* imgDrawable) {

libs/hwui/SkiaCanvas.h

+50 −19

Original line number	Diff line number	Diff line
		@@ -22,8 +22,10 @@
		#include "RenderNode.h"
		#include "VectorDrawable.h"
		#include "hwui/Canvas.h"
		#include "hwui/Paint.h"

		#include <SkCanvas.h>
		#include "src/core/SkArenaAlloc.h"

		#include <cassert>
		#include <optional>
		@@ -99,39 +101,39 @@ public:
		virtual void drawColor(int color, SkBlendMode mode) override;
		virtual void drawPaint(const SkPaint& paint) override;

		virtual void drawPoint(float x, float y, const SkPaint& paint) override;
		virtual void drawPoints(const float* points, int count, const SkPaint& paint) override;
		virtual void drawPoint(float x, float y, const Paint& paint) override;
		virtual void drawPoints(const float* points, int count, const Paint& paint) override;
		virtual void drawLine(float startX, float startY, float stopX, float stopY,
		const SkPaint& paint) override;
		virtual void drawLines(const float* points, int count, const SkPaint& paint) override;
		const Paint& paint) override;
		virtual void drawLines(const float* points, int count, const Paint& paint) override;
		virtual void drawRect(float left, float top, float right, float bottom,
		const SkPaint& paint) override;
		virtual void drawRegion(const SkRegion& region, const SkPaint& paint) override;
		const Paint& paint) override;
		virtual void drawRegion(const SkRegion& region, const Paint& paint) override;
		virtual void drawRoundRect(float left, float top, float right, float bottom, float rx, float ry,
		const SkPaint& paint) override;
		const Paint& paint) override;

		virtual void drawDoubleRoundRect(const SkRRect& outer, const SkRRect& inner,
		const SkPaint& paint) override;
		const Paint& paint) override;

		virtual void drawCircle(float x, float y, float radius, const SkPaint& paint) override;
		virtual void drawCircle(float x, float y, float radius, const Paint& paint) override;
		virtual void drawOval(float left, float top, float right, float bottom,
		const SkPaint& paint) override;
		const Paint& paint) override;
		virtual void drawArc(float left, float top, float right, float bottom, float startAngle,
		float sweepAngle, bool useCenter, const SkPaint& paint) override;
		virtual void drawPath(const SkPath& path, const SkPaint& paint) override;
		virtual void drawVertices(const SkVertices*, SkBlendMode, const SkPaint& paint) override;
		float sweepAngle, bool useCenter, const Paint& paint) override;
		virtual void drawPath(const SkPath& path, const Paint& paint) override;
		virtual void drawVertices(const SkVertices*, SkBlendMode, const Paint& paint) override;

		virtual void drawBitmap(Bitmap& bitmap, float left, float top, const SkPaint* paint) override;
		virtual void drawBitmap(Bitmap& bitmap, const SkMatrix& matrix, const SkPaint* paint) override;
		virtual void drawBitmap(Bitmap& bitmap, float left, float top, const Paint* paint) override;
		virtual void drawBitmap(Bitmap& bitmap, const SkMatrix& matrix, const Paint* paint) override;
		virtual void drawBitmap(Bitmap& bitmap, float srcLeft, float srcTop, float srcRight,
		float srcBottom, float dstLeft, float dstTop, float dstRight,
		float dstBottom, const SkPaint* paint) override;
		float dstBottom, const Paint* paint) override;
		virtual void drawBitmapMesh(Bitmap& bitmap, int meshWidth, int meshHeight,
		const float* vertices, const int* colors,
		const SkPaint* paint) override;
		const Paint* paint) override;
		virtual void drawNinePatch(Bitmap& bitmap, const android::Res_png_9patch& chunk, float dstLeft,
		float dstTop, float dstRight, float dstBottom,
		const SkPaint* paint) override;
		const Paint* paint) override;
		virtual double drawAnimatedImage(AnimatedImageDrawable* imgDrawable) override;

		virtual bool drawTextAbsolutePos() const override { return true; }
		@@ -208,6 +210,35 @@ protected:
		*/
		PaintCoW&& filterPaint(PaintCoW&& paint) const;

		template <typename Proc> void apply_looper(const Paint* paint, Proc proc) {
		SkPaint skp;
		SkDrawLooper* looper = nullptr;
		if (paint) {
		skp = *filterPaint(paint);
		looper = paint->getLooper();
		}
		if (looper) {
		SkSTArenaAlloc<256> alloc;
		SkDrawLooper::Context* ctx = looper->makeContext(&alloc);
		if (ctx) {
		SkDrawLooper::Context::Info info;
		for (;;) {
		SkPaint p = skp;
		if (!ctx->next(&info, &p)) {
		break;
		}
		mCanvas->save();
		mCanvas->translate(info.fTranslate.fX, info.fTranslate.fY);
		proc(p);
		mCanvas->restore();
		}
		}
		} else {
		proc(skp);
		}
		}


		private:
		struct SaveRec {
		int saveCount;
		@@ -222,7 +253,7 @@ private:
		void recordClip(const T&, SkClipOp);
		void applyPersistentClips(size_t clipStartIndex);

		void drawPoints(const float* points, int count, const SkPaint& paint, SkCanvas::PointMode mode);
		void drawPoints(const float* points, int count, const Paint& paint, SkCanvas::PointMode mode);

		class Clip;

libs/hwui/VectorDrawable.cpp

+7 −2

Original line number	Diff line number	Diff line
		@@ -17,6 +17,7 @@
		#include "VectorDrawable.h"

		#include <utils/Log.h>
		#include "hwui/Paint.h"
		#include "PathParser.h"
		#include "SkColorFilter.h"
		#include "SkImageInfo.h"
		@@ -458,8 +459,12 @@ void Tree::drawStaging(Canvas* outCanvas) {
		mStagingCache.dirty = false;
		}

		SkPaint paint;
		getPaintFor(&paint, mStagingProperties);
		SkPaint skp;
		getPaintFor(&skp, mStagingProperties);
		Paint paint;
		paint.setFilterQuality(skp.getFilterQuality());
		paint.setColorFilter(skp.refColorFilter());
		paint.setAlpha(skp.getAlpha());
		outCanvas->drawBitmap(*mStagingCache.bitmap, 0, 0, mStagingCache.bitmap->width(),
		mStagingCache.bitmap->height(), mStagingProperties.getBounds().left(),
		mStagingProperties.getBounds().top(),

libs/hwui/hwui/Canvas.cpp

+3 −3

Original line number	Diff line number	Diff line
		@@ -34,7 +34,7 @@ Canvas* Canvas::create_recording_canvas(int width, int height, uirenderer::Rende
		}

		static inline void drawStroke(SkScalar left, SkScalar right, SkScalar top, SkScalar thickness,
		const SkPaint& paint, Canvas* canvas) {
		const Paint& paint, Canvas* canvas) {
		const SkScalar strokeWidth = fmax(thickness, 1.0f);
		const SkScalar bottom = top + strokeWidth;
		canvas->drawRect(left, top, right, bottom, paint);
		@@ -182,7 +182,7 @@ void Canvas::drawText(const uint16_t* text, int textSize, int start, int count,
		void Canvas::drawDoubleRoundRectXY(float outerLeft, float outerTop, float outerRight,
		float outerBottom, float outerRx, float outerRy, float innerLeft,
		float innerTop, float innerRight, float innerBottom, float innerRx,
		float innerRy, const SkPaint& paint) {
		float innerRy, const Paint& paint) {
		if (CC_UNLIKELY(paint.nothingToDraw())) return;
		SkRect outer = SkRect::MakeLTRB(outerLeft, outerTop, outerRight, outerBottom);
		SkRect inner = SkRect::MakeLTRB(innerLeft, innerTop, innerRight, innerBottom);
		@@ -198,7 +198,7 @@ void Canvas::drawDoubleRoundRectXY(float outerLeft, float outerTop, float outerR
		void Canvas::drawDoubleRoundRectRadii(float outerLeft, float outerTop, float outerRight,
		float outerBottom, const float* outerRadii, float innerLeft,
		float innerTop, float innerRight, float innerBottom,
		const float* innerRadii, const SkPaint& paint) {
		const float* innerRadii, const Paint& paint) {
		static_assert(sizeof(SkVector) == sizeof(float) * 2);
		if (CC_UNLIKELY(paint.nothingToDraw())) return;
		SkRect outer = SkRect::MakeLTRB(outerLeft, outerTop, outerRight, outerBottom);

libs/hwui/hwui/Canvas.h

+20 −20

Original line number	Diff line number	Diff line
		@@ -217,37 +217,37 @@ public:
		virtual void drawPaint(const SkPaint& paint) = 0;

		// Geometry
		virtual void drawPoint(float x, float y, const SkPaint& paint) = 0;
		virtual void drawPoints(const float* points, int floatCount, const SkPaint& paint) = 0;
		virtual void drawPoint(float x, float y, const Paint& paint) = 0;
		virtual void drawPoints(const float* points, int floatCount, const Paint& paint) = 0;
		virtual void drawLine(float startX, float startY, float stopX, float stopY,
		const SkPaint& paint) = 0;
		virtual void drawLines(const float* points, int floatCount, const SkPaint& paint) = 0;
		const Paint& paint) = 0;
		virtual void drawLines(const float* points, int floatCount, const Paint& paint) = 0;
		virtual void drawRect(float left, float top, float right, float bottom,
		const SkPaint& paint) = 0;
		virtual void drawRegion(const SkRegion& region, const SkPaint& paint) = 0;
		const Paint& paint) = 0;
		virtual void drawRegion(const SkRegion& region, const Paint& paint) = 0;
		virtual void drawRoundRect(float left, float top, float right, float bottom, float rx, float ry,
		const SkPaint& paint) = 0;
		const Paint& paint) = 0;
		virtual void drawDoubleRoundRect(const SkRRect& outer, const SkRRect& inner,
		const SkPaint& paint) = 0;
		virtual void drawCircle(float x, float y, float radius, const SkPaint& paint) = 0;
		const Paint& paint) = 0;
		virtual void drawCircle(float x, float y, float radius, const Paint& paint) = 0;
		virtual void drawOval(float left, float top, float right, float bottom,
		const SkPaint& paint) = 0;
		const Paint& paint) = 0;
		virtual void drawArc(float left, float top, float right, float bottom, float startAngle,
		float sweepAngle, bool useCenter, const SkPaint& paint) = 0;
		virtual void drawPath(const SkPath& path, const SkPaint& paint) = 0;
		virtual void drawVertices(const SkVertices*, SkBlendMode, const SkPaint& paint) = 0;
		float sweepAngle, bool useCenter, const Paint& paint) = 0;
		virtual void drawPath(const SkPath& path, const Paint& paint) = 0;
		virtual void drawVertices(const SkVertices*, SkBlendMode, const Paint& paint) = 0;

		// Bitmap-based
		virtual void drawBitmap(Bitmap& bitmap, float left, float top, const SkPaint* paint) = 0;
		virtual void drawBitmap(Bitmap& bitmap, const SkMatrix& matrix, const SkPaint* paint) = 0;
		virtual void drawBitmap(Bitmap& bitmap, float left, float top, const Paint* paint) = 0;
		virtual void drawBitmap(Bitmap& bitmap, const SkMatrix& matrix, const Paint* paint) = 0;
		virtual void drawBitmap(Bitmap& bitmap, float srcLeft, float srcTop, float srcRight,
		float srcBottom, float dstLeft, float dstTop, float dstRight,
		float dstBottom, const SkPaint* paint) = 0;
		float dstBottom, const Paint* paint) = 0;
		virtual void drawBitmapMesh(Bitmap& bitmap, int meshWidth, int meshHeight,
		const float* vertices, const int* colors, const SkPaint* paint) = 0;
		const float* vertices, const int* colors, const Paint* paint) = 0;
		virtual void drawNinePatch(Bitmap& bitmap, const android::Res_png_9patch& chunk, float dstLeft,
		float dstTop, float dstRight, float dstBottom,
		const SkPaint* paint) = 0;
		const Paint* paint) = 0;

		virtual double drawAnimatedImage(AnimatedImageDrawable* imgDrawable) = 0;
		virtual void drawPicture(const SkPicture& picture) = 0;
		@@ -281,12 +281,12 @@ public:
		void drawDoubleRoundRectXY(float outerLeft, float outerTop, float outerRight,
		float outerBottom, float outerRx, float outerRy, float innerLeft,
		float innerTop, float innerRight, float innerBottom, float innerRx,
		float innerRy, const SkPaint& paint);
		float innerRy, const Paint& paint);

		void drawDoubleRoundRectRadii(float outerLeft, float outerTop, float outerRight,
		float outerBottom, const float* outerRadii, float innerLeft,
		float innerTop, float innerRight, float innerBottom,
		const float* innerRadii, const SkPaint& paint);
		const float* innerRadii, const Paint& paint);

		static int GetApiLevel() { return sApiLevel; }