ToolUtils Namespace Reference

Classes
struct	EmojiTestSample
class	HilbertGenerator
class	PixelIter
class	TopoTestNode
class	VariationSliders

Typedefs
using	PathSniffCallback = void(const SkMatrix &, const SkPath &, const SkPaint &)

Enumerations
enum class	EmojiFontFormat {   Cbdt , Sbix , ColrV0 , Test ,   Svg }

Functions
bool	DecodeDataToBitmap (sk_sp< SkData > data, SkBitmap *dst)
bool	GetResourceAsBitmap (const char *resource, SkBitmap *dst)
sk_sp< SkImage >	GetResourceAsImage (const char *resource)
bool	BitmapToBase64DataURI (const SkBitmap &bitmap, SkString *dst)
bool	EncodeImageToPngFile (const char *path, const SkBitmap &src)
bool	EncodeImageToPngFile (const char *path, const SkPixmap &src)
static	DEFINE_bool (nativeFonts, true, "If true, use native font manager and rendering. " "If false, fonts will draw as portably as possible.")
sk_sp< SkTypeface >	PlanetTypeface ()
EmojiTestSample	EmojiSample ()
EmojiTestSample	EmojiSample (EmojiFontFormat format)
SkString	NameForFontFormat (EmojiFontFormat format)
sk_sp< SkTypeface >	SampleUserTypeface ()
sk_sp< SkTypeface >	CreatePortableTypeface (const char *name, SkFontStyle style)
sk_sp< SkTypeface >	DefaultPortableTypeface ()
SkFont	DefaultPortableFont ()
SkBitmap	CreateStringBitmap (int w, int h, SkColor c, int x, int y, int textSize, const char *str)
sk_sp< SkImage >	CreateStringImage (int w, int h, SkColor c, int x, int y, int textSize, const char *str)
sk_sp< SkFontMgr >	TestFontMgr ()
bool	FontMgrIsGDI ()
void	UsePortableFontMgr ()
sk_sp< SkTypeface >	DefaultTypeface ()
sk_sp< SkTypeface >	CreateTestTypeface (const char *name, SkFontStyle style)
sk_sp< SkTypeface >	CreateTypefaceFromResource (const char *resource, int ttcIndex)
SkFont	DefaultFont ()
sk_sp< SkFontMgr >	MakePortableFontMgr ()
sk_sp< SkImage >	MakeTextureImage (SkCanvas *canvas, sk_sp< SkImage > orig)
void	ExtractPaths (const char filepath[], std::function< PathSniffCallback > callback)
void	ExtractPathsFromSVG (const char filepath[], std::function< PathSniffCallback >)
const char *	alphatype_name (SkAlphaType at)
const char *	colortype_name (SkColorType ct)
const char *	colortype_depth (SkColorType ct)
const char *	tilemode_name (SkTileMode mode)
SkColor	color_to_565 (SkColor color)
sk_sp< SkShader >	create_checkerboard_shader (SkColor c1, SkColor c2, int size)
SkBitmap	create_checkerboard_bitmap (int w, int h, SkColor c1, SkColor c2, int checkSize)
sk_sp< SkImage >	create_checkerboard_image (int w, int h, SkColor c1, SkColor c2, int checkSize)
void	draw_checkerboard (SkCanvas *canvas, SkColor c1, SkColor c2, int size)
int	make_pixmaps (SkColorType ct, SkAlphaType at, bool withMips, const SkColor4f colors[6], SkPixmap pixmaps[6], std::unique_ptr< char[]> *mem)
void	add_to_text_blob_w_len (SkTextBlobBuilder *builder, const char *text, size_t len, SkTextEncoding encoding, const SkFont &font, SkScalar x, SkScalar y)
void	add_to_text_blob (SkTextBlobBuilder *builder, const char *text, const SkFont &font, SkScalar x, SkScalar y)
void	get_text_path (const SkFont &font, const void *text, size_t length, SkTextEncoding encoding, SkPath *dst, const SkPoint pos[])
SkPath	make_star (const SkRect &bounds, int numPts, int step)
static void	norm_to_rgb (SkBitmap *bm, int x, int y, const SkVector3 &norm)
void	create_hemi_normal_map (SkBitmap *bm, const SkIRect &dst)
void	create_frustum_normal_map (SkBitmap *bm, const SkIRect &dst)
void	create_tetra_normal_map (SkBitmap *bm, const SkIRect &dst)
bool	copy_to (SkBitmap *dst, SkColorType dstColorType, const SkBitmap &src)
void	copy_to_g8 (SkBitmap *dst, const SkBitmap &src)
bool	equal_pixels (const SkPixmap &a, const SkPixmap &b)
bool	equal_pixels (const SkBitmap &bm0, const SkBitmap &bm1)
bool	equal_pixels (const SkImage *a, const SkImage *b)
sk_sp< SkSurface >	makeSurface (SkCanvas *canvas, const SkImageInfo &info, const SkSurfaceProps *props)
void	ExtractPathsFromSKP (const char filepath[], std::function< PathSniffCallback > callback)
void	get_text_path (const SkFont &, const void *text, size_t length, SkTextEncoding, SkPath *, const SkPoint *positions=nullptr)
void	draw_checkerboard (SkCanvas *canvas)

Typedef Documentation

PathSniffCallback

using ToolUtils::PathSniffCallback = typedef void(const SkMatrix&, const SkPath&, const SkPaint&)

Definition at line 311 of file ToolUtils.h.

Enumeration Type Documentation

EmojiFontFormat

enum class ToolUtils::EmojiFontFormat

strong

Enumerator
Cbdt
Sbix
ColrV0
Test
Svg

Definition at line 39 of file FontToolUtils.h.

                           {
    Cbdt,
    Sbix,
    ColrV0,
    Test,
    Svg
};

Function Documentation

add_to_text_blob()

void ToolUtils::add_to_text_blob	(	SkTextBlobBuilder *	builder,
		const char *	text,
		const SkFont &	font,
		SkScalar	x,
		SkScalar	y
	)

Definition at line 228 of file ToolUtils.cpp.

                                            {
    add_to_text_blob_w_len(builder, text, strlen(text), SkTextEncoding::kUTF8, font, x, y);
}

