surface.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/SkImageInfo.h"
#include "include/core/SkPaint.h"
#include "include/core/SkPoint.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/SkSurfaceProps.h"
#include "include/core/SkTileMode.h"
#include "include/core/SkTypeface.h"
#include "include/core/SkTypes.h"
#include "include/effects/SkGradientShader.h"
#include "include/gpu/GrDirectContext.h"
#include "include/gpu/GrRecordingContext.h"
#include "include/gpu/ganesh/SkSurfaceGanesh.h"
#include "include/utils/SkTextUtils.h"
#include "tools/ToolUtils.h"
#include "tools/fonts/FontToolUtils.h"
#include "tools/gpu/BackendSurfaceFactory.h"

Go to the source code of this file.

Classes
class	SurfacePropsGM
class	NewSurfaceGM

Macros
#define	W   800
#define	H   100
#define	DEF_BASIC_SURFACE_TEST(name, canvas, main, W, H)
#define	DEF_BACKEND_SURFACE_TEST(name, canvas, main, type, W, H)
#define	DEF_BET_SURFACE_TEST(name, canvas, main, W, H)
#define	DEF_BERT_SURFACE_TEST(name, canvas, main, W, H)
#define	DEF_SURFACE_TESTS(name, canvas, W, H)

Typedefs
using	MakeSurfaceFn = std::function< sk_sp< SkSurface >(const SkImageInfo &)>

Functions
static sk_sp< SkShader >	make_shader ()
static sk_sp< SkSurface >	make_surface (GrRecordingContext *ctx, const SkImageInfo &info, SkPixelGeometry geo, SkScalar contrast, SkScalar gamma)
static void	test_draw (SkCanvas *canvas, const char label[])
static sk_sp< SkSurface >	make_surface (const SkImageInfo &ii, SkCanvas *canvas, SurfaceType type)
	DEF_SURFACE_TESTS (copy_on_write_retain, canvas, 256, 256)
	DEF_SURFACE_TESTS (copy_on_write_retain2, canvas, 256, 256)
	DEF_SURFACE_TESTS (simple_snap_image, canvas, 256, 256)
	DEF_SURFACE_TESTS (simple_snap_image2, canvas, 256, 256)
	DEF_SIMPLE_GM (snap_with_mips, canvas, 80, 75)
	DEF_SURFACE_TESTS (copy_on_write_savelayer, canvas, 256, 256)
	DEF_SURFACE_TESTS (surface_underdraw, canvas, 256, 256)

Macro Definition Documentation

DEF_BACKEND_SURFACE_TEST

#define DEF_BACKEND_SURFACE_TEST	(		name,
			canvas,
			main,
			type,
			W,
			H
	)

Value:

    DEF_SIMPLE_GM_CAN_FAIL(name, canvas, err_msg, W, H) {                                       \
        GrDirectContext* direct = GrAsDirectContext(canvas->recordingContext());                \
        if (!direct || direct->abandoned()) {                                                   \
            *err_msg = "Requires non-abandoned GrDirectContext";                                \
            return skiagm::DrawResult::kSkip;                                                   \
        }                                                                                       \
        auto make = [canvas](const SkImageInfo& ii) { return make_surface(ii, canvas, type); }; \
        main(canvas, MakeSurfaceFn(make));                                                      \
        return skiagm::DrawResult::kOk;                                                         \
    }

Definition at line 232 of file surface.cpp.

                                                        {                                       \
        GrDirectContext* direct = GrAsDirectContext(canvas->recordingContext());                \
        if (!direct || direct->abandoned()) {                                                   \
            *err_msg = "Requires non-abandoned GrDirectContext";                                \
            return skiagm::DrawResult::kSkip;                                                   \
        }                                                                                       \
        auto make = [canvas](const SkImageInfo& ii) { return make_surface(ii, canvas, type); }; \
        main(canvas, MakeSurfaceFn(make));                                                      \
        return skiagm::DrawResult::kOk;                                                         \
    }

DEF_BASIC_SURFACE_TEST

#define DEF_BASIC_SURFACE_TEST	(		name,
			canvas,
			main,
			W,
			H
	)

Value:

    DEF_SIMPLE_GM(name, canvas, W, H) {                             \
        auto make = [canvas](const SkImageInfo& ii) {               \
            return make_surface(ii, canvas, SurfaceType::kManaged); \
        };                                                          \
        main(canvas, MakeSurfaceFn(make));                          \
    }

