bleed.cpp File Reference

#include "gm/gm.h"
#include "include/core/SkBitmap.h"
#include "include/core/SkBlurTypes.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkColor.h"
#include "include/core/SkImage.h"
#include "include/core/SkImageInfo.h"
#include "include/core/SkMaskFilter.h"
#include "include/core/SkMatrix.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/SkTileMode.h"
#include "include/core/SkTiledImageUtils.h"
#include "include/core/SkTypes.h"
#include "include/gpu/GrContextOptions.h"
#include "include/private/base/SkTDArray.h"
#include "src/core/SkBlurMask.h"
#include "tools/ToolUtils.h"

Go to the source code of this file.

Classes
class	SrcRectConstraintGM

Functions
std::tuple< sk_sp< SkImage >, SkRect >	make_ringed_image (SkCanvas *canvas, int width, int height)
	DEF_GM (return new SrcRectConstraintGM("strict_constraint_no_red_allowed", SkCanvas::kStrict_SrcRectConstraint, false);)
	DEF_GM (return new SrcRectConstraintGM("strict_constraint_no_red_allowed_manual", SkCanvas::kStrict_SrcRectConstraint, true);)
	DEF_GM (return new SrcRectConstraintGM("strict_constraint_batch_no_red_allowed", SkCanvas::kStrict_SrcRectConstraint, false);)
	DEF_GM (return new SrcRectConstraintGM("strict_constraint_batch_no_red_allowed_manual", SkCanvas::kStrict_SrcRectConstraint, true);)
	DEF_GM (return new SrcRectConstraintGM("fast_constraint_red_is_allowed", SkCanvas::kFast_SrcRectConstraint, false);)
	DEF_GM (return new SrcRectConstraintGM("fast_constraint_red_is_allowed_manual", SkCanvas::kFast_SrcRectConstraint, true);)
static sk_sp< SkImage >	make_image (SkCanvas *canvas, SkRect *srcR)
	DEF_SIMPLE_GM (bleed_downscale, canvas, 360, 240)

Function Documentation

DEF_GM() [1/6]

DEF_GM

(

return new SrcRectConstraintGM("fast_constraint_red_is_allowed", SkCanvas::kFast_SrcRectConstraint, false);

)

DEF_GM() [2/6]

DEF_GM

(

return new SrcRectConstraintGM("fast_constraint_red_is_allowed_manual", SkCanvas::kFast_SrcRectConstraint, true);

)

DEF_GM() [3/6]

DEF_GM

(

return new SrcRectConstraintGM("strict_constraint_batch_no_red_allowed", SkCanvas::kStrict_SrcRectConstraint, false);

)

DEF_GM() [4/6]

DEF_GM

(

return new SrcRectConstraintGM("strict_constraint_batch_no_red_allowed_manual", SkCanvas::kStrict_SrcRectConstraint, true);

)

DEF_GM() [5/6]

DEF_GM

(

return new SrcRectConstraintGM("strict_constraint_no_red_allowed", SkCanvas::kStrict_SrcRectConstraint, false);

)

DEF_GM() [6/6]

DEF_GM

(

return new SrcRectConstraintGM("strict_constraint_no_red_allowed_manual", SkCanvas::kStrict_SrcRectConstraint, true);

)

DEF_SIMPLE_GM()

DEF_SIMPLE_GM	(	bleed_downscale	,
		canvas	,
		360	,
		240
	)

Definition at line 385 of file bleed.cpp.

                                                 {
    SkRect src;
    sk_sp<SkImage> img = make_image(canvas, &src);
    SkPaint paint;
 
    canvas->translate(10, 10);
 
    const SkCanvas::SrcRectConstraint constraints[] = {
        SkCanvas::kStrict_SrcRectConstraint, SkCanvas::kFast_SrcRectConstraint
    };
    const SkSamplingOptions samplings[] = {
        SkSamplingOptions(SkFilterMode::kNearest),
        SkSamplingOptions(SkFilterMode::kLinear),
        SkSamplingOptions(SkFilterMode::kLinear, SkMipmapMode::kLinear),
    };
    for (auto constraint : constraints) {
        canvas->save();
        for (auto sampling : samplings) {
            auto surf = ToolUtils::makeSurface(canvas, SkImageInfo::MakeN32Premul(1, 1));
            surf->getCanvas()->drawImageRect(img, src, SkRect::MakeWH(1, 1), sampling,
                                             nullptr, constraint);
            // now blow up the 1 pixel result
            canvas->drawImageRect(surf->makeImageSnapshot(), SkRect::MakeWH(100, 100),
                                  SkSamplingOptions());
            canvas->translate(120, 0);
        }
        canvas->restore();
        canvas->translate(0, 120);
    }
}

