savelayer.cpp File Reference

#include "gm/gm.h"
#include "include/core/SkBlendMode.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkColor.h"
#include "include/core/SkColorSpace.h"
#include "include/core/SkFont.h"
#include "include/core/SkImage.h"
#include "include/core/SkImageFilter.h"
#include "include/core/SkImageInfo.h"
#include "include/core/SkMaskFilter.h"
#include "include/core/SkMatrix.h"
#include "include/core/SkPaint.h"
#include "include/core/SkPicture.h"
#include "include/core/SkPictureRecorder.h"
#include "include/core/SkPoint.h"
#include "include/core/SkRSXform.h"
#include "include/core/SkRect.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkScalar.h"
#include "include/core/SkShader.h"
#include "include/core/SkSize.h"
#include "include/core/SkString.h"
#include "include/core/SkSurface.h"
#include "include/core/SkTextBlob.h"
#include "include/core/SkTileMode.h"
#include "include/core/SkTypeface.h"
#include "include/core/SkTypes.h"
#include "include/core/SkVertices.h"
#include "include/effects/SkGradientShader.h"
#include "include/effects/SkImageFilters.h"
#include "include/effects/SkShaderMaskFilter.h"
#include "src/base/SkRandom.h"
#include "src/core/SkCanvasPriv.h"
#include "tools/DecodeUtils.h"
#include "tools/Resources.h"
#include "tools/ToolUtils.h"
#include "tools/fonts/FontToolUtils.h"
#include <string.h>
#include <initializer_list>

Go to the source code of this file.

Functions
	DEF_SIMPLE_GM (savelayer_initfromprev, canvas, 256, 256)
static void	draw_cell (SkCanvas *canvas, sk_sp< SkTextBlob > blob, SkColor c, SkScalar w, SkScalar h, bool useDrawBehind)
static void	draw_list (SkCanvas *canvas, sk_sp< SkTextBlob > blob, bool useDrawBehind)
	DEF_SIMPLE_GM (save_behind, canvas, 830, 670)
	DEF_SIMPLE_GM (savelayer_f16, canvas, 900, 300)
static void	draw_atlas (SkCanvas *canvas, SkImage *image)
static void	draw_vertices (SkCanvas *canvas, SkImage *image)
static void	draw_points (SkCanvas *canvas, SkImage *image)
static void	draw_image_set (SkCanvas *canvas, SkImage *image)
	DEF_SIMPLE_GM (skbug_14554, canvas, 310, 630)

Function Documentation

DEF_SIMPLE_GM() [1/4]

DEF_SIMPLE_GM	(	save_behind	,
		canvas	,
		830	,
		670
	)

Definition at line 128 of file savelayer.cpp.

                                             {
    SkFont font = ToolUtils::DefaultPortableFont();
    font.setSize(30);
 
    const char text[] = "This is a very long line of text";
    auto blob = SkTextBlob::MakeFromText(text, strlen(text), font);
 
    for (bool useDrawBehind : {false, true}) {
        canvas->save();
 
        draw_list(canvas, blob, useDrawBehind);
        canvas->translate(0, 350);
        canvas->saveLayer({0, 0, 400, 320}, nullptr);
        draw_list(canvas, blob, useDrawBehind);
        canvas->restore();
 
        canvas->restore();
        canvas->translate(430, 0);
    }
}

DEF_SIMPLE_GM() [2/4]

DEF_SIMPLE_GM	(	savelayer_f16	,
		canvas	,
		900	,
		300
	)

Definition at line 151 of file savelayer.cpp.

                                               {
    int n = 15;
    SkRect r{0, 0, 300, 300};
    SkPaint paint;
 
    const SkColor colors[] = { SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorRED };
    paint.setShader(SkGradientShader::MakeSweep(r.centerX(), r.centerY(),
                                                colors, nullptr, std::size(colors)));
 
    canvas->drawOval(r, paint);
 
    paint.setAlphaf(1.0f/n);
    paint.setBlendMode(SkBlendMode::kPlus);
 
    for (auto flags : {0, (int)SkCanvas::kF16ColorType}) {
        canvas->translate(r.width(), 0);
 
        SkCanvas::SaveLayerRec rec;
        rec.fSaveLayerFlags = flags;
        canvas->saveLayer(rec);
        for (int i = 0; i < n; ++i) {
            canvas->drawOval(r, paint);
        }
        canvas->restore();
    }
}

DEF_SIMPLE_GM() [3/4]

DEF_SIMPLE_GM	(	savelayer_initfromprev	,
		canvas	,
		256	,
		256
	)

Definition at line 53 of file savelayer.cpp.

                                                        {
    canvas->drawImage(ToolUtils::GetResourceAsImage("images/mandrill_256.png"), 0, 0);
 
    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();
};

