SkGr.h File Reference

#include "include/core/SkBlendMode.h"
#include "include/core/SkColor.h"
#include "include/core/SkColorPriv.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkSamplingOptions.h"
#include "include/core/SkTileMode.h"
#include "include/core/SkTypes.h"
#include "include/gpu/GpuTypes.h"
#include "include/private/SkColorData.h"
#include "src/gpu/Blend.h"
#include "src/gpu/SkBackingFit.h"
#include "src/gpu/ganesh/GrColor.h"
#include "src/gpu/ganesh/GrSamplerState.h"
#include <cstdint>
#include <memory>
#include <string_view>
#include <tuple>

Go to the source code of this file.

Namespaces
namespace	skgpu

Enumerations
enum class	GrImageTexGenPolicy : int { kDraw , kNew_Uncached_Unbudgeted , kNew_Uncached_Budgeted }

Functions
static GrColor	SkColorToPremulGrColor (SkColor c)
static GrColor	SkColorToUnpremulGrColor (SkColor c)
SkPMColor4f	SkColorToPMColor4f (SkColor, const GrColorInfo &)
SkColor4f	SkColor4fPrepForDst (SkColor4f, const GrColorInfo &)
static constexpr GrSamplerState::WrapMode	SkTileModeToWrapMode (SkTileMode tileMode)
bool	SkPaintToGrPaint (GrRecordingContext *, const GrColorInfo &dstColorInfo, const SkPaint &skPaint, const SkMatrix &ctm, const SkSurfaceProps &surfaceProps, GrPaint *grPaint)
bool	SkPaintToGrPaintReplaceShader (GrRecordingContext *, const GrColorInfo &dstColorInfo, const SkPaint &skPaint, const SkMatrix &ctm, std::unique_ptr< GrFragmentProcessor > shaderFP, const SkSurfaceProps &surfaceProps, GrPaint *grPaint)
bool	SkPaintToGrPaintWithBlend (GrRecordingContext *context, const GrColorInfo &dstColorInfo, const SkPaint &skPaint, const SkMatrix &ctm, SkBlender *primColorBlender, const SkSurfaceProps &surfaceProps, GrPaint *grPaint)
sk_sp< GrSurfaceProxy >	GrCopyBaseMipMapToTextureProxy (GrRecordingContext *, sk_sp< GrSurfaceProxy > baseProxy, GrSurfaceOrigin origin, std::string_view label, skgpu::Budgeted=skgpu::Budgeted::kYes)
GrSurfaceProxyView	GrCopyBaseMipMapToView (GrRecordingContext *, GrSurfaceProxyView, skgpu::Budgeted=skgpu::Budgeted::kYes)
std::tuple< GrSurfaceProxyView, GrColorType >	GrMakeCachedBitmapProxyView (GrRecordingContext *, const SkBitmap &, std::string_view label, skgpu::Mipmapped=skgpu::Mipmapped::kNo)
std::tuple< GrSurfaceProxyView, GrColorType >	GrMakeUncachedBitmapProxyView (GrRecordingContext *, const SkBitmap &, skgpu::Mipmapped=skgpu::Mipmapped::kNo, SkBackingFit=SkBackingFit::kExact, skgpu::Budgeted=skgpu::Budgeted::kYes)
void	GrMakeKeyFromImageID (skgpu::UniqueKey *key, uint32_t imageID, const SkIRect &imageBounds)
sk_sp< SkIDChangeListener >	GrMakeUniqueKeyInvalidationListener (skgpu::UniqueKey *, uint32_t contextID)
static bool	GrValidCubicResampler (SkCubicResampler cubic)

Enumeration Type Documentation

GrImageTexGenPolicy

enum class GrImageTexGenPolicy : int

strong

Policies for how to create textures for SkImages (and SkBitmaps).

Enumerator
kDraw
kNew_Uncached_Unbudgeted
kNew_Uncached_Budgeted