Definition at line 224 of file surface.cpp.

                                      {                             \
        auto make = [canvas](const SkImageInfo& ii) {               \
            return make_surface(ii, canvas, SurfaceType::kManaged); \
        };                                                          \
        main(canvas, MakeSurfaceFn(make));                          \
    }

DEF_BERT_SURFACE_TEST

#define DEF_BERT_SURFACE_TEST	(		name,
			canvas,
			main,
			W,
			H
	)

Value:

    DEF_BACKEND_SURFACE_TEST(SK_MACRO_CONCAT(name, _bert), canvas, main, \
                             SurfaceType::kBackendRenderTarget, W, H)

Definition at line 248 of file surface.cpp.

DEF_BET_SURFACE_TEST

#define DEF_BET_SURFACE_TEST	(		name,
			canvas,
			main,
			W,
			H
	)

Value:

    DEF_BACKEND_SURFACE_TEST(SK_MACRO_CONCAT(name, _bet), canvas, main, \
                             SurfaceType::kBackendTexture, W, H)

Definition at line 244 of file surface.cpp.

DEF_SURFACE_TESTS

#define DEF_SURFACE_TESTS	(		name,
			canvas,
			W,
			H
	)

Value:

    static void SK_MACRO_CONCAT(name, _main)(SkCanvas*, const MakeSurfaceFn&); \
    DEF_BASIC_SURFACE_TEST(name, canvas, SK_MACRO_CONCAT(name, _main), W, H)   \
    DEF_BET_SURFACE_TEST  (name, canvas, SK_MACRO_CONCAT(name, _main), W, H)   \
    DEF_BERT_SURFACE_TEST (name, canvas, SK_MACRO_CONCAT(name, _main), W, H)   \
    static void SK_MACRO_CONCAT(name, _main)(SkCanvas * canvas, const MakeSurfaceFn& make)

Definition at line 254 of file surface.cpp.

H

#define H   100

Definition at line 39 of file surface.cpp.

W

#define W   800

Definition at line 38 of file surface.cpp.

Typedef Documentation

MakeSurfaceFn

using MakeSurfaceFn = std::function<sk_sp<SkSurface>(const SkImageInfo&)>

Definition at line 222 of file surface.cpp.

Function Documentation

DEF_SIMPLE_GM()

DEF_SIMPLE_GM	(	snap_with_mips	,
		canvas	,
		80	,
		75
	)

Definition at line 321 of file surface.cpp.

                                              {
    auto ct = canvas->imageInfo().colorType() == kUnknown_SkColorType
                      ? kRGBA_8888_SkColorType
                      : canvas->imageInfo().colorType();
    auto ii = SkImageInfo::Make({32, 32},
                                ct,
                                kPremul_SkAlphaType,
                                canvas->imageInfo().refColorSpace());
    auto surface = SkSurfaces::Raster(ii);
 
    auto nextImage = [&](SkColor color) {
        surface->getCanvas()->clear(color);
        SkPaint paint;
        paint.setColor(~color | 0xFF000000);
        surface->getCanvas()->drawRect(SkRect::MakeLTRB(surface->width() *2/5.f,
                                                        surface->height()*2/5.f,
                                                        surface->width() *3/5.f,
                                                        surface->height()*3/5.f),
                                    paint);
        return surface->makeImageSnapshot()->withDefaultMipmaps();
    };
 
    static constexpr int kPad = 8;
    static const SkSamplingOptions kSampling{SkFilterMode::kLinear, SkMipmapMode::kLinear};
 
    canvas->save();
    for (int y = 0; y < 3; ++y) {
        canvas->save();
        SkColor kColors[] = {0xFFF0F0F0, SK_ColorBLUE};
        for (int x = 0; x < 2; ++x) {
            auto image = nextImage(kColors[x]);
            canvas->drawImage(image, 0, 0, kSampling);
            canvas->translate(ii.width() + kPad, 0);
        }
        canvas->restore();
        canvas->translate(0, ii.width() + kPad);
        canvas->scale(.4f, .4f);
    }
    canvas->restore();
}

DEF_SURFACE_TESTS() [1/6]

DEF_SURFACE_TESTS	(	copy_on_write_retain	,
		canvas	,
		256	,
		256
	)

