Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 4285c8a3 authored by Nader Jawad's avatar Nader Jawad
Browse files

Add support for CanvasOps to draw multiple lines or 

points in a single call
--DrawPoints
--DrawLines

Introduced wrapper Points class to
handle containing collections of SkPoints
that is compatible with ref counted pointer
implementations

Bug: 174854640
Test: Added tests to CanvasOpTests
Change-Id: Id4a47a470815d2970c54dac25e59af8512193348
parent 27bb3d0c

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,

libs/hwui/canvas/CanvasOps.h

+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;

libs/hwui/canvas/Points.h

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;

};

libs/hwui/tests/unit/CanvasOpTests.cpp

+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);