add_to_text_blob_w_len()

void ToolUtils::add_to_text_blob_w_len	(	SkTextBlobBuilder *	builder,
		const char *	text,
		size_t	len,
		SkTextEncoding	encoding,
		const SkFont &	font,
		SkScalar	x,
		SkScalar	y
	)

Definition at line 213 of file ToolUtils.cpp.

                                                  {
    int  count = font.countText(text, len, encoding);
    if (count < 1) {
        return;
    }
    auto run   = builder->allocRun(font, count, x, y);
    font.textToGlyphs(text, len, encoding, run.glyphs, count);
}

alphatype_name()

const char * ToolUtils::alphatype_name

(

SkAlphaType

at

)

Definition at line 55 of file ToolUtils.cpp.

                                           {
    switch (at) {
        case kUnknown_SkAlphaType:  return "Unknown";
        case kOpaque_SkAlphaType:   return "Opaque";
        case kPremul_SkAlphaType:   return "Premul";
        case kUnpremul_SkAlphaType: return "Unpremul";
    }
    SkUNREACHABLE;
}

BitmapToBase64DataURI()

bool ToolUtils::BitmapToBase64DataURI	(	const SkBitmap &	bitmap,
		SkString *	dst
	)

Definition at line 25 of file EncodeUtils.cpp.

                                                                  {
    SkPixmap pm;
    if (!bitmap.peekPixels(&pm)) {
        dst->set("peekPixels failed");
        return false;
    }
 
    // We're going to embed this PNG in a data URI, so make it as small as possible
    SkPngEncoder::Options options;
    options.fFilterFlags = SkPngEncoder::FilterFlag::kAll;
    options.fZLibLevel = 9;
 
    SkDynamicMemoryWStream wStream;
    if (!SkPngEncoder::Encode(&wStream, pm, options)) {
        dst->set("SkPngEncoder::Encode failed");
        return false;
    }
 
    sk_sp<SkData> pngData = wStream.detachAsData();
    size_t len = SkBase64::EncodedSize(pngData->size());
 
    // The PNG can be almost arbitrarily large. We don't want to fill our logs with enormous URLs.
    // Infra says these can be pretty big, as long as we're only outputting them on failure.
    static const size_t kMaxBase64Length = 1024 * 1024;
    if (len > kMaxBase64Length) {
        dst->printf("Encoded image too large (%u bytes)", static_cast<uint32_t>(len));
        return false;
    }
 
    dst->resize(len);
    SkBase64::Encode(pngData->data(), pngData->size(), dst->data());
    dst->prepend("data:image/png;base64,");
    return true;
}

color_to_565()

SkColor ToolUtils::color_to_565

(

SkColor

color

)

Map opaque colors from 8888 to 565.

Definition at line 139 of file ToolUtils.cpp.

                                    {
    // Not a good idea to use this function for greyscale colors...
    // it will add an obvious purple or green tint.
    SkASSERT(SkColorGetR(color) != SkColorGetG(color) || SkColorGetR(color) != SkColorGetB(color) ||
             SkColorGetG(color) != SkColorGetB(color));
 
    SkPMColor pmColor = SkPreMultiplyColor(color);
    U16CPU    color16 = SkPixel32ToPixel16(pmColor);
    return SkPixel16ToColor(color16);
}

colortype_depth()

const char * ToolUtils::colortype_depth

(

SkColorType

ct

)

Definition at line 97 of file ToolUtils.cpp.

                                            {
    switch (ct) {
        case kUnknown_SkColorType:            return "Unknown";
        case kAlpha_8_SkColorType:            return "A8";
        case kA16_unorm_SkColorType:          return "A16";
        case kA16_float_SkColorType:          return "AF16";
        case kRGB_565_SkColorType:            return "565";
        case kARGB_4444_SkColorType:          return "4444";
        case kRGBA_8888_SkColorType:          return "8888";
        case kSRGBA_8888_SkColorType:         return "8888";
        case kRGB_888x_SkColorType:           return "888";
        case kBGRA_8888_SkColorType:          return "8888";
        case kRGBA_1010102_SkColorType:       return "1010102";
        case kBGRA_1010102_SkColorType:       return "1010102";
        case kRGB_101010x_SkColorType:        return "101010";
        case kBGR_101010x_SkColorType:        return "101010";
        case kBGR_101010x_XR_SkColorType:     return "101010";
        case kBGRA_10101010_XR_SkColorType:   return "10101010";
        case kRGBA_10x6_SkColorType:          return "10101010";
        case kGray_8_SkColorType:             return "G8";
        case kRGBA_F16Norm_SkColorType:       return "F16Norm";
        case kRGBA_F16_SkColorType:           return "F16";
        case kRGBA_F32_SkColorType:           return "F32";
        case kR8G8_unorm_SkColorType:         return "88";
        case kR16G16_unorm_SkColorType:       return "1616";
        case kR16G16_float_SkColorType:       return "F16F16";
        case kR16G16B16A16_unorm_SkColorType: return "16161616";
        case kR8_unorm_SkColorType:           return "R8";
    }
    SkUNREACHABLE;
}

colortype_name()

const char * ToolUtils::colortype_name

(

SkColorType

ct

)

Definition at line 65 of file ToolUtils.cpp.

                                           {
    switch (ct) {
        case kUnknown_SkColorType:            return "Unknown";
        case kAlpha_8_SkColorType:            return "Alpha_8";
        case kA16_unorm_SkColorType:          return "Alpha_16";
        case kA16_float_SkColorType:          return "A16_float";
        case kRGB_565_SkColorType:            return "RGB_565";
        case kARGB_4444_SkColorType:          return "ARGB_4444";
        case kRGBA_8888_SkColorType:          return "RGBA_8888";
        case kSRGBA_8888_SkColorType:         return "SRGBA_8888";
        case kRGB_888x_SkColorType:           return "RGB_888x";
        case kBGRA_8888_SkColorType:          return "BGRA_8888";
        case kRGBA_1010102_SkColorType:       return "RGBA_1010102";
        case kBGRA_1010102_SkColorType:       return "BGRA_1010102";
        case kRGB_101010x_SkColorType:        return "RGB_101010x";
        case kBGR_101010x_SkColorType:        return "BGR_101010x";
        case kBGR_101010x_XR_SkColorType:     return "BGR_101010x_XR";
        case kRGBA_10x6_SkColorType:          return "RGBA_10x6";
        case kGray_8_SkColorType:             return "Gray_8";
        case kRGBA_F16Norm_SkColorType:       return "RGBA_F16Norm";
        case kRGBA_F16_SkColorType:           return "RGBA_F16";
        case kRGBA_F32_SkColorType:           return "RGBA_F32";
        case kR8G8_unorm_SkColorType:         return "R8G8_unorm";
        case kR16G16_unorm_SkColorType:       return "R16G16_unorm";
        case kR16G16_float_SkColorType:       return "R16G16_float";
        case kR16G16B16A16_unorm_SkColorType: return "R16G16B16A16_unorm";
        case kR8_unorm_SkColorType:           return "R8_unorm";
        case kBGRA_10101010_XR_SkColorType:   return "BGRA_10101010_XR";
    }
    SkUNREACHABLE;
}