Definition at line 141 of file SkGr.h.

                               : int {
    // Choose the cheapest way to generate the texture. Use GrResourceCache if appropriate.
    kDraw,
    // Always make a new texture that is uncached and unbudgeted.
    kNew_Uncached_Unbudgeted,
    // Always make a new texture that is uncached and budgeted.
    kNew_Uncached_Budgeted
};

Function Documentation

GrCopyBaseMipMapToTextureProxy()

sk_sp< GrSurfaceProxy > GrCopyBaseMipMapToTextureProxy	(	GrRecordingContext *	ctx,
		sk_sp< GrSurfaceProxy >	baseProxy,
		GrSurfaceOrigin	origin,
		std::string_view	label,
		skgpu::Budgeted	budgeted = skgpu::Budgeted::kYes
	)

Creates a new texture with mipmap levels and copies the baseProxy into the base layer.

Definition at line 107 of file SkGr.cpp.

                                                                             {
    SkASSERT(baseProxy);
 
    // We don't allow this for promise proxies i.e. if they need mips they need to give them
    // to us upfront.
    if (baseProxy->isPromiseProxy()) {
        return nullptr;
    }
    if (!ctx->priv().caps()->isFormatCopyable(baseProxy->backendFormat())) {
        return nullptr;
    }
    auto copy = GrSurfaceProxy::Copy(ctx,
                                     std::move(baseProxy),
                                     origin,
                                     skgpu::Mipmapped::kYes,
                                     SkBackingFit::kExact,
                                     budgeted,
                                     label);
    if (!copy) {
        return nullptr;
    }
    SkASSERT(copy->asTextureProxy());
    return copy;
}

GrCopyBaseMipMapToView()

GrSurfaceProxyView GrCopyBaseMipMapToView	(	GrRecordingContext *	context,
		GrSurfaceProxyView	src,
		skgpu::Budgeted	budgeted = skgpu::Budgeted::kYes
	)

Same as GrCopyBaseMipMapToTextureProxy but takes the src as a view and returns a view with same origin and swizzle as the src view.

Definition at line 136 of file SkGr.cpp.

                                                                  {
    auto origin = src.origin();
    auto swizzle = src.swizzle();
    auto proxy = src.refProxy();
    return {GrCopyBaseMipMapToTextureProxy(
                    context, proxy, origin, /*label=*/"CopyBaseMipMapToView", budgeted),
            origin,
            swizzle};
}

GrMakeCachedBitmapProxyView()

std::tuple< GrSurfaceProxyView, GrColorType > GrMakeCachedBitmapProxyView	(	GrRecordingContext *	rContext,
		const SkBitmap &	bitmap,
		std::string_view	label,
		skgpu::Mipmapped	mipmapped = skgpu::Mipmapped::kNo
	)