DEF_SIMPLE_GM() [4/4]

DEF_SIMPLE_GM	(	skbug_14554	,
		canvas	,
		310	,
		630
	)

Definition at line 235 of file savelayer.cpp.

                                             {
    sk_sp<SkImage> image = ToolUtils::GetResourceAsImage("images/mandrill_128.png");
    SkPictureRecorder rec;
 
    using DrawProc = void(*)(SkCanvas*, SkImage*);
 
    for (DrawProc proc : {draw_atlas, draw_vertices, draw_points, draw_image_set}) {
        canvas->save();
        for (bool injectExtraOp : {false, true}) {
            auto c = rec.beginRecording(SkRect::MakeWH(150, 150));
            c->saveLayerAlphaf(nullptr, 0.6f);
            proc(c, image.get());
            // For the second draw of each test-case, we inject an extra (useless) operation, which
            // inhibits the optimization and produces the correct result.
            if (injectExtraOp) {
                c->translate(1, 0);
            }
            c->restore();
 
            auto pic = rec.finishRecordingAsPicture();
 
            canvas->drawPicture(pic);
            canvas->translate(160, 0);
        }
        canvas->restore();
        canvas->translate(0, 160);
    }
}

draw_atlas()

static void draw_atlas ( SkCanvas *  canvas, SkImage *  image  )

static

Definition at line 178 of file savelayer.cpp.

                                                         {
    SkRSXform xforms[] = {{1, 0, 0, 0}, {1, 0, 50, 50}};
    SkRect tex[] = {{0, 0, 100, 100}, {0, 0, 100, 100}};
    SkColor colors[] = {0xffffffff, 0xffffffff};
    SkPaint paint;
 
    canvas->drawAtlas(image,
                      xforms,
                      tex,
                      colors,
                      2,
                      SkBlendMode::kSrcIn,
                      SkFilterMode::kNearest,
                      nullptr,
                      &paint);
}

draw_cell()

static void draw_cell ( SkCanvas *  canvas, sk_sp< SkTextBlob >  blob, SkColor  c, SkScalar  w, SkScalar  h, bool  useDrawBehind  )

static

Definition at line 67 of file savelayer.cpp.

                                          {
    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, SkTileMode::kClamp);
    p.setShader(sh);
    p.setBlendMode(SkBlendMode::kDstIn);
 
    if (useDrawBehind) {
        SkCanvasPriv::DrawBehind(canvas, p);
    } else {
        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.setAlphaf(0.25f);
}

draw_image_set()

static void draw_image_set ( SkCanvas *  canvas, SkImage *  image  )

static

Definition at line 216 of file savelayer.cpp.

                                                             {
    SkRect r = SkRect::MakeWH(100, 100);
    SkCanvas::ImageSetEntry entries[] = {
            SkCanvas::ImageSetEntry(sk_ref_sp(image), r, r, 1.0f, SkCanvas::kNone_QuadAAFlags),
            SkCanvas::ImageSetEntry(
                    sk_ref_sp(image), r, r.makeOffset(50, 50), 1.0f, SkCanvas::kNone_QuadAAFlags),
    };
 
    SkPaint paint;
    canvas->experimental_DrawEdgeAAImageSet(
            entries, 2, nullptr, nullptr, SkFilterMode::kNearest, &paint);
}

draw_list()

static void draw_list ( SkCanvas *  canvas, sk_sp< SkTextBlob >  blob, bool  useDrawBehind  )

static

Definition at line 114 of file savelayer.cpp.

                                                                                    {
    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, useDrawBehind);
        canvas->translate(0, h);
    }
}

draw_points()

static void draw_points ( SkCanvas *  canvas, SkImage *  image  )

static

Definition at line 206 of file savelayer.cpp.

                                                          {
    SkPoint pts[] = {{50, 50}, {75, 75}};
    SkPaint paint;
    paint.setShader(image->makeShader(SkFilterMode::kNearest));
    paint.setStrokeWidth(100);
    paint.setStrokeCap(SkPaint::kSquare_Cap);
 
    canvas->drawPoints(SkCanvas::kPoints_PointMode, 2, pts, paint);
}

draw_vertices()

static void draw_vertices ( SkCanvas *  canvas, SkImage *  image  )

static

Definition at line 195 of file savelayer.cpp.

                                                            {
    SkPoint pts[] = {{0, 0}, {0, 100}, {100, 100}, {100, 0}, {100, 100}, {0, 100}};
    sk_sp<SkVertices> verts =
            SkVertices::MakeCopy(SkVertices::kTriangles_VertexMode, 6, pts, nullptr, nullptr);
 
    SkPaint paint;
    paint.setShader(image->makeShader(SkFilterMode::kNearest));
 
    canvas->drawVertices(verts, SkBlendMode::kSrc, paint);
}