copy_to()

bool ToolUtils::copy_to	(	SkBitmap *	dst,
		SkColorType	dstColorType,
		const SkBitmap &	src
	)

Definition at line 394 of file ToolUtils.cpp.

                                                                           {
    SkPixmap srcPM;
    if (!src.peekPixels(&srcPM)) {
        return false;
    }
 
    SkBitmap    tmpDst;
    SkImageInfo dstInfo = srcPM.info().makeColorType(dstColorType);
    if (!tmpDst.setInfo(dstInfo)) {
        return false;
    }
 
    if (!tmpDst.tryAllocPixels()) {
        return false;
    }
 
    SkPixmap dstPM;
    if (!tmpDst.peekPixels(&dstPM)) {
        return false;
    }
 
    if (!srcPM.readPixels(dstPM)) {
        return false;
    }
 
    dst->swap(tmpDst);
    return true;
}

copy_to_g8()

void ToolUtils::copy_to_g8	(	SkBitmap *	dst,
		const SkBitmap &	src
	)

Definition at line 423 of file ToolUtils.cpp.

                                                    {
    SkASSERT(kBGRA_8888_SkColorType == src.colorType() ||
             kRGBA_8888_SkColorType == src.colorType());
 
    SkImageInfo grayInfo = src.info().makeColorType(kGray_8_SkColorType);
    dst->allocPixels(grayInfo);
    uint8_t*        dst8  = (uint8_t*)dst->getPixels();
    const uint32_t* src32 = (const uint32_t*)src.getPixels();
 
    const int  w      = src.width();
    const int  h      = src.height();
    const bool isBGRA = (kBGRA_8888_SkColorType == src.colorType());
    for (int y = 0; y < h; ++y) {
        if (isBGRA) {
            // BGRA
            for (int x = 0; x < w; ++x) {
                uint32_t s = src32[x];
                dst8[x]    = SkComputeLuminance((s >> 16) & 0xFF, (s >> 8) & 0xFF, s & 0xFF);
            }
        } else {
            // RGBA
            for (int x = 0; x < w; ++x) {
                uint32_t s = src32[x];
                dst8[x]    = SkComputeLuminance(s & 0xFF, (s >> 8) & 0xFF, (s >> 16) & 0xFF);
            }
        }
        src32 = (const uint32_t*)((const char*)src32 + src.rowBytes());
        dst8 += dst->rowBytes();
    }
}

create_checkerboard_bitmap()

SkBitmap ToolUtils::create_checkerboard_bitmap	(	int	w,
		int	h,
		SkColor	c1,
		SkColor	c2,
		int	checkSize
	)

Make it easier to create a bitmap-based checkerboard

Definition at line 159 of file ToolUtils.cpp.

                                                                                         {
    SkBitmap bitmap;
    bitmap.allocPixels(SkImageInfo::MakeS32(w, h, kPremul_SkAlphaType));
    SkCanvas canvas(bitmap);
 
    ToolUtils::draw_checkerboard(&canvas, c1, c2, checkSize);
    return bitmap;
}

create_checkerboard_image()

sk_sp< SkImage > ToolUtils::create_checkerboard_image	(	int	w,
		int	h,
		SkColor	c1,
		SkColor	c2,
		int	checkSize
	)

Definition at line 168 of file ToolUtils.cpp.

                                                                                              {
    auto surf = SkSurfaces::Raster(SkImageInfo::MakeN32Premul(w, h));
    ToolUtils::draw_checkerboard(surf->getCanvas(), c1, c2, checkSize);
    return surf->makeImageSnapshot();
}

create_checkerboard_shader()

sk_sp< SkShader > ToolUtils::create_checkerboard_shader	(	SkColor	c1,
		SkColor	c2,
		int	size
	)

Returns a newly created CheckerboardShader.

Definition at line 150 of file ToolUtils.cpp.

                                                                             {
    SkBitmap bm;
    bm.allocPixels(SkImageInfo::MakeS32(2 * size, 2 * size, kPremul_SkAlphaType));
    bm.eraseColor(c1);
    bm.eraseArea(SkIRect::MakeLTRB(0, 0, size, size), c2);
    bm.eraseArea(SkIRect::MakeLTRB(size, size, 2 * size, 2 * size), c2);
    return bm.makeShader(SkTileMode::kRepeat, SkTileMode::kRepeat, SkSamplingOptions());
}

create_frustum_normal_map()

void ToolUtils::create_frustum_normal_map	(	SkBitmap *	bm,
		const SkIRect &	dst
	)

