Merge "Add support for CanvasOps to draw multiple lines or points in a single... (55fc541c) · Commits · e / os / android_frameworks_base

libs/hwui/canvas/CanvasOpTypes.h

+2 −0

Original line number	Diff line number	Diff line
		@@ -47,8 +47,10 @@ enum class CanvasOpType : int8_t {
		DrawArc,
		DrawPaint,
		DrawPoint,
		DrawPoints,
		DrawPath,
		DrawLine,
		DrawLines,
		DrawVertices,
		DrawImage,
		DrawImageRect,

+33 −0

Original line number	Diff line number	Diff line
		@@ -26,6 +26,7 @@
		#include <hwui/Bitmap.h>
		#include <log/log.h>
		#include "CanvasProperty.h"
		#include "Points.h"

		#include "CanvasOpTypes.h"
		#include "Layer.h"
		@@ -165,6 +166,22 @@ struct CanvasOp<CanvasOpType::DrawPoint> {
		ASSERT_DRAWABLE()
		};

		template <>
		struct CanvasOp<CanvasOpType::DrawPoints> {
		size_t count;
		SkPaint paint;
		sk_sp<Points> points;
		void draw(SkCanvas* canvas) const {
		canvas->drawPoints(
		SkCanvas::kPoints_PointMode,
		count,
		points->data(),
		paint
		);
		}
		ASSERT_DRAWABLE()
		};

		template <>
		struct CanvasOp<CanvasOpType::DrawRect> {
		SkRect rect;
		@@ -263,6 +280,22 @@ struct CanvasOp<CanvasOpType::DrawLine> {
		ASSERT_DRAWABLE()
		};

		template<>
		struct CanvasOp<CanvasOpType::DrawLines> {
		size_t count;
		SkPaint paint;
		sk_sp<Points> points;
		void draw(SkCanvas* canvas) const {
		canvas->drawPoints(
		SkCanvas::kLines_PointMode,
		count,
		points->data(),
		paint
		);
		}
		ASSERT_DRAWABLE()
		};

		template<>
		struct CanvasOp<CanvasOpType::DrawVertices> {
		sk_sp<SkVertices> vertices;

0 → 100644

+48 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2020 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/
		#include <ui/FatVector.h>
		#include "SkPoint.h"
		#include "SkRefCnt.h"

		/**
		* Collection of points that are ref counted and to be used with
		* various drawing calls that consume SkPoint as inputs like
		* drawLines/drawPoints
		*/
		class Points: public SkNVRefCnt<SkPoint> {
		public:
		Points(int size){
		skPoints.resize(size);
		}

		Points(std::initializer_list<SkPoint> init): skPoints(init) { }

		SkPoint& operator[](int index) {
		return skPoints[index];
		}

		const SkPoint* data() const {
		return skPoints.data();
		}

		size_t size() const {
		return skPoints.size();
		}
		private:
		// Initialize the size to contain 2 SkPoints on the stack for optimized
		// drawLine calls that require 2 SkPoints for start/end points of the line
		android::FatVector<SkPoint, 2> skPoints;
		};

+49 −0

Original line number	Diff line number	Diff line
		@@ -245,6 +245,31 @@ TEST(CanvasOp, simpleDrawPoint) {
		EXPECT_EQ(1, canvas.sumTotalDrawCalls());
		}

		TEST(CanvasOp, simpleDrawPoints) {
		CanvasOpBuffer buffer;
		EXPECT_EQ(buffer.size(), 0);
		size_t numPts = 3;
		auto pts = sk_ref_sp(
		new Points({
		{32, 16},
		{48, 48},
		{16, 32}
		})
		);

		buffer.push(CanvasOp<Op::DrawPoints> {
		.count = numPts,
		.paint = SkPaint{},
		.points = pts
		});

		CallCountingCanvas canvas;
		EXPECT_EQ(0, canvas.sumTotalDrawCalls());
		rasterizeCanvasBuffer(buffer, &canvas);
		EXPECT_EQ(1, canvas.drawPoints);
		EXPECT_EQ(1, canvas.sumTotalDrawCalls());
		}

		TEST(CanvasOp, simpleDrawLine) {
		CanvasOpBuffer buffer;
		EXPECT_EQ(buffer.size(), 0);
		@@ -263,6 +288,30 @@ TEST(CanvasOp, simpleDrawLine) {
		EXPECT_EQ(1, canvas.sumTotalDrawCalls());
		}

		TEST(CanvasOp, simpleDrawLines) {
		CanvasOpBuffer buffer;
		EXPECT_EQ(buffer.size(), 0);
		size_t numPts = 3;
		auto pts = sk_ref_sp(
		new Points({
		{32, 16},
		{48, 48},
		{16, 32}
		})
		);
		buffer.push(CanvasOp<Op::DrawLines> {
		.count = numPts,
		.paint = SkPaint{},
		.points = pts
		});

		CallCountingCanvas canvas;
		EXPECT_EQ(0, canvas.sumTotalDrawCalls());
		rasterizeCanvasBuffer(buffer, &canvas);
		EXPECT_EQ(1, canvas.drawPoints);
		EXPECT_EQ(1, canvas.sumTotalDrawCalls());
		}

		TEST(CanvasOp, simpleDrawRect) {
		CanvasOpBuffer buffer;
		EXPECT_EQ(buffer.size(), 0);