| /* | |
| * Copyright 2022 Google LLC | |
| * | |
| * Use of this source code is governed by a BSD-style license that can be | |
| * found in the LICENSE file. | |
| */ | |
| #include "src/gpu/graphite/PaintParams.h" | |
| #include "include/core/SkColorSpace.h" | |
| #include "include/core/SkShader.h" | |
| #include "src/core/SkBlendModeBlender.h" | |
| #include "src/core/SkBlenderBase.h" | |
| #include "src/core/SkColorSpacePriv.h" | |
| #include "src/effects/colorfilters/SkColorFilterBase.h" | |
| #include "src/gpu/Blend.h" | |
| #include "src/gpu/DitherUtils.h" | |
| #include "src/gpu/graphite/ContextUtils.h" | |
| #include "src/gpu/graphite/KeyContext.h" | |
| #include "src/gpu/graphite/KeyHelpers.h" | |
| #include "src/gpu/graphite/PaintParamsKey.h" | |
| #include "src/gpu/graphite/PipelineData.h" | |
| #include "src/gpu/graphite/RecorderPriv.h" | |
| namespace skgpu::graphite { | |
| namespace { | |
| // This should be kept in sync w/ SkPaintPriv::ShouldDither and PaintOption::shouldDither | |
| bool should_dither(const PaintParams& p, SkColorType dstCT) { | |
| // The paint dither flag can veto. | |
| if (!p.dither()) { | |
| return false; | |
| } | |
| if (dstCT == kUnknown_SkColorType) { | |
| return false; | |
| } | |
| // We always dither 565 or 4444 when requested. | |
| if (dstCT == kRGB_565_SkColorType || dstCT == kARGB_4444_SkColorType) { | |
| return true; | |
| } | |
| // Otherwise, dither is only needed for non-const paints. | |
| return p.shader() && !as_SB(p.shader())->isConstant(); | |
| } | |
| bool blendmode_depends_on_dst(SkBlendMode blendMode, bool srcIsOpaque) { | |
| if (blendMode == SkBlendMode::kSrc || blendMode == SkBlendMode::kClear) { | |
| // src and clear blending never depends on dst | |
| return false; | |
| } | |
| if (blendMode == SkBlendMode::kSrcOver || blendMode == SkBlendMode::kDstOut) { | |
| // src-over depends on dst if src is transparent (a != 1) | |
| // dst-out simplifies to kClear if a == 1 | |
| return !srcIsOpaque; | |
| } | |
| return true; | |
| } | |
| std::pair<const SkBlender*, SkBlendMode> get_final_blend(const SkBlender* blender) { | |
| if (!blender) { | |
| return {nullptr, SkBlendMode::kSrcOver}; | |
| } | |
| auto optionalBlendMode = as_BB(blender)->asBlendMode(); | |
| if (optionalBlendMode.has_value()) { | |
| return {nullptr, *optionalBlendMode}; | |
| } else { | |
| return {blender, SkBlendMode::kSrc}; | |
| } | |
| } | |
| Coverage get_renderer_coverage(Coverage coverage, | |
| const SkShader* clipShader, | |
| const NonMSAAClip& nonMSAAClip) { | |
| return (clipShader || !nonMSAAClip.isEmpty()) && coverage == Coverage::kNone ? | |
| Coverage::kSingleChannel : coverage; | |
| } | |
| SkEnumBitMask<DstUsage> get_dst_usage(const Caps* caps, | |
| TextureFormat targetFormat, | |
| const PaintParams& paint, | |
| Coverage rendererCoverage) { | |
| if (paint.finalBlender()) { | |
| return DstUsage::kDstReadRequired; | |
| } | |
| SkBlendMode finalBlendMode = paint.finalBlendMode(); | |
| SkEnumBitMask<DstUsage> dstUsage = | |
| CanUseHardwareBlending(caps, targetFormat, finalBlendMode, rendererCoverage) | |
| ? DstUsage::kNone | |
| : DstUsage::kDstReadRequired; | |
| if (finalBlendMode > SkBlendMode::kLastCoeffMode) { | |
| dstUsage |= DstUsage::kAdvancedBlend; | |
| } | |
| return dstUsage; | |
| } | |
| } // anonymous namespace | |
| PaintParams::PaintParams(const SkPaint& paint, | |
| const SkBlender* primitiveBlender, | |
| bool skipColorXform, | |
| bool ignoreShader) | |
| : fColor(paint.getColor4f()) | |
| , fFinalBlend(get_final_blend(paint.getBlender())) | |
| , fShader(ignoreShader ? nullptr : paint.getShader()) | |
| , fColorFilter(paint.getColorFilter()) | |
| , fPrimitiveBlender(primitiveBlender) | |
| , fSkipColorXform(skipColorXform) | |
| , fDither(paint.isDither()) { | |
| if (!fPrimitiveBlender) { | |
| SkColor4f constantColor; // if filled in, will be un-premul sRGB | |
| // fColor is un-premul sRGB | |
| if (fShader && as_SB(fShader)->isConstant(&constantColor)) { | |
| float origA = fColor.fA; | |
| fColor = constantColor; | |
| fColor.fA *= origA; | |
| fShader = nullptr; | |
| } | |
| if (!fShader && fColorFilter) { | |
| fColor = fColorFilter->filterColor4f(fColor, | |
| sk_srgb_singleton(), | |
| sk_srgb_singleton()); | |
| fColorFilter = nullptr; | |
| } | |
| } | |
| } | |
| PaintParams::PaintParams(const SkColor4f& color, SkBlendMode finalBlendMode) | |
| : fColor(color) | |
| , fFinalBlend({nullptr, finalBlendMode}) | |
| , fShader(nullptr) | |
| , fColorFilter(nullptr) | |
| , fPrimitiveBlender(nullptr) | |
| , fSkipColorXform(false) | |
| , fDither(false) {} | |
| SkColor4f PaintParams::Color4fPrepForDst(SkColor4f srcColor, const SkColorInfo& dstColorInfo) { | |
| // xform from sRGB to the destination colorspace | |
| SkColorSpaceXformSteps steps(sk_srgb_singleton(), kUnpremul_SkAlphaType, | |
| dstColorInfo.colorSpace(), kUnpremul_SkAlphaType); | |
| SkColor4f result = srcColor; | |
| steps.apply(result.vec()); | |
| return result; | |
| } | |
| /////////////////////////////////////////////////////////////////////////////////////////////////// | |
| ShadingParams::ShadingParams(const Caps* caps, | |
| const PaintParams& paint, | |
| const NonMSAAClip& nonMSAAClip, | |
| const SkShader* clipShader, | |
| Coverage coverage, | |
| TextureFormat targetFormat) | |
| : fPaint(paint) | |
| , fNonMSAAClip(nonMSAAClip) | |
| , fClipShader(clipShader) | |
| , fRendererCoverage(get_renderer_coverage(coverage, fClipShader, fNonMSAAClip)) | |
| , fTargetFormat(targetFormat) | |
| , fDstUsage(get_dst_usage(caps, fTargetFormat, paint, fRendererCoverage)) {} | |
| bool ShadingParams::addPaintColorToKey(const KeyContext& keyContext) const { | |
| if (fPaint.shader()) { | |
| AddToKey(keyContext, fPaint.shader()); | |
| return fPaint.shader()->isOpaque(); | |
| } else { | |
| RGBPaintColorBlock::AddBlock(keyContext); | |
| return true; // rgb1, always opaque | |
| } | |
| } | |
| /** | |
| * Primitive blend blocks are used to blend either the paint color or the output of another shader | |
| * with a primitive color emitted by certain draw geometry calls (drawVertices, drawAtlas, etc.). | |
| * Dst: primitiveColor Src: Paint color/shader output | |
| */ | |
| bool ShadingParams::handlePrimitiveColor(const KeyContext& keyContext) const { | |
| // If no primitive blending is required, simply add the paint color. | |
| if (!fPaint.primitiveBlender()) { | |
| return this->addPaintColorToKey(keyContext); | |
| } | |
| // If no color space conversion is required and the primitive blend mode is kDst, the src | |
| // branch of the blend does not matter and we can simply emit the primitive color. | |
| std::optional<SkBlendMode> primBlend = as_BB(fPaint.primitiveBlender())->asBlendMode(); | |
| const bool canSkipBlendStep = fPaint.skipPrimitiveColorXform() && | |
| primBlend == SkBlendMode::kDst; | |
| if (canSkipBlendStep) { | |
| AddPrimitiveColor(keyContext, fPaint.skipPrimitiveColorXform()); | |
| return false; | |
| } | |
| bool srcIsOpaque = false; | |
| Blend(keyContext, | |
| /* addBlendToKey= */ [&] () -> void { | |
| AddToKey(keyContext, fPaint.primitiveBlender()); | |
| }, | |
| /* addSrcToKey= */ [&] () -> void { | |
| srcIsOpaque = this->addPaintColorToKey(keyContext); | |
| }, | |
| /* addDstToKey= */ [&] () -> void { | |
| AddPrimitiveColor(keyContext, fPaint.skipPrimitiveColorXform()); | |
| }); | |
| if (primBlend.has_value() && srcIsOpaque) { | |
| // If the input paint/shader is opaque, the result is only opaque if the primitive blend | |
| // mode is kSrc or kSrcOver. All other modes can introduce transparency. | |
| return *primBlend == SkBlendMode::kSrc || *primBlend == SkBlendMode::kSrcOver; | |
| } | |
| // If the input was already transparent, or if it's a runtime/complex blend mode, | |
| // the result cannot be considered opaque. | |
| return false; | |
| } | |
| // Apply the paint's alpha value. | |
| bool ShadingParams::handlePaintAlpha(const KeyContext& keyContext) const { | |
| if (!fPaint.shader() && !fPaint.primitiveBlender()) { | |
| // If there is no shader and no primitive blending the input to the colorFilter stage | |
| // is just the premultiplied paint color. | |
| SkPMColor4f paintColor = PaintParams::Color4fPrepForDst(fPaint.color(), | |
| keyContext.dstColorInfo()).premul(); | |
| SolidColorShaderBlock::AddBlock(keyContext, paintColor); | |
| return fPaint.color().isOpaque(); | |
| } | |
| if (!fPaint.color().isOpaque()) { | |
| Blend(keyContext, | |
| /* addBlendToKey= */ [&] () -> void { | |
| AddFixedBlendMode(keyContext, SkBlendMode::kSrcIn); | |
| }, | |
| /* addSrcToKey= */ [&]() -> void { | |
| this->handlePrimitiveColor(keyContext); | |
| }, | |
| /* addDstToKey= */ [&]() -> void { | |
| AlphaOnlyPaintColorBlock::AddBlock(keyContext); | |
| }); | |
| // The result is guaranteed to be non-opaque because we're blending with fColor's alpha. | |
| return false; | |
| } else { | |
| return this->handlePrimitiveColor(keyContext); | |
| } | |
| } | |
| bool ShadingParams::handleColorFilter(const KeyContext& keyContext) const { | |
| if (fPaint.colorFilter()) { | |
| bool srcIsOpaque = false; | |
| Compose(keyContext, | |
| /* addInnerToKey= */ [&]() -> void { | |
| srcIsOpaque = this->handlePaintAlpha(keyContext); | |
| }, | |
| /* addOuterToKey= */ [&]() -> void { | |
| AddToKey(keyContext, fPaint.colorFilter()); | |
| }); | |
| return srcIsOpaque && fPaint.colorFilter()->isAlphaUnchanged(); | |
| } else { | |
| return this->handlePaintAlpha(keyContext); | |
| } | |
| } | |
| bool ShadingParams::handleDithering(const KeyContext& keyContext) const { | |
| #ifndef SK_IGNORE_GPU_DITHER | |
| SkColorType ct = keyContext.dstColorInfo().colorType(); | |
| if (should_dither(fPaint, ct)) { | |
| bool srcIsOpaque = false; | |
| Compose(keyContext, | |
| /* addInnerToKey= */ [&]() -> void { | |
| srcIsOpaque = this->handleColorFilter(keyContext); | |
| }, | |
| /* addOuterToKey= */ [&]() -> void { | |
| AddDitherBlock(keyContext, ct); | |
| }); | |
| return srcIsOpaque; | |
| } else | |
| #endif | |
| { | |
| return this->handleColorFilter(keyContext); | |
| } | |
| } | |
| void ShadingParams::handleClipping(const KeyContext& keyContext) const { | |
| if (!fNonMSAAClip.isEmpty()) { | |
| const AnalyticClip& analyticClip = fNonMSAAClip.fAnalyticClip; | |
| SkPoint radiusPair; | |
| SkRect analyticBounds; | |
| if (!analyticClip.isEmpty()) { | |
| float radius = analyticClip.fRadius + 0.5f; | |
| // N.B.: Because the clip data is normally used with depth-based clipping, | |
| // the shape is inverted from its usual state. We re-invert here to | |
| // match what the shader snippet expects. | |
| radiusPair = {(analyticClip.fInverted) ? radius : -radius, 1.0f/radius}; | |
| analyticBounds = analyticClip.fBounds.makeOutset(0.5f).asSkRect(); | |
| } else { | |
| // This will generate no analytic clip. | |
| radiusPair = { -0.5f, 1.f }; | |
| analyticBounds = { 0, 0, 0, 0 }; | |
| } | |
| const AtlasClip& atlasClip = fNonMSAAClip.fAtlasClip; | |
| SkISize maskSize = atlasClip.fMaskBounds.size(); | |
| SkRect texMaskBounds = SkRect::MakeXYWH(atlasClip.fOutPos.x(), atlasClip.fOutPos.y(), | |
| maskSize.width(), maskSize.height()); | |
| // Outset bounds to capture some of the padding (necessary for inverse clip) | |
| texMaskBounds.outset(0.5f, 0.5f); | |
| SkPoint texCoordOffset = SkPoint::Make(atlasClip.fOutPos.x() - atlasClip.fMaskBounds.left(), | |
| atlasClip.fOutPos.y() - atlasClip.fMaskBounds.top()); | |
| NonMSAAClipBlock::NonMSAAClipData data( | |
| analyticBounds, | |
| radiusPair, | |
| analyticClip.edgeSelectRect(), | |
| texCoordOffset, | |
| texMaskBounds, | |
| atlasClip.fAtlasTexture); | |
| if (fClipShader) { | |
| // For both an analytic clip and clip shader, we need to compose them together into | |
| // a single clipping root node. | |
| Blend(keyContext, | |
| /* addBlendToKey= */ [&]() -> void { | |
| AddFixedBlendMode(keyContext, SkBlendMode::kModulate); | |
| }, | |
| /* addSrcToKey= */ [&]() -> void { | |
| NonMSAAClipBlock::AddBlock(keyContext, data); | |
| }, | |
| /* addDstToKey= */ [&]() -> void { | |
| AddToKey(keyContext, fClipShader); | |
| }); | |
| } else { | |
| // Without a clip shader, the analytic clip can be the clipping root node. | |
| NonMSAAClipBlock::AddBlock(keyContext, data); | |
| } | |
| } else if (fClipShader) { | |
| // Since there's no analytic clip, the clipping root node can be fClipShader directly. | |
| AddToKey(keyContext, fClipShader); | |
| } | |
| } | |
| std::optional<ShadingParams::Result> ShadingParams::toKey(const KeyContext& keyContext) const { | |
| // Root Node 0 is the source color, which is the output of all effects post dithering | |
| bool isOpaque = this->handleDithering(keyContext); | |
| // Root Node 1 is the final blender | |
| bool dependsOnDst = fRendererCoverage != Coverage::kNone; | |
| if (fPaint.finalBlender()) { | |
| AddToKey(keyContext, fPaint.finalBlender()); | |
| // Cannot inspect runtime blenders to pessimistically assume they will always use the dst. | |
| dependsOnDst = true; | |
| } else { | |
| if (!(fDstUsage & DstUsage::kDstReadRequired)) { | |
| // With no shader blending, be as explicit as possible about the final blend | |
| AddFixedBlendMode(keyContext, fPaint.finalBlendMode()); | |
| } else { | |
| // With shader blending, use AddBlendMode() to select the more universal blend functions | |
| // when possible. Technically we could always use a fixed blend mode but would then | |
| // over-generate when encountering certain classes of blends. This is most problematic | |
| // on devices that wouldn't support dual-source blending, so help them out by at least | |
| // not requiring lots of pipelines. | |
| AddBlendMode(keyContext, fPaint.finalBlendMode()); | |
| } | |
| // Blend modes can be analyzed to determine if specific src colors still depend on the dst. | |
| dependsOnDst |= blendmode_depends_on_dst(fPaint.finalBlendMode(), isOpaque); | |
| } | |
| // Optional Root Node 2 is the clip | |
| this->handleClipping(keyContext); | |
| UniquePaintParamsID paintID = | |
| keyContext.recorder()->priv().shaderCodeDictionary()->findOrCreate( | |
| keyContext.paintParamsKeyBuilder()); | |
| if (!paintID.isValid()) { | |
| return {}; | |
| } else { | |
| return Result{paintID, | |
| fDstUsage | (dependsOnDst ? DstUsage::kDependsOnDst : DstUsage::kNone)}; | |
| } | |
| } | |
| } // namespace skgpu::graphite |