Definition at line 318 of file ToolUtils.cpp.

                                                                 {
    const SkPoint center =
            SkPoint::Make(dst.fLeft + (dst.width() / 2.0f), dst.fTop + (dst.height() / 2.0f));
 
    SkIRect inner = dst;
    inner.inset(dst.width() / 4, dst.height() / 4);
 
    SkPoint3       norm;
    const SkPoint3 left  = SkPoint3::Make(-SK_ScalarRoot2Over2, 0.0f, SK_ScalarRoot2Over2);
    const SkPoint3 up    = SkPoint3::Make(0.0f, -SK_ScalarRoot2Over2, SK_ScalarRoot2Over2);
    const SkPoint3 right = SkPoint3::Make(SK_ScalarRoot2Over2, 0.0f, SK_ScalarRoot2Over2);
    const SkPoint3 down  = SkPoint3::Make(0.0f, SK_ScalarRoot2Over2, SK_ScalarRoot2Over2);
 
    for (int y = dst.fTop; y < dst.fBottom; ++y) {
        for (int x = dst.fLeft; x < dst.fRight; ++x) {
            if (inner.contains(x, y)) {
                norm.set(0.0f, 0.0f, 1.0f);
            } else {
                SkScalar locX = x + 0.5f - center.fX;
                SkScalar locY = y + 0.5f - center.fY;
 
                if (locX >= 0.0f) {
                    if (locY > 0.0f) {
                        norm = locX >= locY ? right : down;  // LR corner
                    } else {
                        norm = locX > -locY ? right : up;  // UR corner
                    }
                } else {
                    if (locY > 0.0f) {
                        norm = -locX > locY ? left : down;  // LL corner
                    } else {
                        norm = locX > locY ? up : left;  // UL corner
                    }
                }
            }
 
            norm_to_rgb(bm, x, y, norm);
        }
    }
}

create_hemi_normal_map()

void ToolUtils::create_hemi_normal_map	(	SkBitmap *	bm,
		const SkIRect &	dst
	)

Definition at line 294 of file ToolUtils.cpp.

                                                              {
    const SkPoint center =
            SkPoint::Make(dst.fLeft + (dst.width() / 2.0f), dst.fTop + (dst.height() / 2.0f));
    const SkPoint halfSize = SkPoint::Make(dst.width() / 2.0f, dst.height() / 2.0f);
 
    SkVector3 norm;
 
    for (int y = dst.fTop; y < dst.fBottom; ++y) {
        for (int x = dst.fLeft; x < dst.fRight; ++x) {
            norm.fX = (x + 0.5f - center.fX) / halfSize.fX;
            norm.fY = (y + 0.5f - center.fY) / halfSize.fY;
 
            SkScalar tmp = norm.fX * norm.fX + norm.fY * norm.fY;
            if (tmp >= 1.0f) {
                norm.set(0.0f, 0.0f, 1.0f);
            } else {
                norm.fZ = sqrtf(1.0f - tmp);
            }
 
            norm_to_rgb(bm, x, y, norm);
        }
    }
}

create_tetra_normal_map()

void ToolUtils::create_tetra_normal_map	(	SkBitmap *	bm,
		const SkIRect &	dst
	)

Definition at line 359 of file ToolUtils.cpp.

                                                               {
    const SkPoint center =
            SkPoint::Make(dst.fLeft + (dst.width() / 2.0f), dst.fTop + (dst.height() / 2.0f));
 
    static const SkScalar k1OverRoot3 = 0.5773502692f;
 
    SkPoint3       norm;
    const SkPoint3 leftUp  = SkPoint3::Make(-k1OverRoot3, -k1OverRoot3, k1OverRoot3);
    const SkPoint3 rightUp = SkPoint3::Make(k1OverRoot3, -k1OverRoot3, k1OverRoot3);
    const SkPoint3 down    = SkPoint3::Make(0.0f, SK_ScalarRoot2Over2, SK_ScalarRoot2Over2);
 
    for (int y = dst.fTop; y < dst.fBottom; ++y) {
        for (int x = dst.fLeft; x < dst.fRight; ++x) {
            SkScalar locX = x + 0.5f - center.fX;
            SkScalar locY = y + 0.5f - center.fY;
 
            if (locX >= 0.0f) {
                if (locY > 0.0f) {
                    norm = locX >= locY ? rightUp : down;  // LR corner
                } else {
                    norm = rightUp;
                }
            } else {
                if (locY > 0.0f) {
                    norm = -locX > locY ? leftUp : down;  // LL corner
                } else {
                    norm = leftUp;
                }
            }
 
            norm_to_rgb(bm, x, y, norm);
        }
    }
}

CreatePortableTypeface()

sk_sp< SkTypeface > ToolUtils::CreatePortableTypeface	(	const char *	name,
		SkFontStyle	style
	)

Returns a platform-independent text renderer.

Definition at line 187 of file FontToolUtils.cpp.

                                                                              {
    static sk_sp<SkFontMgr> portableFontMgr = MakePortableFontMgr();
    SkASSERT_RELEASE(portableFontMgr);
    sk_sp<SkTypeface> face = portableFontMgr->legacyMakeTypeface(name, style);
    SkASSERT_RELEASE(face);
    return face;
}

CreateStringBitmap()

SkBitmap ToolUtils::CreateStringBitmap	(	int	w,
		int	h,
		SkColor	c,
		int	x,
		int	y,
		int	textSize,
		const char *	str
	)

Definition at line 206 of file FontToolUtils.cpp.

                                             {
    SkBitmap bitmap;
    bitmap.allocN32Pixels(w, h);
    SkCanvas canvas(bitmap);
 
    SkPaint paint;
    paint.setColor(c);
 
    SkFont font(DefaultPortableTypeface(), textSize);
 
    canvas.clear(0x00000000);
    canvas.drawSimpleText(str,
                          strlen(str),
                          SkTextEncoding::kUTF8,
                          SkIntToScalar(x),
                          SkIntToScalar(y),
                          font,
                          paint);
 
    // Tag data as sRGB (without doing any color space conversion). Color-space aware configs
    // will process this correctly but legacy configs will render as if this returned N32.
    SkBitmap result;
    result.setInfo(SkImageInfo::MakeS32(w, h, kPremul_SkAlphaType));
    result.setPixelRef(sk_ref_sp(bitmap.pixelRef()), 0, 0);
    return result;
}

CreateStringImage()

sk_sp< SkImage > ToolUtils::CreateStringImage	(	int	w,
		int	h,
		SkColor	c,
		int	x,
		int	y,
		int	textSize,
		const char *	str
	)

Definition at line 234 of file FontToolUtils.cpp.

                                                  {
    return CreateStringBitmap(w, h, c, x, y, textSize, str).asImage();
}

CreateTestTypeface()

sk_sp< SkTypeface > ToolUtils::CreateTestTypeface	(	const char *	name,
		SkFontStyle	style
	)