Definition at line 261 of file surface.cpp.

                                                          {
    const SkImageInfo info = SkImageInfo::MakeN32Premul(256, 256);
    sk_sp<SkSurface> surf = make(info);
 
    surf->getCanvas()->clear(SK_ColorRED);
    // its important that image survives longer than the next draw, so the surface will see
    // an outstanding image, and have to decide if it should retain or discard those pixels
    sk_sp<SkImage> image = surf->makeImageSnapshot();
 
    // normally a clear+opaque should trigger the discard optimization, but since we have a clip
    // it should not (we need the previous red pixels).
    surf->getCanvas()->clipRect(SkRect::MakeWH(128, 256));
    surf->getCanvas()->clear(SK_ColorBLUE);
 
    // expect to see two rects: blue | red
    canvas->drawImage(surf->makeImageSnapshot(), 0, 0);
}

DEF_SURFACE_TESTS() [2/6]

DEF_SURFACE_TESTS	(	copy_on_write_retain2	,
		canvas	,
		256	,
		256
	)

Definition at line 280 of file surface.cpp.

                                                           {
    const SkImageInfo info = SkImageInfo::MakeN32Premul(256, 256);
    sk_sp<SkSurface> surf = make(info);
 
    surf->getCanvas()->clear(SK_ColorBLUE);
    // its important that image survives longer than the next draw, so the surface will see
    // an outstanding image, and have to decide if it should retain or discard those pixels
    sk_sp<SkImage> image = surf->makeImageSnapshot();
 
    surf->getCanvas()->clear(SK_ColorRED);
    // normally a clear+opaque should trigger the discard optimization, but since we have a clip
    // it should not (we need the previous red pixels).
    surf->getCanvas()->clipRect(SkRect::MakeWH(128, 256));
    surf->getCanvas()->drawImage(image, 0, 0);
 
    // expect to see two rects: blue | red
    canvas->drawImage(surf->makeImageSnapshot(), 0, 0);
}

DEF_SURFACE_TESTS() [3/6]

DEF_SURFACE_TESTS	(	copy_on_write_savelayer	,
		canvas	,
		256	,
		256
	)

Definition at line 362 of file surface.cpp.

                                                             {
    const SkImageInfo info = SkImageInfo::MakeN32Premul(256, 256);
    sk_sp<SkSurface> surf = make(info);
    surf->getCanvas()->clear(SK_ColorRED);
    // its important that image survives longer than the next draw, so the surface will see
    // an outstanding image, and have to decide if it should retain or discard those pixels
    sk_sp<SkImage> image = surf->makeImageSnapshot();
 
    // now draw into a full-screen layer. This should (a) trigger a copy-on-write, but it should
    // not trigger discard, even tho its alpha (SK_ColorBLUE) is opaque, since it is in a layer
    // with a non-opaque paint.
    SkPaint paint;
    paint.setAlphaf(0.25f);
    surf->getCanvas()->saveLayer({0, 0, 256, 256}, &paint);
    surf->getCanvas()->clear(SK_ColorBLUE);
    surf->getCanvas()->restore();
 
    // expect to see two rects: blue blended on red
    canvas->drawImage(surf->makeImageSnapshot(), 0, 0);
}

DEF_SURFACE_TESTS() [4/6]

DEF_SURFACE_TESTS	(	simple_snap_image	,
		canvas	,
		256	,
		256
	)

Definition at line 299 of file surface.cpp.

                                                       {
    const SkImageInfo info = SkImageInfo::MakeN32Premul(256, 256);
    sk_sp<SkSurface> surf = make(info);
 
    surf->getCanvas()->clear(SK_ColorRED);
    sk_sp<SkImage> image = surf->makeImageSnapshot();
    // expect to see just red
    canvas->drawImage(std::move(image), 0, 0);
}

DEF_SURFACE_TESTS() [5/6]

DEF_SURFACE_TESTS	(	simple_snap_image2	,
		canvas	,
		256	,
		256
	)

Definition at line 310 of file surface.cpp.

                                                        {
    const SkImageInfo info = SkImageInfo::MakeN32Premul(256, 256);
    sk_sp<SkSurface> surf = make(info);
 
    surf->getCanvas()->clear(SK_ColorRED);
    sk_sp<SkImage> image = surf->makeImageSnapshot();
    surf.reset();
    // expect to see just red
    canvas->drawImage(std::move(image), 0, 0);
}

DEF_SURFACE_TESTS() [6/6]

DEF_SURFACE_TESTS	(	surface_underdraw	,
		canvas	,
		256	,
		256
	)