make_image()

static sk_sp< SkImage > make_image ( SkCanvas *  canvas, SkRect *  srcR  )

static

Definition at line 365 of file bleed.cpp.

                                                                 {
    // Intentially making the size a power of 2 to avoid the noise from how different GPUs will
    // produce different mipmap filtering when we have an odd sized texture.
    const int N = 10 + 2 + 8 + 2 + 10;
    SkImageInfo info = SkImageInfo::MakeN32Premul(N, N);
    auto        surface = ToolUtils::makeSurface(canvas, info);
    SkCanvas* c = surface->getCanvas();
    SkRect r = SkRect::MakeIWH(info.width(), info.height());
    SkPaint paint;
 
    paint.setColor(SK_ColorRED);
    c->drawRect(r, paint);
    r.inset(10, 10);
    paint.setColor(SK_ColorBLUE);
    c->drawRect(r, paint);
 
    *srcR = r.makeInset(2, 2);
    return surface->makeImageSnapshot();
}

make_ringed_image()

std::tuple< sk_sp< SkImage >, SkRect > make_ringed_image	(	SkCanvas *	canvas,
		int	width,
		int	height
	)

Creates an image with two one-pixel wide borders around a checkerboard. The checkerboard is 2x2 checks where each check has as many pixels as is necessary to fill the interior. It returns the image and a src rect that bounds the checkerboard portion.

Definition at line 42 of file bleed.cpp.

                                                                                            {
 
    // These are kRGBA_8888_SkColorType values.
    static constexpr uint32_t kOuterRingColor = 0xFFFF0000,
                              kInnerRingColor = 0xFF0000FF,
                              kCheckColor1    = 0xFF000000,
                              kCheckColor2    = 0xFFFFFFFF;
 
    SkASSERT(0 == width % 2 && 0 == height % 2);
    SkASSERT(width >= 6 && height >= 6);
 
    SkImageInfo info = SkImageInfo::Make(width, height, kRGBA_8888_SkColorType,
                                         kPremul_SkAlphaType);
    size_t rowBytes = SkAlign4(info.minRowBytes());
    SkBitmap bitmap;
    bitmap.allocPixels(info, rowBytes);
 
    uint32_t* scanline = bitmap.getAddr32(0, 0);
    for (int x = 0; x < width; ++x) {
        scanline[x] = kOuterRingColor;
    }
    scanline = bitmap.getAddr32(0, 1);
    scanline[0] = kOuterRingColor;
    for (int x = 1; x < width - 1; ++x) {
        scanline[x] = kInnerRingColor;
    }
    scanline[width - 1] = kOuterRingColor;
 
    for (int y = 2; y < height / 2; ++y) {
        scanline = bitmap.getAddr32(0, y);
        scanline[0] = kOuterRingColor;
        scanline[1] = kInnerRingColor;
        for (int x = 2; x < width / 2; ++x) {
            scanline[x] = kCheckColor1;
        }
        for (int x = width / 2; x < width - 2; ++x) {
            scanline[x] = kCheckColor2;
        }
        scanline[width - 2] = kInnerRingColor;
        scanline[width - 1] = kOuterRingColor;
    }
 
    for (int y = height / 2; y < height - 2; ++y) {
        scanline = bitmap.getAddr32(0, y);
        scanline[0] = kOuterRingColor;
        scanline[1] = kInnerRingColor;
        for (int x = 2; x < width / 2; ++x) {
            scanline[x] = kCheckColor2;
        }
        for (int x = width / 2; x < width - 2; ++x) {
            scanline[x] = kCheckColor1;
        }
        scanline[width - 2] = kInnerRingColor;
        scanline[width - 1] = kOuterRingColor;
    }
 
    scanline = bitmap.getAddr32(0, height - 2);
    scanline[0] = kOuterRingColor;
    for (int x = 1; x < width - 1; ++x) {
        scanline[x] = kInnerRingColor;
    }
    scanline[width - 1] = kOuterRingColor;
 
    scanline = bitmap.getAddr32(0, height - 1);
    for (int x = 0; x < width; ++x) {
        scanline[x] = kOuterRingColor;
    }
    bitmap.setImmutable();
    return { bitmap.asImage(), SkRect::Make({2, 2, width - 2, height - 2})};
}