Definition at line 307 of file FontToolUtils.cpp.

                                                                          {
    sk_sp<SkFontMgr> fm = TestFontMgr();
    SkASSERT_RELEASE(fm);
    sk_sp<SkTypeface> face = fm->legacyMakeTypeface(name, style);
    if (face) {
        return face;
    }
    return CreatePortableTypeface(name, style);
}

CreateTypefaceFromResource()

sk_sp< SkTypeface > ToolUtils::CreateTypefaceFromResource	(	const char *	resource,
		int	ttcIndex
	)

Definition at line 317 of file FontToolUtils.cpp.

                                                                                 {
    sk_sp<SkFontMgr> fm = TestFontMgr();
    SkASSERT_RELEASE(fm);
    return fm->makeFromStream(GetResourceAsStream(resource), ttcIndex);
}

DecodeDataToBitmap()

bool ToolUtils::DecodeDataToBitmap	(	sk_sp< SkData >	data,
		SkBitmap *	dst
	)

Definition at line 22 of file DecodeUtils.cpp.

                                                           {
    std::unique_ptr<SkImageGenerator> gen(SkImageGenerators::MakeFromEncoded(std::move(data)));
    return gen && dst->tryAllocPixels(gen->getInfo()) &&
           gen->getPixels(
                   gen->getInfo().makeColorSpace(nullptr), dst->getPixels(), dst->rowBytes());
}

DefaultFont()

SkFont ToolUtils::DefaultFont

(

)

Definition at line 323 of file FontToolUtils.cpp.

                     {
    return SkFont(DefaultTypeface(), 12);
}

DefaultPortableFont()

SkFont ToolUtils::DefaultPortableFont

(

)

Returns a font that has a non-empty typeface. This could change, so don't depend on things like how it looks, font metrics, etc.

Definition at line 202 of file FontToolUtils.cpp.

                             {
    return SkFont(DefaultPortableTypeface(), 12);
}

DefaultPortableTypeface()

sk_sp< SkTypeface > ToolUtils::DefaultPortableTypeface

(

)

Definition at line 195 of file FontToolUtils.cpp.

                                            {
    // At last check, the default typeface is a serif font.
    sk_sp<SkTypeface> face = CreatePortableTypeface(nullptr, SkFontStyle());
    SkASSERT_RELEASE(face);
    return face;
}

DefaultTypeface()

sk_sp< SkTypeface > ToolUtils::DefaultTypeface

(

)

Definition at line 303 of file FontToolUtils.cpp.

                                    {
    return CreateTestTypeface(nullptr, SkFontStyle());
}

DEFINE_bool()

static ToolUtils::DEFINE_bool ( nativeFonts  , true  , "If  true, use native font manager and rendering. " "If  false, fonts will draw as portably as possible."    )

static

draw_checkerboard() [1/2]

void ToolUtils::draw_checkerboard ( SkCanvas *  canvas )

inline

A default checkerboard.

Definition at line 95 of file ToolUtils.h.

                                                {
    ToolUtils::draw_checkerboard(canvas, 0xFF999999, 0xFF666666, 8);
}

draw_checkerboard() [2/2]

void ToolUtils::draw_checkerboard	(	SkCanvas *	canvas,
		SkColor	color1,
		SkColor	color2,
		int	checkSize
	)

Draw a checkerboard pattern in the current canvas, restricted to the current clip, using SkBlendMode::kSrc.

Definition at line 174 of file ToolUtils.cpp.

                                                                           {
    SkPaint paint;
    paint.setShader(create_checkerboard_shader(c1, c2, size));
    paint.setBlendMode(SkBlendMode::kSrc);
    canvas->drawPaint(paint);
}

EmojiSample() [1/2]

EmojiTestSample ToolUtils::EmojiSample

(

)

Return a color emoji typeface if available.

Definition at line 92 of file FontToolUtils.cpp.

                              {
    static const EmojiTestSample emojiSample = []() {
        EmojiTestSample sample = {nullptr, ""};
#if defined(SK_BUILD_FOR_WIN)
        sample = EmojiSample(EmojiFontFormat::ColrV0);
#elif defined(SK_BUILD_FOR_MAC) || defined(SK_BUILD_FOR_IOS)
        sample = EmojiSample(EmojiFontFormat::Sbix);
#else
        sample = EmojiSample(EmojiFontFormat::Cbdt);
#endif
        if (sample.typeface) {
            return sample;
        }
        return EmojiSample(EmojiFontFormat::Test);
    }();
    return emojiSample;
}

EmojiSample() [2/2]

EmojiTestSample ToolUtils::EmojiSample

(

EmojiFontFormat

format

)

Return a color emoji typeface of a specific color font format if available.

Definition at line 110 of file FontToolUtils.cpp.

                                                    {
    EmojiTestSample sample;
    sample.sampleText = "\U0001F600 \u2662";  // 😀 ♢
    switch (format) {
        case EmojiFontFormat::Cbdt:
            sample.typeface = CreateTypefaceFromResource("fonts/cbdt.ttf");
            break;
        case EmojiFontFormat::Sbix:
            sample.typeface = CreateTypefaceFromResource("fonts/sbix.ttf");
            break;
        case EmojiFontFormat::ColrV0:
            sample.typeface = CreateTypefaceFromResource("fonts/colr.ttf");
            break;
        case EmojiFontFormat::Svg:
            sample.typeface = CreateTypefaceFromResource("fonts/SampleSVG.ttf");
            sample.sampleText = "abcdefghij";
            break;
        case EmojiFontFormat::Test:
            sample.typeface = CreatePortableTypeface("Emoji", SkFontStyle());
    }
    return sample;
}

EncodeImageToPngFile() [1/2]

bool ToolUtils::EncodeImageToPngFile	(	const char *	path,
		const SkBitmap &	src
	)

Definition at line 60 of file EncodeUtils.cpp.

                                                                 {
    SkFILEWStream file(path);
    return file.isValid() && SkPngEncoder::Encode(&file, src.pixmap(), {});
}

EncodeImageToPngFile() [2/2]

bool ToolUtils::EncodeImageToPngFile	(	const char *	path,
		const SkPixmap &	src
	)

