blob: c13dc7747403a94573505ea66f1fb43ef5069988 [file] [log] [blame]
/*
* Copyright 2010 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "src/gpu/ganesh/SkGr.h"
#include "include/core/SkAlphaType.h"
#include "include/core/SkBitmap.h"
#include "include/core/SkColorFilter.h"
#include "include/core/SkData.h"
#include "include/core/SkImageInfo.h"
#include "include/core/SkMatrix.h"
#include "include/core/SkPaint.h"
#include "include/core/SkPixelRef.h"
#include "include/core/SkPoint.h"
#include "include/core/SkRect.h"
#include "include/core/SkSize.h"
#include "include/effects/SkRuntimeEffect.h"
#include "include/gpu/GrBackendSurface.h"
#include "include/gpu/GrRecordingContext.h"
#include "include/private/SkIDChangeListener.h"
#include "include/private/base/SkTPin.h"
#include "include/private/gpu/ganesh/GrTypesPriv.h"
#include "src/core/SkBlendModePriv.h"
#include "src/core/SkBlenderBase.h"
#include "src/core/SkColorFilterBase.h"
#include "src/core/SkMaskFilterBase.h"
#include "src/core/SkMessageBus.h"
#include "src/core/SkPaintPriv.h"
#include "src/core/SkRuntimeEffectPriv.h"
#include "src/gpu/ResourceKey.h"
#include "src/gpu/Swizzle.h"
#include "src/gpu/ganesh/GrCaps.h"
#include "src/gpu/ganesh/GrColorInfo.h"
#include "src/gpu/ganesh/GrColorSpaceXform.h"
#include "src/gpu/ganesh/GrFPArgs.h"
#include "src/gpu/ganesh/GrFragmentProcessor.h"
#include "src/gpu/ganesh/GrPaint.h"
#include "src/gpu/ganesh/GrProxyProvider.h"
#include "src/gpu/ganesh/GrRecordingContextPriv.h"
#include "src/gpu/ganesh/GrSurfaceProxy.h"
#include "src/gpu/ganesh/GrSurfaceProxyView.h"
#include "src/gpu/ganesh/GrTextureProxy.h"
#include "src/gpu/ganesh/effects/GrSkSLFP.h"
#include "src/gpu/ganesh/effects/GrTextureEffect.h"
#include "src/shaders/SkShaderBase.h"
#include <optional>
#include <utility>
class SkBlender;
class SkColorSpace;
enum SkColorType : int;
void GrMakeKeyFromImageID(skgpu::UniqueKey* key, uint32_t imageID, const SkIRect& imageBounds) {
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;
}
////////////////////////////////////////////////////////////////////////////////
sk_sp<SkIDChangeListener> GrMakeUniqueKeyInvalidationListener(skgpu::UniqueKey* key,
uint32_t contextID) {
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 std::move(listener);
}
sk_sp<GrSurfaceProxy> GrCopyBaseMipMapToTextureProxy(GrRecordingContext* ctx,
sk_sp<GrSurfaceProxy> baseProxy,
GrSurfaceOrigin origin,
std::string_view label,
skgpu::Budgeted budgeted) {
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, GrMipmapped::kYes,
SkBackingFit::kExact, budgeted, label);
if (!copy) {
return nullptr;
}
SkASSERT(copy->asTextureProxy());
return copy;
}
GrSurfaceProxyView GrCopyBaseMipMapToView(GrRecordingContext* context,
GrSurfaceProxyView src,
skgpu::Budgeted budgeted) {
auto origin = src.origin();
auto swizzle = src.swizzle();
auto proxy = src.refProxy();
return {GrCopyBaseMipMapToTextureProxy(
context, proxy, origin, /*label=*/"CopyBaseMipMapToView", budgeted),
origin,
swizzle};
}
static GrMipmapped adjust_mipmapped(GrMipmapped mipmapped,
const SkBitmap& bitmap,
const GrCaps* caps) {
if (!caps->mipmapSupport() || bitmap.dimensions().area() <= 1) {
return GrMipmapped::kNo;
}
return mipmapped;
}
static GrColorType choose_bmp_texture_colortype(const GrCaps* caps, const SkBitmap& bitmap) {
GrColorType ct = SkColorTypeToGrColorType(bitmap.info().colorType());
if (caps->getDefaultBackendFormat(ct, GrRenderable::kNo).isValid()) {
return ct;
}
return GrColorType::kRGBA_8888;
}
static sk_sp<GrTextureProxy> make_bmp_proxy(GrProxyProvider* proxyProvider,
const SkBitmap& bitmap,
GrColorType ct,
GrMipmapped mipmapped,
SkBackingFit fit,
skgpu::Budgeted budgeted) {
SkBitmap bmpToUpload;
if (ct != SkColorTypeToGrColorType(bitmap.info().colorType())) {
SkColorType skCT = GrColorTypeToSkColorType(ct);
if (!bmpToUpload.tryAllocPixels(bitmap.info().makeColorType(skCT)) ||
!bitmap.readPixels(bmpToUpload.pixmap())) {
return {};
}
bmpToUpload.setImmutable();
} else {
bmpToUpload = bitmap;
}
auto proxy = proxyProvider->createProxyFromBitmap(bmpToUpload, mipmapped, fit, budgeted);
SkASSERT(!proxy || mipmapped == GrMipmapped::kNo || proxy->mipmapped() == GrMipmapped::kYes);
return proxy;
}
std::tuple<GrSurfaceProxyView, GrColorType>
GrMakeCachedBitmapProxyView(GrRecordingContext* rContext,
const SkBitmap& bitmap,
std::string_view label,
GrMipmapped mipmapped) {
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 == GrMipmapped::kNo || proxy->mipmapped() == GrMipmapped::kYes);
installKey(proxy.get());
}
skgpu::Swizzle swizzle = caps->getReadSwizzle(proxy->backendFormat(), ct);
if (mipmapped == GrMipmapped::kNo || proxy->mipmapped() == GrMipmapped::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};
}
std::tuple<GrSurfaceProxyView, GrColorType> GrMakeUncachedBitmapProxyView(
GrRecordingContext* rContext,
const SkBitmap& bitmap,
GrMipmapped mipmapped,
SkBackingFit fit,
skgpu::Budgeted budgeted) {
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 == GrMipmapped::kNo || proxy->mipmapped() == GrMipmapped::kYes);
return {{std::move(proxy), kTopLeft_GrSurfaceOrigin, swizzle}, ct};
}
return {};
}
///////////////////////////////////////////////////////////////////////////////
SkPMColor4f SkColorToPMColor4f(SkColor c, const GrColorInfo& colorInfo) {
SkColor4f color = SkColor4f::FromColor(c);
if (auto* xform = colorInfo.colorSpaceXformFromSRGB()) {
color = xform->apply(color);
}
return color.premul();
}
SkColor4f SkColor4fPrepForDst(SkColor4f color, const GrColorInfo& colorInfo) {
if (auto* xform = colorInfo.colorSpaceXformFromSRGB()) {
color = xform->apply(color);
}
return color;
}
///////////////////////////////////////////////////////////////////////////////
static inline bool blender_requires_shader(const SkBlender* blender) {
SkASSERT(blender);
std::optional<SkBlendMode> mode = as_BB(blender)->asBlendMode();
return !mode.has_value() || *mode != SkBlendMode::kDst;
}
#ifndef SK_IGNORE_GPU_DITHER
static inline float dither_range_for_config(GrColorType dstColorType) {
// We use 1 / (2^bitdepth-1) as the range since each channel can hold 2^bitdepth values
switch (dstColorType) {
// 4 bit
case GrColorType::kABGR_4444:
case GrColorType::kARGB_4444:
case GrColorType::kBGRA_4444:
return 1 / 15.f;
// 6 bit
case GrColorType::kBGR_565:
return 1 / 63.f;
// 8 bit
case GrColorType::kUnknown:
case GrColorType::kAlpha_8:
case GrColorType::kAlpha_8xxx:
case GrColorType::kGray_8:
case GrColorType::kGrayAlpha_88:
case GrColorType::kGray_8xxx:
case GrColorType::kR_8:
case GrColorType::kR_8xxx:
case GrColorType::kRG_88:
case GrColorType::kRGB_888:
case GrColorType::kRGB_888x:
case GrColorType::kRGBA_8888:
case GrColorType::kRGBA_8888_SRGB:
case GrColorType::kBGRA_8888:
return 1 / 255.f;
// 10 bit
case GrColorType::kRGBA_1010102:
case GrColorType::kBGRA_1010102:
return 1 / 1023.f;
// 16 bit
case GrColorType::kAlpha_16:
case GrColorType::kR_16:
case GrColorType::kRG_1616:
case GrColorType::kRGBA_16161616:
return 1 / 32767.f;
// Half
case GrColorType::kAlpha_F16:
case GrColorType::kGray_F16:
case GrColorType::kR_F16:
case GrColorType::kRG_F16:
case GrColorType::kRGBA_F16:
case GrColorType::kRGBA_F16_Clamped:
// Float
case GrColorType::kAlpha_F32xxx:
case GrColorType::kRGBA_F32:
return 0.f; // no dithering
}
SkUNREACHABLE;
}
static SkBitmap make_dither_lut() {
static constexpr struct DitherTable {
constexpr DitherTable() : data() {
for (int x = 0; x < 8; ++x) {
for (int y = 0; y < 8; ++y) {
// The computation of 'm' and 'value' is lifted from CPU backend.
unsigned int m = (y & 1) << 5 | (x & 1) << 4 |
(y & 2) << 2 | (x & 2) << 1 |
(y & 4) >> 1 | (x & 4) >> 2;
float value = float(m) * 1.0 / 64.0 - 63.0 / 128.0;
// Bias by 0.5 to be in 0..1, mul by 255 and round to nearest int to make byte.
data[y * 8 + x] = (uint8_t)((value + 0.5) * 255.f + 0.5f);
}
}
}
uint8_t data[64];
} gTable;
SkBitmap bmp;
bmp.setInfo(SkImageInfo::MakeA8(8, 8));
bmp.setPixels(const_cast<uint8_t*>(gTable.data));
bmp.setImmutable();
return bmp;
}
static std::unique_ptr<GrFragmentProcessor> make_dither_effect(
GrRecordingContext* rContext,
std::unique_ptr<GrFragmentProcessor> inputFP,
float range,
const GrCaps* caps) {
if (range == 0 || inputFP == nullptr) {
return inputFP;
}
if (caps->avoidDithering()) {
return inputFP;
}
// We used to use integer math on sk_FragCoord, when supported, and a fallback using floating
// point (on a 4x4 rather than 8x8 grid). Now we precompute a 8x8 table in a texture because
// it was shown to be significantly faster on several devices. Test was done with the following
// running in viewer with the stats layer enabled and looking at total frame time:
// SkRandom r;
// for (int i = 0; i < N; ++i) {
// SkColor c[2] = {r.nextU(), r.nextU()};
// SkPoint pts[2] = {{r.nextRangeScalar(0, 500), r.nextRangeScalar(0, 500)},
// {r.nextRangeScalar(0, 500), r.nextRangeScalar(0, 500)}};
// SkPaint p;
// p.setDither(true);
// p.setShader(SkGradientShader::MakeLinear(pts, c, nullptr, 2, SkTileMode::kRepeat));
// canvas->drawPaint(p);
// }
// Device GPU N no dither int math dither table dither
// Linux desktop QuadroP1000 5000 304ms 400ms (1.31x) 383ms (1.26x)
// TecnoSpark3Pro PowerVRGE8320 200 299ms 820ms (2.74x) 592ms (1.98x)
// Pixel 4 Adreno640 500 110ms 221ms (2.01x) 214ms (1.95x)
// Galaxy S20 FE Mali-G77 MP11 600 165ms 360ms (2.18x) 260ms (1.58x)
static const SkBitmap gLUT = make_dither_lut();
auto [tex, ct] = GrMakeCachedBitmapProxyView(
rContext, gLUT, /*label=*/"MakeDitherEffect", GrMipmapped::kNo);
if (!tex) {
return inputFP;
}
SkASSERT(ct == GrColorType::kAlpha_8);
GrSamplerState sampler(GrSamplerState::WrapMode::kRepeat, SkFilterMode::kNearest);
auto te = GrTextureEffect::Make(
std::move(tex), kPremul_SkAlphaType, SkMatrix::I(), sampler, *caps);
static const SkRuntimeEffect* effect = SkMakeRuntimeEffect(SkRuntimeEffect::MakeForShader,
"uniform half range;"
"uniform shader inputFP;"
"uniform shader table;"
"half4 main(float2 xy) {"
"half4 color = inputFP.eval(xy);"
"half value = table.eval(sk_FragCoord.xy).a - 0.5;" // undo the bias in the table
// For each color channel, add the random offset to the channel value and then clamp
// between 0 and alpha to keep the color premultiplied.
"return half4(clamp(color.rgb + value * range, 0.0, color.a), color.a);"
"}"
);
return GrSkSLFP::Make(effect, "Dither", /*inputFP=*/nullptr,
GrSkSLFP::OptFlags::kPreservesOpaqueInput,
"range", range,
"inputFP", std::move(inputFP),
"table", GrSkSLFP::IgnoreOptFlags(std::move(te)));
}
#endif
static inline bool skpaint_to_grpaint_impl(
GrRecordingContext* context,
const GrColorInfo& dstColorInfo,
const SkPaint& skPaint,
const SkMatrixProvider& matrixProvider,
std::optional<std::unique_ptr<GrFragmentProcessor>> shaderFP,
SkBlender* primColorBlender,
const SkSurfaceProps& surfaceProps,
GrPaint* grPaint) {
// Convert SkPaint color to 4f format in the destination color space
SkColor4f origColor = SkColor4fPrepForDst(skPaint.getColor4f(), dstColorInfo);
GrFPArgs fpArgs(context, matrixProvider, &dstColorInfo, surfaceProps);
// Setup the initial color considering the shader, the SkPaint color, and the presence or not
// of per-vertex colors.
std::unique_ptr<GrFragmentProcessor> paintFP;
const bool gpProvidesShader = shaderFP.has_value() && !*shaderFP;
if (!primColorBlender || blender_requires_shader(primColorBlender)) {
if (shaderFP.has_value()) {
paintFP = std::move(*shaderFP);
} else {
if (const SkShaderBase* shader = as_SB(skPaint.getShader())) {
paintFP = shader->asFragmentProcessor(fpArgs);
if (paintFP == nullptr) {
return false;
}
}
}
}
// Set this in below cases if the output of the shader/paint-color/paint-alpha/primXfermode is
// a known constant value. In that case we can simply apply a color filter during this
// conversion without converting the color filter to a GrFragmentProcessor.
bool applyColorFilterToPaintColor = false;
if (paintFP) {
if (primColorBlender) {
// There is a blend between the primitive color and the shader color. The shader sees
// the opaque paint color. The shader's output is blended using the provided mode by
// the primitive color. The blended color is then modulated by the paint's alpha.
// The geometry processor will insert the primitive color to start the color chain, so
// the GrPaint color will be ignored.
SkPMColor4f shaderInput = origColor.makeOpaque().premul();
paintFP = GrFragmentProcessor::OverrideInput(std::move(paintFP), shaderInput);
paintFP = as_BB(primColorBlender)->asFragmentProcessor(std::move(paintFP),
/*dstFP=*/nullptr,
fpArgs);
if (!paintFP) {
return false;
}
// We can ignore origColor here - alpha is unchanged by gamma
float paintAlpha = skPaint.getColor4f().fA;
if (1.0f != paintAlpha) {
// No gamut conversion - paintAlpha is a (linear) alpha value, splatted to all
// color channels. It's value should be treated as the same in ANY color space.
paintFP = GrFragmentProcessor::ModulateRGBA(
std::move(paintFP), {paintAlpha, paintAlpha, paintAlpha, paintAlpha});
}
} else {
float paintAlpha = skPaint.getColor4f().fA;
if (paintAlpha != 1.0f) {
// This invokes the shader's FP tree with an opaque version of the paint color,
// then multiplies the final result by the incoming (paint) alpha.
// We're actually putting the *unpremul* paint color on the GrPaint. This is okay,
// because the shader is supposed to see the original (opaque) RGB from the paint.
// ApplyPaintAlpha then creates a valid premul color by applying the paint alpha.
// Think of this as equivalent to (but faster than) putting origColor.premul() on
// the GrPaint, and ApplyPaintAlpha unpremuling it before passing it to the child.
paintFP = GrFragmentProcessor::ApplyPaintAlpha(std::move(paintFP));
grPaint->setColor4f({origColor.fR, origColor.fG, origColor.fB, origColor.fA});
} else {
// paintFP will ignore its input color, so we must disable coverage-as-alpha.
// TODO(skbug:11942): The alternative would be to always use ApplyPaintAlpha, but
// we'd need to measure the cost of that shader math against the CAA benefit.
paintFP = GrFragmentProcessor::DisableCoverageAsAlpha(std::move(paintFP));
grPaint->setColor4f(origColor.premul());
}
}
} else {
if (primColorBlender) {
// The primitive itself has color (e.g. interpolated vertex color) and this is what
// the GP will output. Thus, we must get the paint color in separately below as a color
// FP. This could be made more efficient if the relevant GPs used GrPaint color and
// took the SkBlender to apply with primitive color. As it stands changing the SkPaint
// color will break batches.
grPaint->setColor4f(SK_PMColor4fWHITE); // won't be used.
if (blender_requires_shader(primColorBlender)) {
paintFP = GrFragmentProcessor::MakeColor(origColor.makeOpaque().premul());
paintFP = as_BB(primColorBlender)->asFragmentProcessor(std::move(paintFP),
/*dstFP=*/nullptr,
fpArgs);
if (!paintFP) {
return false;
}
}
// The paint's *alpha* is applied after the paint/primitive color blend:
// We can ignore origColor here - alpha is unchanged by gamma
float paintAlpha = skPaint.getColor4f().fA;
if (paintAlpha != 1.0f) {
// No gamut conversion - paintAlpha is a (linear) alpha value, splatted to all
// color channels. It's value should be treated as the same in ANY color space.
paintFP = GrFragmentProcessor::ModulateRGBA(
std::move(paintFP), {paintAlpha, paintAlpha, paintAlpha, paintAlpha});
}
} else {
// No shader, no primitive color.
grPaint->setColor4f(origColor.premul());
// We can do this if there isn't a GP that is acting as the shader.
applyColorFilterToPaintColor = !gpProvidesShader;
}
}
SkColorFilter* colorFilter = skPaint.getColorFilter();
if (colorFilter) {
if (applyColorFilterToPaintColor) {
SkColorSpace* dstCS = dstColorInfo.colorSpace();
grPaint->setColor4f(colorFilter->filterColor4f(origColor, dstCS, dstCS).premul());
} else {
auto [success, fp] = as_CFB(colorFilter)->asFragmentProcessor(std::move(paintFP),
context, dstColorInfo,
surfaceProps);
if (!success) {
return false;
}
paintFP = std::move(fp);
}
}
SkMaskFilterBase* maskFilter = as_MFB(skPaint.getMaskFilter());
if (maskFilter) {
if (auto mfFP = maskFilter->asFragmentProcessor(fpArgs)) {
grPaint->setCoverageFragmentProcessor(std::move(mfFP));
}
}
#ifndef SK_IGNORE_GPU_DITHER
GrColorType ct = dstColorInfo.colorType();
if (SkPaintPriv::ShouldDither(skPaint, GrColorTypeToSkColorType(ct)) && paintFP != nullptr) {
float ditherRange = dither_range_for_config(ct);
paintFP = make_dither_effect(
context, std::move(paintFP), ditherRange, context->priv().caps());
}
#endif
// Note that for the final blend onto the canvas, we should prefer to use the GrXferProcessor
// instead of a SkBlendModeBlender to perform the blend. The Xfer processor is able to perform
// coefficient-based blends directly, without readback. This will be much more efficient.
if (auto bm = skPaint.asBlendMode()) {
// When the xfermode is null on the SkPaint (meaning kSrcOver) we need the XPFactory field
// on the GrPaint to also be null (also kSrcOver).
SkASSERT(!grPaint->getXPFactory());
if (bm.value() != SkBlendMode::kSrcOver) {
grPaint->setXPFactory(SkBlendMode_AsXPFactory(bm.value()));
}
} else {
// Apply a custom blend against the surface color, and force the XP to kSrc so that the
// computed result is applied directly to the canvas while still honoring the alpha.
paintFP = as_BB(skPaint.getBlender())->asFragmentProcessor(
std::move(paintFP),
GrFragmentProcessor::SurfaceColor(),
fpArgs);
if (!paintFP) {
return false;
}
grPaint->setXPFactory(SkBlendMode_AsXPFactory(SkBlendMode::kSrc));
}
if (GrColorTypeClampType(dstColorInfo.colorType()) == GrClampType::kManual) {
if (paintFP != nullptr) {
paintFP = GrFragmentProcessor::ClampOutput(std::move(paintFP));
} else {
auto color = grPaint->getColor4f();
grPaint->setColor4f({SkTPin(color.fR, 0.f, 1.f),
SkTPin(color.fG, 0.f, 1.f),
SkTPin(color.fB, 0.f, 1.f),
SkTPin(color.fA, 0.f, 1.f)});
}
}
if (paintFP) {
grPaint->setColorFragmentProcessor(std::move(paintFP));
}
return true;
}
bool SkPaintToGrPaint(GrRecordingContext* context,
const GrColorInfo& dstColorInfo,
const SkPaint& skPaint,
const SkMatrixProvider& matrixProvider,
const SkSurfaceProps& surfaceProps,
GrPaint* grPaint) {
return skpaint_to_grpaint_impl(context,
dstColorInfo,
skPaint,
matrixProvider,
/*shaderFP=*/std::nullopt,
/*primColorBlender=*/nullptr,
surfaceProps,
grPaint);
}
/** Replaces the SkShader (if any) on skPaint with the passed in GrFragmentProcessor. */
bool SkPaintToGrPaintReplaceShader(GrRecordingContext* context,
const GrColorInfo& dstColorInfo,
const SkPaint& skPaint,
const SkMatrixProvider& matrixProvider,
std::unique_ptr<GrFragmentProcessor> shaderFP,
const SkSurfaceProps& surfaceProps,
GrPaint* grPaint) {
return skpaint_to_grpaint_impl(context,
dstColorInfo,
skPaint,
matrixProvider,
std::move(shaderFP),
/*primColorBlender=*/nullptr,
surfaceProps,
grPaint);
}
/** 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. */
bool SkPaintToGrPaintWithBlend(GrRecordingContext* context,
const GrColorInfo& dstColorInfo,
const SkPaint& skPaint,
const SkMatrixProvider& matrixProvider,
SkBlender* primColorBlender,
const SkSurfaceProps& surfaceProps,
GrPaint* grPaint) {
return skpaint_to_grpaint_impl(context,
dstColorInfo,
skPaint,
matrixProvider,
/*shaderFP=*/std::nullopt,
primColorBlender,
surfaceProps,
grPaint);
}