Definition at line 383 of file surface.cpp.

                                                       {
    SkImageInfo info = SkImageInfo::MakeN32Premul(256, 256, nullptr);
    auto surf = make(info);
 
    const SkIRect subset = SkIRect::MakeLTRB(180, 0, 256, 256);
 
    // noisy background
    {
        SkPoint pts[] = {{0, 0}, {40, 50}};
        SkColor colors[] = {SK_ColorRED, SK_ColorBLUE};
        auto sh = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kRepeat);
        SkPaint paint;
        paint.setShader(sh);
        surf->getCanvas()->drawPaint(paint);
    }
 
    // save away the right-hand strip, then clear it
    sk_sp<SkImage> saveImg = surf->makeImageSnapshot(subset);
    {
        SkPaint paint;
        paint.setBlendMode(SkBlendMode::kClear);
        surf->getCanvas()->drawRect(SkRect::Make(subset), paint);
    }
 
    // draw the "foreground"
    {
        SkPaint paint;
        paint.setColor(SK_ColorGREEN);
        SkRect r = { 0, 10, 256, 35 };
        while (r.fBottom < 256) {
            surf->getCanvas()->drawRect(r, paint);
            r.offset(0, r.height() * 2);
        }
    }
 
    // apply the "fade"
    {
        SkPoint pts[] = {{SkIntToScalar(subset.left()), 0}, {SkIntToScalar(subset.right()), 0}};
        SkColor colors[] = {0xFF000000, 0};
        auto sh = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kClamp);
        SkPaint paint;
        paint.setShader(sh);
        paint.setBlendMode(SkBlendMode::kDstIn);
        surf->getCanvas()->drawRect(SkRect::Make(subset), paint);
    }
 
    // restore the original strip, drawing it "under" the current foreground
    {
        SkPaint paint;
        paint.setBlendMode(SkBlendMode::kDstOver);
        surf->getCanvas()->drawImage(saveImg,
                                     SkIntToScalar(subset.left()), SkIntToScalar(subset.top()),
                                     SkSamplingOptions(), &paint);
    }
 
    // show it on screen
   surf->draw(canvas, 0, 0);
}

make_shader()

static sk_sp< SkShader > make_shader ( )

static

Definition at line 41 of file surface.cpp.

                                     {
    int a = 0x99;
    int b = 0xBB;
    SkPoint pts[] = { { 0, 0 }, { W, H } };
    SkColor colors[] = { SkColorSetRGB(a, a, a), SkColorSetRGB(b, b, b) };
    return SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kClamp);
}

make_surface() [1/2]

static sk_sp< SkSurface > make_surface ( const SkImageInfo &  ii, SkCanvas *  canvas, SurfaceType  type  )

static

Definition at line 203 of file surface.cpp.

                                                                                                {
    GrDirectContext* direct = GrAsDirectContext(canvas->recordingContext());
    switch (type) {
        case kManaged:
            return ToolUtils::makeSurface(canvas, ii);
        case kBackendTexture:
            if (!direct) {
                return nullptr;
            }
            return sk_gpu_test::MakeBackendTextureSurface(direct, ii, kTopLeft_GrSurfaceOrigin, 1);
        case kBackendRenderTarget:
            return sk_gpu_test::MakeBackendRenderTargetSurface(direct,
                                                               ii,
                                                               kTopLeft_GrSurfaceOrigin,
                                                               1);
    }
    return nullptr;
}

make_surface() [2/2]

static sk_sp< SkSurface > make_surface ( GrRecordingContext *  ctx, const SkImageInfo &  info, SkPixelGeometry  geo, SkScalar  contrast, SkScalar  gamma  )

static

Definition at line 49 of file surface.cpp.

                                                     {
    SkSurfaceProps props(0, geo, contrast, gamma);
    if (ctx) {
        return SkSurfaces::RenderTarget(ctx, skgpu::Budgeted::kNo, info, 0, &props);
    } else {
        return SkSurfaces::Raster(info, &props);
    }
}

test_draw()

static void test_draw ( SkCanvas *  canvas, const char  label[]  )

static

Definition at line 62 of file surface.cpp.

                                                            {
    SkPaint paint;
 
    paint.setAntiAlias(true);
    paint.setDither(true);
 
    paint.setShader(make_shader());
    canvas->drawRect(SkRect::MakeWH(W, H), paint);
    paint.setShader(nullptr);
 
    paint.setColor(SK_ColorWHITE);
    SkFont font(ToolUtils::DefaultPortableTypeface(), 32);
    font.setEdging(SkFont::Edging::kSubpixelAntiAlias);
    SkTextUtils::DrawString(canvas, label, W / 2, H * 3 / 4, font, paint,
                            SkTextUtils::kCenter_Align);
}