Definition at line 188 of file SkGr.cpp.

                                  {
    if (!bitmap.peekPixels(nullptr)) {
        return {};
    }
 
    GrProxyProvider* proxyProvider = rContext->priv().proxyProvider();
    const GrCaps* caps = rContext->priv().caps();
 
    skgpu::UniqueKey key;
    SkIPoint origin = bitmap.pixelRefOrigin();
    SkIRect subset = SkIRect::MakePtSize(origin, bitmap.dimensions());
    GrMakeKeyFromImageID(&key, bitmap.pixelRef()->getGenerationID(), subset);
 
    mipmapped = adjust_mipmapped(mipmapped, bitmap, caps);
    GrColorType ct = choose_bmp_texture_colortype(caps, bitmap);
 
    auto installKey = [&](GrTextureProxy* proxy) {
        auto listener = GrMakeUniqueKeyInvalidationListener(&key, proxyProvider->contextID());
        bitmap.pixelRef()->addGenIDChangeListener(std::move(listener));
        proxyProvider->assignUniqueKeyToProxy(key, proxy);
    };
 
    sk_sp<GrTextureProxy> proxy = proxyProvider->findOrCreateProxyByUniqueKey(key);
    if (!proxy) {
        proxy = make_bmp_proxy(
                proxyProvider, bitmap, ct, mipmapped, SkBackingFit::kExact, skgpu::Budgeted::kYes);
        if (!proxy) {
            return {};
        }
        SkASSERT(mipmapped == skgpu::Mipmapped::kNo ||
                 proxy->mipmapped() == skgpu::Mipmapped::kYes);
        installKey(proxy.get());
    }
 
    skgpu::Swizzle swizzle = caps->getReadSwizzle(proxy->backendFormat(), ct);
    if (mipmapped == skgpu::Mipmapped::kNo || proxy->mipmapped() == skgpu::Mipmapped::kYes) {
        return {{std::move(proxy), kTopLeft_GrSurfaceOrigin, swizzle}, ct};
    }
 
    // We need a mipped proxy, but we found a proxy earlier that wasn't mipped. Thus we generate
    // a new mipped surface and copy the original proxy into the base layer. We will then let
    // the gpu generate the rest of the mips.
    auto mippedProxy = GrCopyBaseMipMapToTextureProxy(
            rContext, proxy, kTopLeft_GrSurfaceOrigin, /*label=*/"MakeCachedBitmapProxyView");
    if (!mippedProxy) {
        // We failed to make a mipped proxy with the base copied into it. This could have
        // been from failure to make the proxy or failure to do the copy. Thus we will fall
        // back to just using the non mipped proxy; See skbug.com/7094.
        return {{std::move(proxy), kTopLeft_GrSurfaceOrigin, swizzle}, ct};
    }
    // In this case we are stealing the key from the original proxy which should only happen
    // when we have just generated mipmaps for an originally unmipped proxy/texture. This
    // means that all future uses of the key will access the mipmapped version. The texture
    // backing the unmipped version will remain in the resource cache until the last texture
    // proxy referencing it is deleted at which time it too will be deleted or recycled.
    SkASSERT(proxy->getUniqueKey() == key);
    proxyProvider->removeUniqueKeyFromProxy(proxy.get());
    installKey(mippedProxy->asTextureProxy());
    return {{std::move(mippedProxy), kTopLeft_GrSurfaceOrigin, swizzle}, ct};
}

GrMakeKeyFromImageID()

void GrMakeKeyFromImageID	(	skgpu::UniqueKey *	key,
		uint32_t	imageID,
		const SkIRect &	imageBounds
	)

Our key includes the offset, width, and height so that bitmaps created by extractSubset() are unique.

The imageID is in the shared namespace (see SkNextID::ImageID())

• SkBitmap/SkPixelRef
• SkImage
• SkImageGenerator

Definition at line 60 of file SkGr.cpp.

                                                                                             {
    SkASSERT(key);
    SkASSERT(imageID);
    SkASSERT(!imageBounds.isEmpty());
    static const skgpu::UniqueKey::Domain kImageIDDomain = skgpu::UniqueKey::GenerateDomain();
    skgpu::UniqueKey::Builder builder(key, kImageIDDomain, 5, "Image");
    builder[0] = imageID;
    builder[1] = imageBounds.fLeft;
    builder[2] = imageBounds.fTop;
    builder[3] = imageBounds.fRight;
    builder[4] = imageBounds.fBottom;
}

GrMakeUncachedBitmapProxyView()

std::tuple< GrSurfaceProxyView, GrColorType > GrMakeUncachedBitmapProxyView	(	GrRecordingContext *	rContext,
		const SkBitmap &	bitmap,
		skgpu::Mipmapped	mipmapped = skgpu::Mipmapped::kNo,
		SkBackingFit	fit = SkBackingFit::kExact,
		skgpu::Budgeted	budgeted = skgpu::Budgeted::kYes
	)

Like above but always uploads the bitmap and never inserts into the cache. Unlike above, the texture may be approx or scratch and budgeted or not.