Definition at line 65 of file EncodeUtils.cpp.

                                                                 {
    SkFILEWStream file(path);
    return file.isValid() && SkPngEncoder::Encode(&file, src, {});
}

equal_pixels() [1/3]

bool ToolUtils::equal_pixels	(	const SkBitmap &	bm0,
		const SkBitmap &	bm1
	)

Definition at line 480 of file ToolUtils.cpp.

                                                            {
    SkPixmap pm0, pm1;
    if (!bm0.peekPixels(&pm0)) {
        SkDebugf("Could not read pixels from A\n");
        return false;
    }
    if (!bm1.peekPixels(&pm1)) {
        SkDebugf("Could not read pixels from B\n");
        return false;
    }
    return equal_pixels(pm0, pm1);
}

equal_pixels() [2/3]

bool ToolUtils::equal_pixels	(	const SkImage *	a,
		const SkImage *	b
	)

Definition at line 493 of file ToolUtils.cpp.

                                                      {
    SkASSERT_RELEASE(a);
    SkASSERT_RELEASE(b);
    // ensure that peekPixels will succeed
    auto imga = a->makeRasterImage();
    auto imgb = b->makeRasterImage();
 
    SkPixmap pm0, pm1;
    if (!imga->peekPixels(&pm0)) {
        SkDebugf("Could not read pixels from A\n");
        return false;
    }
    if (!imgb->peekPixels(&pm1)) {
        SkDebugf("Could not read pixels from B\n");
        return false;
    }
    return equal_pixels(pm0, pm1);
}

equal_pixels() [3/3]

bool ToolUtils::equal_pixels	(	const SkPixmap &	,
		const SkPixmap &
	)

Returns true iff all of the pixels between the two images are identical.

If the configs differ, return false.

Definition at line 456 of file ToolUtils.cpp.

                                                        {
    if (a.width() != b.width() || a.height() != b.height()) {
        SkDebugf("[ToolUtils::equal_pixels] Dimensions do not match (%d x %d) != (%d x %d)\n",
                 a.width(), a.height(), b.width(), b.height());
        return false;
    }
 
    if (a.colorType() != b.colorType()) {
        SkDebugf("[ToolUtils::equal_pixels] colorType does not match %d != %d\n",
                 (int) a.colorType(), (int) b.colorType());
        return false;
    }
 
    for (int y = 0; y < a.height(); ++y) {
        const char* aptr = (const char*)a.addr(0, y);
        const char* bptr = (const char*)b.addr(0, y);
        if (0 != memcmp(aptr, bptr, a.width() * a.info().bytesPerPixel())) {
            SkDebugf("[ToolUtils::equal_pixels] row %d does not match byte for byte\n", y);
            return false;
        }
    }
    return true;
}

ExtractPaths()

void ToolUtils::ExtractPaths	(	const char	filepath[],
		std::function< PathSniffCallback >	callback
	)

Definition at line 26 of file SvgPathExtractor.cpp.

                                                                                  {
    SkFILEStream stream(filepath);
    if (!stream.isValid()) {
        SkDebugf("ExtractPaths: invalid input file at \"%s\"\n", filepath);
        return;
    }
 
    class PathSniffer : public SkCanvas {
    public:
        PathSniffer(std::function<PathSniffCallback> callback)
                : SkCanvas(4096, 4096, nullptr)
                , fPathSniffCallback(callback) {}
    private:
        void onDrawPath(const SkPath& path, const SkPaint& paint) override {
            fPathSniffCallback(this->getTotalMatrix(), path, paint);
        }
        std::function<PathSniffCallback> fPathSniffCallback;
    };
 
    sk_sp<SkSVGDOM> svg = SkSVGDOM::MakeFromStream(stream);
    if (!svg) {
        SkDebugf("ExtractPaths: couldn't load svg at \"%s\"\n", filepath);
        return;
    }
    PathSniffer pathSniffer(callback);
    svg->setContainerSize(SkSize::Make(pathSniffer.getBaseLayerSize()));
    svg->render(&pathSniffer);
}

ExtractPathsFromSKP()

void ToolUtils::ExtractPathsFromSKP	(	const char	filepath[],
		std::function< PathSniffCallback >	callback
	)

Definition at line 757 of file ToolUtils.cpp.

                                                                                         {
    SkFILEStream stream(filepath);
    if (!stream.isValid()) {
        SkDebugf("ExtractPaths: invalid input file at \"%s\"\n", filepath);
        return;
    }
 
    class PathSniffer : public SkCanvas {
    public:
        PathSniffer(std::function<PathSniffCallback> callback)
                : SkCanvas(4096, 4096, nullptr)
                , fPathSniffCallback(callback) {}
    private:
        void onDrawPath(const SkPath& path, const SkPaint& paint) override {
            fPathSniffCallback(this->getTotalMatrix(), path, paint);
        }
        std::function<PathSniffCallback> fPathSniffCallback;
    };
 
    sk_sp<SkPicture> skp = SkPicture::MakeFromStream(&stream);
    if (!skp) {
        SkDebugf("ExtractPaths: couldn't load skp at \"%s\"\n", filepath);
        return;
    }
    PathSniffer pathSniffer(callback);
    skp->playback(&pathSniffer);
}

ExtractPathsFromSVG()

void ToolUtils::ExtractPathsFromSVG	(	const char	filepath[],
		std::function< PathSniffCallback >
	)

FontMgrIsGDI()

bool ToolUtils::FontMgrIsGDI

(

)

Definition at line 289 of file FontToolUtils.cpp.

                    {
    if (!FLAGS_nativeFonts) {
        return false;
    }
#if defined(SK_BUILD_FOR_WIN)
    if (FLAGS_gdi) {
        return true;
    }
#endif
    return false;
}

get_text_path() [1/2]

void ToolUtils::get_text_path	(	const SkFont &	,
		const void *	text,
		size_t	length,
		SkTextEncoding	,
		SkPath *	,
		const SkPoint *	positions = nullptr
	)

get_text_path() [2/2]

void ToolUtils::get_text_path	(	const SkFont &	font,
		const void *	text,
		size_t	length,
		SkTextEncoding	encoding,
		SkPath *	dst,
		const SkPoint	pos[]
	)

