| /* | |
| * Copyright 2016 Google Inc. | |
| * | |
| * Use of this source code is governed by a BSD-style license that can be | |
| * found in the LICENSE file. | |
| */ | |
| #include "gm/gm.h" | |
| #include "include/core/SkBitmap.h" | |
| #include "include/core/SkBlendMode.h" | |
| #include "include/core/SkCanvas.h" | |
| #include "include/core/SkColor.h" | |
| #include "include/core/SkImage.h" | |
| #include "include/core/SkImageInfo.h" | |
| #include "include/core/SkPaint.h" | |
| #include "include/core/SkRect.h" | |
| #include "include/core/SkRefCnt.h" | |
| #include "include/core/SkScalar.h" | |
| #include "include/core/SkSize.h" | |
| #include "include/core/SkString.h" | |
| #include "include/core/SkSurface.h" | |
| #include "include/gpu/GrDirectContext.h" | |
| #include "include/private/base/SkMalloc.h" | |
| #include "tools/ToolUtils.h" | |
| static sk_sp<SkSurface> make_surface(SkCanvas* root, int N, int padLeft, int padTop, | |
| int padRight, int padBottom) { | |
| SkImageInfo info = SkImageInfo::MakeN32Premul(N + padLeft + padRight, N + padTop + padBottom); | |
| return ToolUtils::makeSurface(root, info); | |
| } | |
| static sk_sp<SkImage> make_image(SkCanvas* root, int* xDivs, int* yDivs, int padLeft, int padTop, | |
| int padRight, int padBottom) { | |
| const int kCap = 28; | |
| const int kMid = 8; | |
| const int kSize = 2*kCap + 3*kMid; | |
| auto surface(make_surface(root, kSize, padLeft, padTop, padRight, padBottom)); | |
| SkCanvas* canvas = surface->getCanvas(); | |
| canvas->translate((float) padLeft, (float) padTop); | |
| SkRect r = SkRect::MakeWH(SkIntToScalar(kSize), SkIntToScalar(kSize)); | |
| const SkScalar strokeWidth = SkIntToScalar(6); | |
| const SkScalar radius = SkIntToScalar(kCap) - strokeWidth/2; | |
| xDivs[0] = kCap + padLeft; | |
| yDivs[0] = kCap + padTop; | |
| xDivs[1] = kCap + kMid + padLeft; | |
| yDivs[1] = kCap + kMid + padTop; | |
| xDivs[2] = kCap + 2 * kMid + padLeft; | |
| yDivs[2] = kCap + 2 * kMid + padTop; | |
| xDivs[3] = kCap + 3 * kMid + padLeft; | |
| yDivs[3] = kCap + 3 * kMid + padTop; | |
| SkPaint paint; | |
| paint.setAntiAlias(true); | |
| paint.setColor(0xFFFFFF00); | |
| canvas->drawRoundRect(r, radius, radius, paint); | |
| r.setXYWH(SkIntToScalar(kCap), 0, SkIntToScalar(kMid), SkIntToScalar(kSize)); | |
| paint.setColor(0x8800FF00); | |
| canvas->drawRect(r, paint); | |
| r.setXYWH(SkIntToScalar(kCap + kMid), 0, SkIntToScalar(kMid), SkIntToScalar(kSize)); | |
| paint.setColor(0x880000FF); | |
| canvas->drawRect(r, paint); | |
| r.setXYWH(SkIntToScalar(kCap + 2*kMid), 0, SkIntToScalar(kMid), SkIntToScalar(kSize)); | |
| paint.setColor(0x88FF00FF); | |
| canvas->drawRect(r, paint); | |
| r.setXYWH(0, SkIntToScalar(kCap), SkIntToScalar(kSize), SkIntToScalar(kMid)); | |
| paint.setColor(0x8800FF00); | |
| canvas->drawRect(r, paint); | |
| r.setXYWH(0, SkIntToScalar(kCap + kMid), SkIntToScalar(kSize), SkIntToScalar(kMid)); | |
| paint.setColor(0x880000FF); | |
| canvas->drawRect(r, paint); | |
| r.setXYWH(0, SkIntToScalar(kCap + 2*kMid), SkIntToScalar(kSize), SkIntToScalar(kMid)); | |
| paint.setColor(0x88FF00FF); | |
| canvas->drawRect(r, paint); | |
| return surface->makeImageSnapshot(); | |
| } | |
| static void image_to_bitmap(GrDirectContext* dContext, const SkImage* image, SkBitmap* bm) { | |
| SkImageInfo info = SkImageInfo::MakeN32Premul(image->width(), image->height()); | |
| bm->allocPixels(info); | |
| image->readPixels(dContext, info, bm->getPixels(), bm->rowBytes(), 0, 0); | |
| } | |
| /** | |
| * This is similar to NinePatchStretchGM, but it also tests "ninepatch" images with more | |
| * than nine patches. | |
| */ | |
| class LatticeGM : public skiagm::GM { | |
| public: | |
| LatticeGM() {} | |
| protected: | |
| SkString onShortName() override { | |
| return SkString("lattice"); | |
| } | |
| SkISize onISize() override { | |
| return SkISize::Make(800, 800); | |
| } | |
| void onDrawHelper(GrDirectContext* dContext, SkCanvas* canvas, int padLeft, int padTop, | |
| int padRight, int padBottom) { | |
| canvas->save(); | |
| int xDivs[5]; | |
| int yDivs[5]; | |
| xDivs[0] = padLeft; | |
| yDivs[0] = padTop; | |
| SkBitmap bitmap; | |
| sk_sp<SkImage> image = make_image(canvas, xDivs + 1, yDivs + 1, padLeft, padTop, | |
| padRight, padBottom); | |
| image_to_bitmap(dContext, image.get(), &bitmap); | |
| const SkSize size[] = { | |
| { 50, 50, }, // shrink in both axes | |
| { 50, 200, }, // shrink in X | |
| { 200, 50, }, // shrink in Y | |
| { 200, 200, }, | |
| }; | |
| canvas->drawImage(image, 10, 10); | |
| SkScalar x = SkIntToScalar(100); | |
| SkScalar y = SkIntToScalar(100); | |
| SkCanvas::Lattice lattice; | |
| lattice.fXCount = 4; | |
| lattice.fXDivs = xDivs + 1; | |
| lattice.fYCount = 4; | |
| lattice.fYDivs = yDivs + 1; | |
| lattice.fRectTypes = nullptr; | |
| lattice.fColors = nullptr; | |
| SkIRect bounds = SkIRect::MakeLTRB(padLeft, padTop, | |
| image->width() - padRight, image->height() - padBottom); | |
| lattice.fBounds = (bounds == SkIRect::MakeWH(image->width(), image->height())) ? | |
| nullptr : &bounds; | |
| for (int iy = 0; iy < 2; ++iy) { | |
| for (int ix = 0; ix < 2; ++ix) { | |
| int i = ix * 2 + iy; | |
| SkRect r = SkRect::MakeXYWH(x + ix * 60, y + iy * 60, | |
| size[i].width(), size[i].height()); | |
| canvas->drawImageLattice(image.get(), lattice, r); | |
| } | |
| } | |
| // Provide hints about 3 solid color rects. These colors match | |
| // what was already in the bitmap. | |
| int fixedColorX[3] = {2, 4, 1}; | |
| int fixedColorY[3] = {1, 1, 2}; | |
| SkColor fixedColor[3] = {SK_ColorBLACK, SK_ColorBLACK, SK_ColorBLACK}; | |
| const SkImageInfo info = SkImageInfo::Make(1, 1, kBGRA_8888_SkColorType, | |
| kUnpremul_SkAlphaType); | |
| for (int rectNum = 0; rectNum < 3; rectNum++) { | |
| int srcX = xDivs[fixedColorX[rectNum]-1]; | |
| int srcY = yDivs[fixedColorY[rectNum]-1]; | |
| image->readPixels(dContext, info, &fixedColor[rectNum], 4, srcX, srcY); | |
| } | |
| // Include the degenerate first div. While normally the first patch is "scalable", | |
| // this will mean that the first non-degenerate patch is "fixed". | |
| lattice.fXCount = 5; | |
| lattice.fXDivs = xDivs; | |
| lattice.fYCount = 5; | |
| lattice.fYDivs = yDivs; | |
| // Let's skip a few rects. | |
| SkCanvas::Lattice::RectType flags[36]; | |
| sk_bzero(flags, 36 * sizeof(SkCanvas::Lattice::RectType)); | |
| flags[4] = SkCanvas::Lattice::kTransparent; | |
| flags[9] = SkCanvas::Lattice::kTransparent; | |
| flags[12] = SkCanvas::Lattice::kTransparent; | |
| flags[19] = SkCanvas::Lattice::kTransparent; | |
| for (int rectNum = 0; rectNum < 3; rectNum++) { | |
| flags[fixedColorY[rectNum]*6 + fixedColorX[rectNum]] | |
| = SkCanvas::Lattice::kFixedColor; | |
| } | |
| lattice.fRectTypes = flags; | |
| SkColor colors[36]; | |
| sk_bzero(colors, 36 * sizeof(SkColor)); | |
| for (int rectNum = 0; rectNum < 3; rectNum++) { | |
| colors[fixedColorY[rectNum]*6 + fixedColorX[rectNum]] | |
| = fixedColor[rectNum]; | |
| } | |
| lattice.fColors = colors; | |
| canvas->translate(400, 0); | |
| for (int iy = 0; iy < 2; ++iy) { | |
| for (int ix = 0; ix < 2; ++ix) { | |
| int i = ix * 2 + iy; | |
| SkRect r = SkRect::MakeXYWH(x + ix * 60, y + iy * 60, | |
| size[i].width(), size[i].height()); | |
| canvas->drawImageLattice(image.get(), lattice, r); | |
| } | |
| } | |
| canvas->restore(); | |
| } | |
| DrawResult onDraw(SkCanvas* canvas, SkString* errorMsg) override { | |
| auto rContext = canvas->recordingContext(); | |
| auto dContext = GrAsDirectContext(rContext); | |
| if (rContext && !dContext) { | |
| *errorMsg = "not supported in ddl"; | |
| return DrawResult::kSkip; | |
| } | |
| this->onDrawHelper(dContext, canvas, 0, 0, 0, 0); | |
| canvas->translate(0.0f, 400.0f); | |
| this->onDrawHelper(dContext, canvas, 3, 7, 4, 11); | |
| return DrawResult::kOk; | |
| } | |
| private: | |
| using INHERITED = skiagm::GM; | |
| }; | |
| DEF_GM( return new LatticeGM; ) | |
| // LatticeGM2 exercises code paths that draw fixed color and 1x1 rectangles. | |
| class LatticeGM2 : public skiagm::GM { | |
| public: | |
| LatticeGM2() {} | |
| SkString onShortName() override { | |
| return SkString("lattice2"); | |
| } | |
| SkISize onISize() override { | |
| return SkISize::Make(800, 800); | |
| } | |
| sk_sp<SkImage> makeImage(SkCanvas* root, int padLeft, int padTop, int padRight, int padBottom) { | |
| const int kSize = 80; | |
| auto surface(make_surface(root, kSize, padLeft, padTop, padRight, padBottom)); | |
| SkCanvas* canvas = surface->getCanvas(); | |
| SkPaint paint; | |
| paint.setAntiAlias(false); | |
| SkRect r; | |
| //first line | |
| r.setXYWH(0, 0, 4, 1); //4x1 green rect | |
| paint.setColor(0xFF00FF00); | |
| canvas->drawRect(r, paint); | |
| r.setXYWH(4, 0, 1, 1); //1x1 blue pixel -> draws as rectangle | |
| paint.setColor(0xFF0000FF); | |
| canvas->drawRect(r, paint); | |
| r.setXYWH(5, 0, kSize-5, 1); //the rest of the line is red | |
| paint.setColor(0xFFFF0000); | |
| canvas->drawRect(r, paint); | |
| //second line -> draws as fixed color rectangles | |
| r.setXYWH(0, 1, 4, 1); //4x1 red rect | |
| paint.setColor(0xFFFF0000); | |
| canvas->drawRect(r, paint); | |
| r.setXYWH(4, 1, 1, 1); //1x1 blue pixel with alpha | |
| paint.setColor(0x880000FF); | |
| canvas->drawRect(r, paint); | |
| r.setXYWH(5, 1, kSize-5, 1); //the rest of the line is green | |
| paint.setColor(0xFF00FF00); | |
| canvas->drawRect(r, paint); | |
| //third line - does not draw, because it is transparent | |
| r.setXYWH(0, 2, 4, kSize-2); //4x78 green rect | |
| paint.setColor(0xFF00FF00); | |
| canvas->drawRect(r, paint); | |
| r.setXYWH(4, 2, 1, kSize-2); //1x78 red pixel with alpha | |
| paint.setColor(0x88FF0000); | |
| canvas->drawRect(r, paint); | |
| r.setXYWH(5, 2, kSize-5, kSize-2); //the rest of the image is blue | |
| paint.setColor(0xFF0000FF); | |
| canvas->drawRect(r, paint); | |
| return surface->makeImageSnapshot(); | |
| } | |
| void onDrawHelper(SkCanvas* canvas, int padLeft, int padTop, int padRight, int padBottom, | |
| SkPaint& paint) { | |
| int xDivs[2] = {4, 5}; | |
| int yDivs[2] = {1, 2}; | |
| canvas->save(); | |
| sk_sp<SkImage> image = makeImage(canvas, padLeft, padTop, padRight, padBottom); | |
| canvas->drawImage(image, 10, 10); | |
| SkCanvas::Lattice lattice; | |
| lattice.fXCount = 2; | |
| lattice.fXDivs = xDivs; | |
| lattice.fYCount = 2; | |
| lattice.fYDivs = yDivs; | |
| lattice.fBounds = nullptr; | |
| SkCanvas::Lattice::RectType flags[9]; | |
| sk_bzero(flags, 9 * sizeof(SkCanvas::Lattice::RectType)); | |
| flags[3] = SkCanvas::Lattice::kFixedColor; | |
| flags[4] = SkCanvas::Lattice::kFixedColor; | |
| flags[5] = SkCanvas::Lattice::kFixedColor; | |
| flags[6] = SkCanvas::Lattice::kTransparent; | |
| flags[7] = SkCanvas::Lattice::kTransparent; | |
| flags[8] = SkCanvas::Lattice::kTransparent; | |
| lattice.fRectTypes = flags; | |
| SkColor colors[9] = {SK_ColorBLACK, SK_ColorBLACK, SK_ColorBLACK, | |
| 0xFFFF0000, 0x880000FF, 0xFF00FF00, | |
| SK_ColorBLACK, SK_ColorBLACK, SK_ColorBLACK}; | |
| lattice.fColors = colors; | |
| paint.setColor(0xFFFFFFFF); | |
| canvas->drawImageLattice(image.get(), lattice, | |
| SkRect::MakeXYWH(100, 100, 200, 200), | |
| SkFilterMode::kNearest, &paint); | |
| //draw the same content with alpha | |
| canvas->translate(400, 0); | |
| paint.setColor(0x80000FFF); | |
| canvas->drawImageLattice(image.get(), lattice, | |
| SkRect::MakeXYWH(100, 100, 200, 200), | |
| SkFilterMode::kNearest, &paint); | |
| canvas->restore(); | |
| } | |
| void onDraw(SkCanvas* canvas) override { | |
| //draw a rectangle in the background with transparent pixels | |
| SkPaint paint; | |
| paint.setColor(0x7F123456); | |
| paint.setBlendMode(SkBlendMode::kSrc); | |
| canvas->drawRect( SkRect::MakeXYWH(300, 0, 300, 800), paint); | |
| //draw image lattice with kSrcOver blending | |
| paint.setBlendMode(SkBlendMode::kSrcOver); | |
| this->onDrawHelper(canvas, 0, 0, 0, 0, paint); | |
| //draw image lattice with kSrcATop blending | |
| canvas->translate(0.0f, 400.0f); | |
| paint.setBlendMode(SkBlendMode::kSrcATop); | |
| this->onDrawHelper(canvas, 0, 0, 0, 0, paint); | |
| } | |
| private: | |
| using INHERITED = skiagm::GM; | |
| }; | |
| DEF_GM( return new LatticeGM2; ) | |
| // Code paths that incorporate the paint color when drawing the lattice (using an alpha image) | |
| DEF_SIMPLE_GM_BG(lattice_alpha, canvas, 120, 120, SK_ColorWHITE) { | |
| auto surface = ToolUtils::makeSurface(canvas, SkImageInfo::MakeA8(100, 100)); | |
| surface->getCanvas()->clear(0); | |
| surface->getCanvas()->drawCircle(50, 50, 50, SkPaint()); | |
| auto image = surface->makeImageSnapshot(); | |
| int divs[] = { 20, 40, 60, 80 }; | |
| SkCanvas::Lattice lattice; | |
| lattice.fXCount = 4; | |
| lattice.fXDivs = divs; | |
| lattice.fYCount = 4; | |
| lattice.fYDivs = divs; | |
| lattice.fRectTypes = nullptr; | |
| lattice.fColors = nullptr; | |
| lattice.fBounds = nullptr; | |
| SkPaint paint; | |
| paint.setColor(SK_ColorMAGENTA); | |
| canvas->drawImageLattice(image.get(), lattice, SkRect::MakeWH(120, 120), | |
| SkFilterMode::kNearest, &paint); | |
| } |