libs/hwui/tests/common/scenes/ShapeAnimation.cpp

/*
 * Copyright (C) 2015 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 "TestSceneBase.h"
#include "utils/Color.h"

#include <cstdio>

class ShapeAnimation;

static TestScene::Registrar _Shapes(TestScene::Info{
    "shapes",
    "A grid of shape drawing test cases.",
    TestScene::simpleCreateScene<ShapeAnimation>
});

class ShapeAnimation : public TestScene {
public:
    sp<RenderNode> card;
    void createContent(int width, int height, TestCanvas& canvas) override {
        card = TestUtils::createNode(0, 0, width, height,
                [width](RenderProperties& props, TestCanvas& canvas) {
            std::function<void(TestCanvas&, float, const SkPaint&)> ops[] = {
                [](TestCanvas& canvas, float size, const SkPaint& paint) {
                    canvas.drawArc(0, 0, size, size, 50, 189, true, paint);
                },
                [](TestCanvas& canvas, float size, const SkPaint& paint) {
                    canvas.drawOval(0, 0, size, size, paint);
                },
                [](TestCanvas& canvas, float size, const SkPaint& paint) {
                    SkPath diamondPath;
                    diamondPath.moveTo(size / 2, 0);
                    diamondPath.lineTo(size, size / 2);
                    diamondPath.lineTo(size / 2, size);
                    diamondPath.lineTo(0, size / 2);
                    diamondPath.close();
                    canvas.drawPath(diamondPath, paint);
                },
                [](TestCanvas& canvas, float size, const SkPaint& paint) {
                    float data[] = {0, 0, size, size, 0, size, size, 0 };
                    canvas.drawLines(data, sizeof(data) / sizeof(float), paint);
                },
                [](TestCanvas& canvas, float size, const SkPaint& paint) {
                    float data[] = {0, 0, size, size, 0, size, size, 0 };
                    canvas.drawPoints(data, sizeof(data) / sizeof(float), paint);
                },
                [](TestCanvas& canvas, float size, const SkPaint& paint) {
                    canvas.drawRect(0, 0, size, size, paint);
                },
                [](TestCanvas& canvas, float size, const SkPaint& paint) {
                    float rad = size / 4;
                    canvas.drawRoundRect(0, 0, size, size, rad, rad, paint);
                }
            };
            float cellSpace = dp(4);
            float cellSize = floorf(width / 7 - cellSpace);

            // each combination of strokeWidth + style gets a column
            int outerCount = canvas.save(SkCanvas::kMatrixClip_SaveFlag);
            SkPaint paint;
            paint.setAntiAlias(true);
            SkPaint::Style styles[] = {
                    SkPaint::kStroke_Style, SkPaint::kFill_Style, SkPaint::kStrokeAndFill_Style };
            for (auto style : styles) {
                paint.setStyle(style);
                for (auto strokeWidth : { 0.0f, 0.5f, 8.0f }) {
                    paint.setStrokeWidth(strokeWidth);
                    // fill column with each op
                    int middleCount = canvas.save(SkCanvas::kMatrixClip_SaveFlag);
                    for (auto op : ops) {
                        int innerCount = canvas.save(SkCanvas::kMatrixClip_SaveFlag);
                        canvas.clipRect(0, 0, cellSize, cellSize, SkRegion::kIntersect_Op);
                        canvas.drawColor(Color::White, SkXfermode::Mode::kSrcOver_Mode);
                        op(canvas, cellSize, paint);
                        canvas.restoreToCount(innerCount);
                        canvas.translate(cellSize + cellSpace, 0);
                    }
                    canvas.restoreToCount(middleCount);
                    canvas.translate(0, cellSize + cellSpace);
                }
            }
            canvas.restoreToCount(outerCount);
        });
        canvas.drawColor(Color::Grey_500, SkXfermode::Mode::kSrcOver_Mode);
        canvas.drawRenderNode(card.get());
    }

    void doFrame(int frameNr) override {
        card->mutateStagingProperties().setTranslationY(frameNr % 150);
        card->setPropertyFieldsDirty(RenderNode::Y);
    }
};