Definition at line 236 of file ToolUtils.cpp.

                                         {
    SkAutoToGlyphs        atg(font, text, length, encoding);
    const int             count = atg.count();
    AutoTArray<SkPoint> computedPos;
    if (pos == nullptr) {
        computedPos.reset(count);
        font.getPos(atg.glyphs(), count, &computedPos[0]);
        pos = computedPos.get();
    }
 
    struct Rec {
        SkPath*        fDst;
        const SkPoint* fPos;
    } rec = {dst, pos};
    font.getPaths(atg.glyphs(),
                  atg.count(),
                  [](const SkPath* src, const SkMatrix& mx, void* ctx) {
                      Rec* rec = (Rec*)ctx;
                      if (src) {
                          SkMatrix tmp(mx);
                          tmp.postTranslate(rec->fPos->fX, rec->fPos->fY);
                          rec->fDst->addPath(*src, tmp);
                      }
                      rec->fPos += 1;
                  },
                  &rec);
}

GetResourceAsBitmap()

bool ToolUtils::GetResourceAsBitmap ( const char *  resource, SkBitmap *  dst  )

inline

Definition at line 21 of file DecodeUtils.h.

                                                                     {
    return DecodeDataToBitmap(GetResourceAsData(resource), dst);
}

GetResourceAsImage()

sk_sp< SkImage > ToolUtils::GetResourceAsImage ( const char *  resource )

inline

Definition at line 25 of file DecodeUtils.h.

                                                               {
    return SkImages::DeferredFromEncodedData(GetResourceAsData(resource));
}

make_pixmaps()

int ToolUtils::make_pixmaps	(	SkColorType	,
		SkAlphaType	,
		bool	withMips,
		const SkColor4f	colors[6],
		SkPixmap	pixmaps[6],
		std::unique_ptr< char[]> *	mem
	)

Create pixmaps to initialize a 32x32 image w/ or w/o mipmaps. Returns the number of levels (either 1 or 6). The mipmap levels will be colored as specified in 'colors'

Definition at line 181 of file ToolUtils.cpp.

                                             {
 
    int levelSize = 32;
    int numMipLevels = withMips ? 6 : 1;
    size_t size = 0;
    SkImageInfo ii[6];
    size_t rowBytes[6];
    for (int level = 0; level < numMipLevels; ++level) {
        ii[level] = SkImageInfo::Make(levelSize, levelSize, ct, at);
        rowBytes[level] = ii[level].minRowBytes();
        // Make sure we test row bytes that aren't tight.
        if (!(level % 2)) {
            rowBytes[level] += (level + 1)*SkColorTypeBytesPerPixel(ii[level].colorType());
        }
        size += rowBytes[level]*ii[level].height();
        levelSize /= 2;
    }
    mem->reset(new char[size]);
    char* addr = mem->get();
    for (int level = 0; level < numMipLevels; ++level) {
        pixmaps[level].reset(ii[level], addr, rowBytes[level]);
        addr += rowBytes[level]*ii[level].height();
        pixmaps[level].erase(colors[level]);
    }
    return numMipLevels;
}

make_star()

SkPath ToolUtils::make_star	(	const SkRect &	bounds,
		int	numPts,
		int	step
	)

Definition at line 269 of file ToolUtils.cpp.

                                                             {
    SkASSERT(numPts != step);
    SkPathBuilder builder;
    builder.setFillType(SkPathFillType::kEvenOdd);
    builder.moveTo(0, -1);
    for (int i = 1; i < numPts; ++i) {
        int      idx   = i * step % numPts;
        SkScalar theta = idx * 2 * SK_ScalarPI / numPts + SK_ScalarPI / 2;
        SkScalar x     = SkScalarCos(theta);
        SkScalar y     = -SkScalarSin(theta);
        builder.lineTo(x, y);
    }
    SkPath path = builder.detach();
    path.transform(SkMatrix::RectToRect(path.getBounds(), bounds));
    return path;
}

MakePortableFontMgr()

sk_sp< SkFontMgr > ToolUtils::MakePortableFontMgr

(

)

Definition at line 175 of file TestFontMgr.cpp.

{ return sk_make_sp<FontMgr>(); }

makeSurface()

sk_sp< SkSurface > ToolUtils::makeSurface	(	SkCanvas *	canvas,
		const SkImageInfo &	info,
		const SkSurfaceProps *	props
	)

Definition at line 512 of file ToolUtils.cpp.

                                                          {
    auto surf = canvas->makeSurface(info, props);
    if (!surf) {
        surf = SkSurfaces::Raster(info, props);
    }
    return surf;
}

MakeTextureImage()

sk_sp< SkImage > ToolUtils::MakeTextureImage	(	SkCanvas *	canvas,
		sk_sp< SkImage >	orig
	)

Definition at line 32 of file GpuToolUtils.cpp.

                                                                       {
    if (!orig) {
        return nullptr;
    }
 
#if defined(SK_GANESH)
    if (canvas->recordingContext() && canvas->recordingContext()->asDirectContext()) {
        GrDirectContext* dContext = canvas->recordingContext()->asDirectContext();
        const GrCaps* caps = dContext->priv().caps();
 
        if (orig->width() >= caps->maxTextureSize() || orig->height() >= caps->maxTextureSize()) {
            // Ganesh is able to tile large SkImage draws. Always forcing SkImages to be uploaded
            // prevents this feature from being tested by our tools. For now, leave excessively
            // large SkImages as bitmaps.
            return orig;
        }
 
        return SkImages::TextureFromImage(dContext, orig);
    }
#endif
#if defined(SK_GRAPHITE)
    if (canvas->recorder()) {
        return SkImages::TextureFromImage(canvas->recorder(), orig, {false});
    }
#endif
    return orig;
}

NameForFontFormat()

SkString ToolUtils::NameForFontFormat

(

EmojiFontFormat

format

)

Return a string representation of the requeste format. Useful for suffixing test names.

Definition at line 133 of file FontToolUtils.cpp.

                                                   {
    switch (format) {
        case EmojiFontFormat::Cbdt:
            return SkString("cbdt");
        case EmojiFontFormat::Sbix:
            return SkString("sbix");
        case EmojiFontFormat::ColrV0:
            return SkString("colrv0");
        case EmojiFontFormat::Test:
            return SkString("test");
        case EmojiFontFormat::Svg:
            return SkString("svg");
    }
    return SkString();
}