Definition at line 253 of file SkGr.cpp.

                                {
    GrProxyProvider* proxyProvider = rContext->priv().proxyProvider();
    const GrCaps* caps = rContext->priv().caps();
 
    mipmapped = adjust_mipmapped(mipmapped, bitmap, caps);
    GrColorType ct = choose_bmp_texture_colortype(caps, bitmap);
 
    if (auto proxy = make_bmp_proxy(proxyProvider, bitmap, ct, mipmapped, fit, budgeted)) {
        skgpu::Swizzle swizzle = caps->getReadSwizzle(proxy->backendFormat(), ct);
        SkASSERT(mipmapped == skgpu::Mipmapped::kNo ||
                 proxy->mipmapped() == skgpu::Mipmapped::kYes);
        return {{std::move(proxy), kTopLeft_GrSurfaceOrigin, swizzle}, ct};
    }
    return {};
}

GrMakeUniqueKeyInvalidationListener()

sk_sp< SkIDChangeListener > GrMakeUniqueKeyInvalidationListener	(	skgpu::UniqueKey *	key,
		uint32_t	contextID
	)

Makes a SkIDChangeListener from a skgpu::UniqueKey. The key will be invalidated in the resource cache if the ID becomes invalid. This also modifies the key so that it will cause the listener to be deregistered if the key is destroyed (to prevent unbounded listener growth when resources are purged before listeners trigger).

Definition at line 75 of file SkGr.cpp.

                                                                                  {
    class Listener : public SkIDChangeListener {
    public:
        Listener(const skgpu::UniqueKey& key, uint32_t contextUniqueID)
                : fMsg(key, contextUniqueID) {}
 
        void changed() override {
            SkMessageBus<skgpu::UniqueKeyInvalidatedMessage, uint32_t>::Post(fMsg);
        }
 
    private:
        skgpu::UniqueKeyInvalidatedMessage fMsg;
    };
 
    auto listener = sk_make_sp<Listener>(*key, contextID);
 
    // We stick a SkData on the key that calls invalidateListener in its destructor.
    auto invalidateListener = [](const void* ptr, void* /*context*/) {
        auto listener = reinterpret_cast<const sk_sp<Listener>*>(ptr);
        (*listener)->markShouldDeregister();
        delete listener;
    };
    auto data = SkData::MakeWithProc(new sk_sp<Listener>(listener),
                                     sizeof(sk_sp<Listener>),
                                     invalidateListener,
                                     nullptr);
    SkASSERT(!key->getCustomData());
    key->setCustomData(std::move(data));
    return listener;
}

GrValidCubicResampler()

static bool GrValidCubicResampler ( SkCubicResampler  cubic )

inlinestatic

Definition at line 211 of file SkGr.h.

                                                                 {
    return cubic.B >= 0 && cubic.C >= 0;
}

SkColor4fPrepForDst()

SkColor4f SkColor4fPrepForDst	(	SkColor4f	color,
		const GrColorInfo &	colorInfo
	)

Converts an SkColor4f to the destination color space.

Definition at line 283 of file SkGr.cpp.

                                                                             {
    if (auto* xform = colorInfo.colorSpaceXformFromSRGB()) {
        color = xform->apply(color);
    }
    return color;
}

SkColorToPMColor4f()

SkPMColor4f SkColorToPMColor4f	(	SkColor	c,
		const GrColorInfo &	colorInfo
	)

Similar, but using SkPMColor4f.

Definition at line 275 of file SkGr.cpp.

                                                                        {
    SkColor4f color = SkColor4f::FromColor(c);
    if (auto* xform = colorInfo.colorSpaceXformFromSRGB()) {
        color = xform->apply(color);
    }
    return color.premul();
}

SkColorToPremulGrColor()

static GrColor SkColorToPremulGrColor ( SkColor  c )

inlinestatic

Definition at line 51 of file SkGr.h.

                                                        {
    SkPMColor pm = SkPreMultiplyColor(c);
    unsigned r = SkGetPackedR32(pm);
    unsigned g = SkGetPackedG32(pm);
    unsigned b = SkGetPackedB32(pm);
    unsigned a = SkGetPackedA32(pm);
    return GrColorPackRGBA(r, g, b, a);
}

