You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
351 lines
12 KiB
351 lines
12 KiB
/*
|
|
* Copyright 2017 Google Inc.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license that can be
|
|
* found in the LICENSE file.
|
|
*/
|
|
|
|
#include "gm.h"
|
|
#include "sk_tool_utils.h"
|
|
#include "SkCanvasPriv.h"
|
|
|
|
|
|
// This GM tests out the deprecated Android-specific unclipped saveLayer "feature".
|
|
// In particular, it attempts to compare the performance of unclipped saveLayers with alternatives.
|
|
|
|
static void save_layer_unclipped(SkCanvas* canvas,
|
|
SkScalar l, SkScalar t, SkScalar r, SkScalar b) {
|
|
SkRect rect = SkRect::MakeLTRB(l, t, r, b);
|
|
canvas->saveLayer({ &rect, nullptr, nullptr, nullptr, nullptr,
|
|
(SkCanvas::SaveLayerFlags) SkCanvasPriv::kDontClipToLayer_SaveLayerFlag });
|
|
}
|
|
|
|
static void do_draw(SkCanvas* canvas) {
|
|
SkPaint paint;
|
|
SkRandom rand;
|
|
|
|
for (int i = 0; i < 20; ++i) {
|
|
paint.setColor(sk_tool_utils::color_to_565(rand.nextU() | (0xFF << 24)));
|
|
canvas->drawRect({ 15, 15, 290, 40 }, paint);
|
|
canvas->translate(0, 30);
|
|
}
|
|
}
|
|
|
|
class UnclippedSaveLayerGM : public skiagm::GM {
|
|
public:
|
|
enum class Mode {
|
|
kClipped,
|
|
kUnclipped
|
|
};
|
|
|
|
UnclippedSaveLayerGM(Mode mode) : fMode(mode) { this->setBGColor(SK_ColorWHITE); }
|
|
|
|
protected:
|
|
bool runAsBench() const override { return true; }
|
|
|
|
SkString onShortName() override {
|
|
if (Mode::kClipped == fMode) {
|
|
return SkString("savelayer_unclipped");
|
|
} else {
|
|
SkASSERT(Mode::kUnclipped == fMode);
|
|
return SkString("savelayer_clipped");
|
|
}
|
|
}
|
|
|
|
SkISize onISize() override { return SkISize::Make(320, 640); }
|
|
|
|
void onDraw(SkCanvas* canvas) override {
|
|
const SkScalar L = 10;
|
|
const SkScalar T = 10;
|
|
const SkScalar R = 310;
|
|
const SkScalar B = 630;
|
|
|
|
canvas->clipRect({ L, T, R, B });
|
|
|
|
for (int i = 0; i < 100; ++i) {
|
|
SkAutoCanvasRestore acr(canvas, true);
|
|
if (Mode::kClipped == fMode) {
|
|
save_layer_unclipped(canvas, L, T, R, T + 20);
|
|
save_layer_unclipped(canvas, L, B - 20, R, B);
|
|
} else {
|
|
SkASSERT(Mode::kUnclipped == fMode);
|
|
canvas->saveLayer({ L, T, R, B }, nullptr);
|
|
}
|
|
|
|
do_draw(canvas);
|
|
}
|
|
}
|
|
|
|
private:
|
|
Mode fMode;
|
|
|
|
typedef skiagm::GM INHERITED;
|
|
};
|
|
DEF_GM(return new UnclippedSaveLayerGM(UnclippedSaveLayerGM::Mode::kClipped);)
|
|
DEF_GM(return new UnclippedSaveLayerGM(UnclippedSaveLayerGM::Mode::kUnclipped);)
|
|
|
|
DEF_SIMPLE_GM(picture_savelayer, canvas, 320, 640) {
|
|
SkPaint paint1, paint2, paint3;
|
|
paint1.setAlpha(0x7f);
|
|
paint2.setAlpha(0x3f);
|
|
paint3.setColor(0xFFFF0000);
|
|
SkRect rect1{40, 5, 80, 70}, rect2{5, 40, 70, 80}, rect3{10, 10, 70, 70};
|
|
// In the future, we might also test the clipped case by allowing i = 0
|
|
for(int i = 1; i < 2; ++i) {
|
|
canvas->translate(100 * i, 0);
|
|
auto flag = i ?
|
|
(SkCanvas::SaveLayerFlags) SkCanvasPriv::kDontClipToLayer_SaveLayerFlag : 0;
|
|
canvas->saveLayer({ &rect1, &paint1, nullptr, nullptr, nullptr, flag});
|
|
canvas->saveLayer({ &rect2, &paint2, nullptr, nullptr, nullptr, flag});
|
|
canvas->drawRect(rect3, paint3);
|
|
canvas->restore();
|
|
canvas->restore();
|
|
}
|
|
};
|
|
|
|
#include "Resources.h"
|
|
|
|
// Test kInitWithPrevious_SaveLayerFlag by drawing an image, save a layer with the flag, which
|
|
// should seed the layer with the image (from below). Then we punch a hole in the layer and
|
|
// restore with kPlus mode, which should show the mandrill super-bright on the outside, but
|
|
// normal where we punched the hole.
|
|
DEF_SIMPLE_GM(savelayer_initfromprev, canvas, 256, 256) {
|
|
canvas->drawImage(GetResourceAsImage("images/mandrill_256.png"), 0, 0, nullptr);
|
|
|
|
SkCanvas::SaveLayerRec rec;
|
|
SkPaint paint;
|
|
paint.setBlendMode(SkBlendMode::kPlus);
|
|
rec.fSaveLayerFlags = SkCanvas::kInitWithPrevious_SaveLayerFlag;
|
|
rec.fPaint = &paint;
|
|
canvas->saveLayer(rec);
|
|
paint.setBlendMode(SkBlendMode::kClear);
|
|
canvas->drawCircle(128, 128, 96, paint);
|
|
canvas->restore();
|
|
};
|
|
|
|
#include "SkBlurImageFilter.h"
|
|
#include "SkGradientShader.h"
|
|
#include "SkPicture.h"
|
|
#include "SkPictureRecorder.h"
|
|
#include "SkSurface.h"
|
|
|
|
static void draw_mask(SkCanvas* canvas, int size) {
|
|
const SkScalar cx = size * SK_ScalarHalf,
|
|
cy = cx;
|
|
const SkColor colors[] = { 0x00000000, 0xffff0000, 0x00000000, 0xffff0000, 0x00000000,
|
|
0xffff0000, 0x00000000, 0xffff0000, 0x00000000 };
|
|
|
|
SkPaint paint;
|
|
paint.setAntiAlias(true);
|
|
paint.setShader(SkGradientShader::MakeSweep(cx, cy, colors, nullptr, SK_ARRAY_COUNT(colors)));
|
|
canvas->drawPaint(paint);
|
|
|
|
paint.setShader(SkGradientShader::MakeRadial({cx, cy}, size / 4, colors, nullptr, 2,
|
|
SkShader::kClamp_TileMode));
|
|
canvas->drawCircle(cx, cy, size / 4, paint);
|
|
}
|
|
|
|
DEF_SIMPLE_GM(savelayer_clipmask, canvas, 1200, 1200) {
|
|
static constexpr int kSize = 100;
|
|
static constexpr SkRect kLayerBounds = { kSize * 0.25f, kSize * 0.25f,
|
|
kSize * 0.75f, kSize * 0.75f };
|
|
static constexpr struct {
|
|
const SkRect* bounds;
|
|
const SkScalar matrix[9];
|
|
} kConfigs[] = {
|
|
{ nullptr, { 1 , 0 , 0, 0 , 1 , 0, 0, 0, 1 } },
|
|
{ nullptr, { 2 , 0 , 0, 0 , 2 , 0, 0, 0, 1 } },
|
|
{ nullptr, { 2 , 0 , -50, 0 , 2 , -50, 0, 0, 1 } },
|
|
{ nullptr, { 0.707f, -0.707f, 50, 0.707f, 0.707f, -20, 0, 0, 1 } },
|
|
{ nullptr, { 0.5f , 0 , 25, 0 , 0.5f , 25, 0, 0, 1 } },
|
|
|
|
{ &kLayerBounds, { 1 , 0 , 0, 0 , 1 , 0, 0, 0, 1 } },
|
|
{ &kLayerBounds, { 2 , 0 , 0, 0 , 2 , 0, 0, 0, 1 } },
|
|
{ &kLayerBounds, { 2 , 0 , -50, 0 , 2 , -50, 0, 0, 1 } },
|
|
{ &kLayerBounds, { 0.707f, -0.707f, 50, 0.707f, 0.707f, -20, 0, 0, 1 } },
|
|
{ &kLayerBounds, { 0.5f , 0 , 25, 0 , 0.5f , 25, 0, 0, 1 } },
|
|
};
|
|
|
|
using MaskMakerFunc = sk_sp<SkImage> (*)(int size);
|
|
static const MaskMakerFunc kMaskMakers[] = {
|
|
[](int size) -> sk_sp<SkImage> {
|
|
auto surf = SkSurface::MakeRaster(SkImageInfo::MakeA8(size, size));
|
|
draw_mask(surf->getCanvas(), size);
|
|
return surf->makeImageSnapshot();
|
|
},
|
|
|
|
[](int size) -> sk_sp<SkImage> {
|
|
auto surf = SkSurface::MakeRasterN32Premul(size, size);
|
|
draw_mask(surf->getCanvas(), size);
|
|
return surf->makeImageSnapshot();
|
|
},
|
|
|
|
[](int size) -> sk_sp<SkImage> {
|
|
SkPictureRecorder recorder;
|
|
draw_mask(recorder.beginRecording(size, size), size);
|
|
return SkImage::MakeFromPicture(recorder.finishRecordingAsPicture(),
|
|
SkISize::Make(size, size),
|
|
nullptr, nullptr,
|
|
SkImage::BitDepth::kU8,
|
|
SkColorSpace::MakeSRGB());
|
|
}
|
|
};
|
|
|
|
using PaintMakerFunc = SkPaint (*)();
|
|
static const PaintMakerFunc kPaintMakers[] = {
|
|
[]() -> SkPaint { return SkPaint(); },
|
|
[]() -> SkPaint {
|
|
SkPaint p; p.setImageFilter(SkBlurImageFilter::Make(2, 2, nullptr)); return p;
|
|
},
|
|
[]() -> SkPaint { SkPaint p; p.setBlendMode(SkBlendMode::kSrcOut); return p; },
|
|
};
|
|
|
|
canvas->drawColor(0xffcccccc);
|
|
|
|
SkMatrix clipMatrix;
|
|
SkCanvas::SaveLayerRec rec;
|
|
rec.fClipMatrix = &clipMatrix;
|
|
|
|
for (const auto& paintMaker : kPaintMakers) {
|
|
auto layerPaint = paintMaker();
|
|
rec.fPaint = &layerPaint;
|
|
|
|
for (const auto& maskMaker : kMaskMakers) {
|
|
sk_sp<SkImage> mask = maskMaker(kSize);
|
|
rec.fClipMask = mask.get();
|
|
|
|
canvas->save();
|
|
for (const auto cfg : kConfigs) {
|
|
rec.fBounds = cfg.bounds;
|
|
clipMatrix.set9(cfg.matrix);
|
|
canvas->saveLayer(rec);
|
|
|
|
SkPaint paint;
|
|
paint.setColor(0xff0000ff);
|
|
canvas->drawRect(SkRect::MakeWH(50, 50), paint);
|
|
paint.setColor(0xffff0000);
|
|
canvas->drawRect(SkRect::MakeXYWH(50, 0, 50, 50), paint);
|
|
paint.setColor(0xff00ff00);
|
|
canvas->drawRect(SkRect::MakeXYWH(50, 50, 50, 50), paint);
|
|
paint.setColor(0xffffff00);
|
|
canvas->drawRect(SkRect::MakeXYWH(0, 50, 50, 50), paint);
|
|
|
|
canvas->restore();
|
|
canvas->translate(120, 0);
|
|
}
|
|
canvas->restore();
|
|
canvas->translate(0, 120);
|
|
}
|
|
}
|
|
}
|
|
|
|
DEF_SIMPLE_GM(savelayer_coverage, canvas, 500, 500) {
|
|
canvas->saveLayer(nullptr, nullptr);
|
|
|
|
SkRect r = { 0, 0, 200, 200 };
|
|
SkPaint layerPaint;
|
|
layerPaint.setBlendMode(SkBlendMode::kModulate);
|
|
|
|
auto image = GetResourceAsImage("images/mandrill_128.png");
|
|
|
|
auto proc = [layerPaint](SkCanvas* canvas, SkCanvas::SaveLayerRec& rec) {
|
|
SkPaint paint;
|
|
paint.setColor(SK_ColorRED);
|
|
|
|
canvas->saveLayer(rec);
|
|
canvas->drawCircle(100, 100, 50, paint);
|
|
paint.setColor(0x8800FF00);
|
|
canvas->drawRect({10, 90, 190, 110}, paint);
|
|
canvas->restore();
|
|
};
|
|
|
|
const int yflags[] = { 0, SkCanvas::kInitWithPrevious_SaveLayerFlag };
|
|
for (int y = 0; y <= 1; ++y) {
|
|
const int xflags[] = { 0, SkCanvas::kMaskAgainstCoverage_EXPERIMENTAL_DONT_USE_SaveLayerFlag };
|
|
for (int x = 0; x <= 1; ++x) {
|
|
canvas->save();
|
|
canvas->translate(x * 200.f, y * 200.f);
|
|
|
|
SkCanvas::SaveLayerRec rec(&r, &layerPaint, yflags[y] | xflags[x]);
|
|
canvas->drawImageRect(image, r, nullptr);
|
|
proc(canvas, rec);
|
|
|
|
canvas->restore();
|
|
}
|
|
}
|
|
|
|
canvas->restore();
|
|
}
|
|
|
|
#include "SkFont.h"
|
|
#include "SkGradientShader.h"
|
|
#include "SkTextBlob.h"
|
|
|
|
static void draw_cell(SkCanvas* canvas, sk_sp<SkTextBlob> blob, SkColor c, SkScalar w, SkScalar h) {
|
|
SkRect r = SkRect::MakeWH(w, h);
|
|
SkPaint p;
|
|
p.setColor(c);
|
|
p.setBlendMode(SkBlendMode::kSrc);
|
|
canvas->drawRect(r, p);
|
|
p.setBlendMode(SkBlendMode::kSrcOver);
|
|
|
|
const SkScalar margin = 80;
|
|
r.fLeft = w - margin;
|
|
|
|
// save the behind image
|
|
SkDEBUGCODE(int sc0 =) canvas->getSaveCount();
|
|
SkDEBUGCODE(int sc1 =) SkCanvasPriv::SaveBehind(canvas, &r);
|
|
SkDEBUGCODE(int sc2 =) canvas->getSaveCount();
|
|
SkASSERT(sc0 == sc1);
|
|
SkASSERT(sc0 + 1 == sc2);
|
|
|
|
// draw the foreground (including over the 'behind' section)
|
|
p.setColor(SK_ColorBLACK);
|
|
canvas->drawTextBlob(blob, 10, 30, p);
|
|
|
|
// draw the treatment
|
|
const SkPoint pts[] = { {r.fLeft,0}, {r.fRight, 0} };
|
|
const SkColor colors[] = { 0x88000000, 0x0 };
|
|
auto sh = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode);
|
|
p.setShader(sh);
|
|
p.setBlendMode(SkBlendMode::kDstIn);
|
|
canvas->drawRect(r, p);
|
|
|
|
// this should restore the behind image
|
|
canvas->restore();
|
|
SkDEBUGCODE(int sc3 =) canvas->getSaveCount();
|
|
SkASSERT(sc3 == sc0);
|
|
|
|
// just outline where we expect the treatment to appear
|
|
p.reset();
|
|
p.setStyle(SkPaint::kStroke_Style);
|
|
p.setAlpha(0x40);
|
|
canvas->drawRect(r, p);
|
|
}
|
|
|
|
static void draw_list(SkCanvas* canvas, sk_sp<SkTextBlob> blob) {
|
|
SkAutoCanvasRestore acr(canvas, true);
|
|
|
|
SkRandom rand;
|
|
SkScalar w = 400;
|
|
SkScalar h = 40;
|
|
for (int i = 0; i < 8; ++i) {
|
|
SkColor c = rand.nextU(); // ensure we're opaque
|
|
c = (c & 0xFFFFFF) | 0x80000000;
|
|
draw_cell(canvas, blob, c, w, h);
|
|
canvas->translate(0, h);
|
|
}
|
|
}
|
|
|
|
DEF_SIMPLE_GM(save_behind, canvas, 400, 670) {
|
|
SkFont font;
|
|
font.setSize(30);
|
|
const char text[] = "This is a very long line of text";
|
|
auto blob = SkTextBlob::MakeFromText(text, strlen(text), font);
|
|
|
|
draw_list(canvas, blob);
|
|
canvas->translate(0, 350);
|
|
canvas->saveLayer({0, 0, 400, 320}, nullptr);
|
|
draw_list(canvas, blob);
|
|
}
|