norm_to_rgb()

static void ToolUtils::norm_to_rgb ( SkBitmap *  bm, int  x, int  y, const SkVector3 &  norm  )

inlinestatic

Definition at line 286 of file ToolUtils.cpp.

                                                                                  {
    SkASSERT(SkScalarNearlyEqual(norm.length(), 1.0f));
    unsigned char r      = static_cast<unsigned char>((0.5f * norm.fX + 0.5f) * 255);
    unsigned char g      = static_cast<unsigned char>((-0.5f * norm.fY + 0.5f) * 255);
    unsigned char b      = static_cast<unsigned char>((0.5f * norm.fZ + 0.5f) * 255);
    *bm->getAddr32(x, y) = SkPackARGB32(0xFF, r, g, b);
}

PlanetTypeface()

sk_sp< SkTypeface > ToolUtils::PlanetTypeface

(

)

Definition at line 73 of file FontToolUtils.cpp.

                                   {
    static const sk_sp<SkTypeface> planetTypeface = []() {
        const char* filename;
#if defined(SK_BUILD_FOR_WIN)
        filename = "fonts/planetcolr.ttf";
#elif defined(SK_BUILD_FOR_MAC) || defined(SK_BUILD_FOR_IOS)
        filename = "fonts/planetsbix.ttf";
#else
        filename = "fonts/planetcbdt.ttf";
#endif
        sk_sp<SkTypeface> typeface = CreateTypefaceFromResource(filename);
        if (typeface) {
            return typeface;
        }
        return CreateTestTypeface("Planet", SkFontStyle());
    }();
    return planetTypeface;
}

SampleUserTypeface()

sk_sp< SkTypeface > ToolUtils::SampleUserTypeface

(

)

A simple SkUserTypeface for testing.

Definition at line 149 of file FontToolUtils.cpp.

                                       {
    SkCustomTypefaceBuilder builder;
    SkFont font;
    const float upem = 200;
 
    {
        SkFontMetrics metrics;
        metrics.fFlags = 0;
        metrics.fTop = -200;
        metrics.fAscent = -150;
        metrics.fDescent = 50;
        metrics.fBottom = -75;
        metrics.fLeading = 10;
        metrics.fAvgCharWidth = 150;
        metrics.fMaxCharWidth = 300;
        metrics.fXMin = -20;
        metrics.fXMax = 290;
        metrics.fXHeight = -100;
        metrics.fCapHeight = 0;
        metrics.fUnderlineThickness = 5;
        metrics.fUnderlinePosition = 2;
        metrics.fStrikeoutThickness = 5;
        metrics.fStrikeoutPosition = -50;
        builder.setMetrics(metrics, 1.0f/upem);
    }
    builder.setFontStyle(SkFontStyle(367, 3, SkFontStyle::kOblique_Slant));
 
    const SkMatrix scale = SkMatrix::Scale(1.0f/upem, 1.0f/upem);
    for (SkGlyphID index = 0; index <= 67; ++index) {
        SkScalar width;
        width = 100;
 
        builder.setGlyph(index, width/upem, SkPath::Circle(50, -50, 75).makeTransform(scale));
    }
 
    return builder.detach();
}

TestFontMgr()

sk_sp< SkFontMgr > ToolUtils::TestFontMgr

(

)

Definition at line 247 of file FontToolUtils.cpp.

                               {
    static sk_sp<SkFontMgr> mgr;
    static SkOnce once;
    once([] {
        if (!FLAGS_nativeFonts) {
            mgr = MakePortableFontMgr();
        }
#if defined(SK_BUILD_FOR_WIN) && defined(SK_FONTMGR_GDI_AVAILABLE)
        else if (FLAGS_gdi) {
            mgr = SkFontMgr_New_GDI();
        }
#endif
#if defined(SK_FONTMGR_FONTATIONS_AVAILABLE)
        else if (FLAGS_fontations) {
            mgr = SkFontMgr_New_Fontations_Empty();
        }
#endif
        else {
#if defined(SK_BUILD_FOR_ANDROID) && defined(SK_FONTMGR_ANDROID_AVAILABLE)
            mgr = SkFontMgr_New_Android(nullptr, std::make_unique<SkFontScanner_FreeType>());
#elif defined(SK_BUILD_FOR_WIN) && defined(SK_FONTMGR_DIRECTWRITE_AVAILABLE)
            mgr = SkFontMgr_New_DirectWrite();
#elif defined(SK_FONTMGR_CORETEXT_AVAILABLE) && (defined(SK_BUILD_FOR_IOS) || \
                                                defined(SK_BUILD_FOR_MAC))
            mgr = SkFontMgr_New_CoreText(nullptr);
#elif defined(SK_FONTMGR_FONTCONFIG_AVAILABLE)
            mgr = SkFontMgr_New_FontConfig(nullptr);
#elif defined(SK_FONTMGR_FREETYPE_DIRECTORY_AVAILABLE)
            // In particular, this is used on ChromeOS, which is Linux-like but doesn't have
            // FontConfig.
            mgr = SkFontMgr_New_Custom_Directory(SK_FONT_FILE_PREFIX);
#elif defined(SK_FONTMGR_FREETYPE_EMPTY_AVAILABLE)
            mgr = SkFontMgr_New_Custom_Empty();
#else
            mgr = SkFontMgr::RefEmpty();
#endif
        }
        SkASSERT_RELEASE(mgr);
    });
    return mgr;
}

tilemode_name()

const char * ToolUtils::tilemode_name

(

SkTileMode

mode

)

Definition at line 129 of file ToolUtils.cpp.

                                           {
    switch (mode) {
        case SkTileMode::kClamp:  return "clamp";
        case SkTileMode::kRepeat: return "repeat";
        case SkTileMode::kMirror: return "mirror";
        case SkTileMode::kDecal:  return "decal";
    }
    SkUNREACHABLE;
}

UsePortableFontMgr()

void ToolUtils::UsePortableFontMgr

(

)

Definition at line 301 of file FontToolUtils.cpp.

{ FLAGS_nativeFonts = false; }