1 /*
2 * Copyright 2024 Google LLC
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8 #include "include/gpu/graphite/precompile/PrecompileBlender.h"
9
10 #include "include/effects/SkRuntimeEffect.h"
11 #include "include/gpu/graphite/precompile/PrecompileRuntimeEffect.h"
12 #include "src/core/SkKnownRuntimeEffects.h"
13 #include "src/gpu/Blend.h"
14 #include "src/gpu/graphite/PaintParams.h"
15 #include "src/gpu/graphite/precompile/PrecompileBaseComplete.h"
16 #include "src/gpu/graphite/precompile/PrecompileBlenderPriv.h"
17
18 namespace skgpu::graphite {
19
20 PrecompileBlender::~PrecompileBlender() = default;
21
22 //--------------------------------------------------------------------------------------------------
23 class PrecompileBlendModeBlender final : public PrecompileBlender {
24 public:
PrecompileBlendModeBlender(SkBlendMode blendMode)25 PrecompileBlendModeBlender(SkBlendMode blendMode) : fBlendMode(blendMode) {}
26
27 protected:
asBlendMode() const28 std::optional<SkBlendMode> asBlendMode() const final { return fBlendMode; }
29
addToKey(const KeyContext & keyContext,PaintParamsKeyBuilder * builder,PipelineDataGatherer * gatherer,int desiredCombination) const30 void addToKey(const KeyContext& keyContext,
31 PaintParamsKeyBuilder* builder,
32 PipelineDataGatherer* gatherer,
33 int desiredCombination) const final {
34 SkASSERT(desiredCombination == 0); // The blend mode blender only ever has one combination
35
36 AddBlendMode(keyContext, builder, gatherer, fBlendMode);
37 }
38
39 private:
40 SkBlendMode fBlendMode;
41 };
42
Mode(SkBlendMode blendMode)43 sk_sp<PrecompileBlender> PrecompileBlenders::Mode(SkBlendMode blendMode) {
44 return sk_make_sp<PrecompileBlendModeBlender>(blendMode);
45 }
46
47 //--------------------------------------------------------------------------------------------------
Arithmetic()48 sk_sp<PrecompileBlender> PrecompileBlenders::Arithmetic() {
49 const SkRuntimeEffect* arithmeticEffect =
50 GetKnownRuntimeEffect(SkKnownRuntimeEffects::StableKey::kArithmetic);
51
52 return PrecompileRuntimeEffects::MakePrecompileBlender(sk_ref_sp(arithmeticEffect));
53 }
54
55 //--------------------------------------------------------------------------------------------------
PrecompileBlenderList(SkSpan<const sk_sp<PrecompileBlender>> blenders)56 PrecompileBlenderList::PrecompileBlenderList(SkSpan<const sk_sp<PrecompileBlender>> blenders) {
57 for (const auto& b : blenders) {
58 if (!b) {
59 // A null SkBlender is equivalent to kSrcOver
60 fHasPorterDuffBlender = true;
61 } else if (b->priv().asBlendMode().has_value()) {
62 SkBlendMode bm = b->priv().asBlendMode().value();
63
64 SkSpan<const float> coeffs = skgpu::GetPorterDuffBlendConstants(bm);
65 if (!coeffs.empty()) {
66 fHasPorterDuffBlender = true;
67 } else if (bm >= SkBlendMode::kHue) {
68 fHasHSLCBlender = true;
69 } else {
70 SkASSERT(b->priv().numCombinations() == 1);
71 fFixedBlenderEffects.push_back(b); // No reduced shader snippet for this blend mode
72 fNumCombos++;
73 }
74 } else {
75 // Runtime blenders are always fixed
76 fFixedBlenderEffects.push_back(b);
77 fNumCombos += b->priv().numCombinations();
78 }
79 }
80
81 if (!fHasPorterDuffBlender && !fHasHSLCBlender && fFixedBlenderEffects.empty()) {
82 fHasPorterDuffBlender = true; // Fallback to kSrcOver
83 }
84
85 if (fHasPorterDuffBlender) {
86 fNumCombos++;
87 }
88 if (fHasHSLCBlender) {
89 fNumCombos++;
90 }
91 }
92
PrecompileBlenderList(SkSpan<const SkBlendMode> blendModes)93 PrecompileBlenderList::PrecompileBlenderList(SkSpan<const SkBlendMode> blendModes) {
94 for (SkBlendMode bm : blendModes) {
95 SkSpan<const float> coeffs = skgpu::GetPorterDuffBlendConstants(bm);
96 if (!coeffs.empty()) {
97 fHasPorterDuffBlender = true;
98 } else if (bm >= SkBlendMode::kHue) {
99 fHasHSLCBlender = true;
100 } else {
101 fFixedBlenderEffects.push_back(PrecompileBlenders::Mode(bm));
102 }
103 }
104
105 if (!fHasPorterDuffBlender && !fHasHSLCBlender && fFixedBlenderEffects.empty()) {
106 fHasPorterDuffBlender = true; // Fallback to kSrcOver
107 }
108
109 fNumCombos = fHasPorterDuffBlender + fHasHSLCBlender + SkTo<int>(fFixedBlenderEffects.size());
110 }
111
selectOption(int desiredCombination) const112 std::pair<sk_sp<PrecompileBlender>, int> PrecompileBlenderList::selectOption(
113 int desiredCombination) const {
114 SkASSERT(desiredCombination >= 0 && desiredCombination < this->numCombinations());
115
116 if (fHasPorterDuffBlender) {
117 if (desiredCombination == 0) {
118 // Porter-Duff constant consolidated blend option, pick kSrcOver as a stand-in
119 return {PrecompileBlenders::Mode(SkBlendMode::kSrcOver), 0};
120 } else {
121 desiredCombination--;
122 }
123 }
124
125 if (fHasHSLCBlender) {
126 if (desiredCombination == 0) {
127 // HSLC blend option, pick kHue arbitrarily
128 return {PrecompileBlenders::Mode(SkBlendMode::kHue), 0};
129 } else {
130 desiredCombination--;
131 }
132 }
133
134 if (!fFixedBlenderEffects.empty()) {
135 auto [option, childCombination] =
136 PrecompileBase::SelectOption<PrecompileBlender>(fFixedBlenderEffects,
137 desiredCombination);
138
139 // Double-check that we aren't returning a blend mode that should have been consolidated.
140 SkDEBUGCODE(auto bm = option->priv().asBlendMode();)
141 SkASSERT(!bm || (*bm > SkBlendMode::kXor && *bm < SkBlendMode::kHue));
142 return {option, childCombination};
143 }
144
145 SkUNREACHABLE;
146 }
147
148
149 } // namespace skgpu::graphite
150