SkColorToUnpremulGrColor()

static GrColor SkColorToUnpremulGrColor ( SkColor  c )

inlinestatic

Definition at line 60 of file SkGr.h.

                                                          {
    unsigned r = SkColorGetR(c);
    unsigned g = SkColorGetG(c);
    unsigned b = SkColorGetB(c);
    unsigned a = SkColorGetA(c);
    return GrColorPackRGBA(r, g, b, a);
}

SkPaintToGrPaint()

bool SkPaintToGrPaint	(	GrRecordingContext *	context,
		const GrColorInfo &	dstColorInfo,
		const SkPaint &	skPaint,
		const SkMatrix &	ctm,
		const SkSurfaceProps &	surfaceProps,
		GrPaint *	grPaint
	)

Converts an SkPaint to a GrPaint for a given GrRecordingContext. The matrix is required in order to convert the SkShader (if any) on the SkPaint. The primitive itself has no color.

Definition at line 553 of file SkGr.cpp.

                                        {
    return skpaint_to_grpaint_impl(context,
                                   dstColorInfo,
                                   skPaint,
                                   ctm,
                                   /*shaderFP=*/std::nullopt,
                                   /*primColorBlender=*/nullptr,
                                   surfaceProps,
                                   grPaint);
}

SkPaintToGrPaintReplaceShader()

bool SkPaintToGrPaintReplaceShader	(	GrRecordingContext *	context,
		const GrColorInfo &	dstColorInfo,
		const SkPaint &	skPaint,
		const SkMatrix &	ctm,
		std::unique_ptr< GrFragmentProcessor >	shaderFP,
		const SkSurfaceProps &	surfaceProps,
		GrPaint *	grPaint
	)

Replaces the SkShader (if any) on skPaint with the passed in GrFragmentProcessor, if not null. If null then it is assumed that the geometry processor is implementing a shader replacement. The processor should expect an unpremul input color and produce a premultiplied output color.

Replaces the SkShader (if any) on skPaint with the passed in GrFragmentProcessor.

Definition at line 570 of file SkGr.cpp.

                                                     {
    return skpaint_to_grpaint_impl(context,
                                   dstColorInfo,
                                   skPaint,
                                   ctm,
                                   std::move(shaderFP),
                                   /*primColorBlender=*/nullptr,
                                   surfaceProps,
                                   grPaint);
}

SkPaintToGrPaintWithBlend()

bool SkPaintToGrPaintWithBlend	(	GrRecordingContext *	context,
		const GrColorInfo &	dstColorInfo,
		const SkPaint &	skPaint,
		const SkMatrix &	ctm,
		SkBlender *	primColorBlender,
		const SkSurfaceProps &	surfaceProps,
		GrPaint *	grPaint
	)

Blends the SkPaint's shader (or color if no shader) with the color which specified via a GrOp's GrPrimitiveProcesssor.

Blends the SkPaint's shader (or color if no shader) with a per-primitive color which must be setup as a vertex attribute using the specified SkBlender.

Definition at line 589 of file SkGr.cpp.

                                                 {
    return skpaint_to_grpaint_impl(context,
                                   dstColorInfo,
                                   skPaint,
                                   ctm,
                                   /*shaderFP=*/std::nullopt,
                                   primColorBlender,
                                   surfaceProps,
                                   grPaint);
}

SkTileModeToWrapMode()

static constexpr GrSamplerState::WrapMode SkTileModeToWrapMode ( SkTileMode  tileMode )

staticconstexpr

Definition at line 77 of file SkGr.h.

                                                                                  {
    switch (tileMode) {
        case SkTileMode::kClamp:  return GrSamplerState::WrapMode::kClamp;
        case SkTileMode::kDecal:  return GrSamplerState::WrapMode::kClampToBorder;
        case SkTileMode::kMirror: return GrSamplerState::WrapMode::kMirrorRepeat;
        case SkTileMode::kRepeat: return GrSamplerState::WrapMode::kRepeat;
    }
    SkUNREACHABLE;
}