Brian Salomon | 92ce594 | 2017-01-18 11:01:10 -0500 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2017 Google Inc. |
| 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 | #ifndef GrProcessorSet_DEFINED |
| 9 | #define GrProcessorSet_DEFINED |
| 10 | |
| 11 | #include "GrFragmentProcessor.h" |
| 12 | #include "GrPaint.h" |
Brian Salomon | a811b12 | 2017-03-30 08:21:32 -0400 | [diff] [blame] | 13 | #include "GrProcessorAnalysis.h" |
Brian Salomon | 92ce594 | 2017-01-18 11:01:10 -0500 | [diff] [blame] | 14 | #include "SkTemplates.h" |
Hal Canary | ce78bad | 2017-05-04 14:15:40 -0400 | [diff] [blame] | 15 | #include "GrXferProcessor.h" |
Brian Salomon | 92ce594 | 2017-01-18 11:01:10 -0500 | [diff] [blame] | 16 | |
Brian Salomon | 5298dc8 | 2017-02-22 11:52:03 -0500 | [diff] [blame] | 17 | class GrAppliedClip; |
Brian Salomon | 92ce594 | 2017-01-18 11:01:10 -0500 | [diff] [blame] | 18 | class GrXPFactory; |
| 19 | |
Brian Salomon | 91326c3 | 2017-08-09 16:02:19 -0400 | [diff] [blame] | 20 | class GrProcessorSet { |
Brian Salomon | 6d4b65e | 2017-05-03 17:06:09 -0400 | [diff] [blame] | 21 | private: |
| 22 | // Arbitrary constructor arg for empty set and analysis |
| 23 | enum class Empty { kEmpty }; |
| 24 | |
Brian Salomon | 92ce594 | 2017-01-18 11:01:10 -0500 | [diff] [blame] | 25 | public: |
Brian Salomon | 91326c3 | 2017-08-09 16:02:19 -0400 | [diff] [blame] | 26 | GrProcessorSet(GrPaint&&); |
| 27 | GrProcessorSet(SkBlendMode); |
Brian Salomon | aff329b | 2017-08-11 09:40:37 -0400 | [diff] [blame] | 28 | GrProcessorSet(std::unique_ptr<GrFragmentProcessor> colorFP); |
Brian Salomon | 91326c3 | 2017-08-09 16:02:19 -0400 | [diff] [blame] | 29 | GrProcessorSet(GrProcessorSet&&); |
| 30 | GrProcessorSet(const GrProcessorSet&) = delete; |
| 31 | GrProcessorSet& operator=(const GrProcessorSet&) = delete; |
Brian Salomon | 92ce594 | 2017-01-18 11:01:10 -0500 | [diff] [blame] | 32 | |
Brian Salomon | 54d212e | 2017-03-21 14:22:38 -0400 | [diff] [blame] | 33 | ~GrProcessorSet(); |
| 34 | |
Brian Salomon | 92ce594 | 2017-01-18 11:01:10 -0500 | [diff] [blame] | 35 | int numColorFragmentProcessors() const { return fColorFragmentProcessorCnt; } |
| 36 | int numCoverageFragmentProcessors() const { |
Brian Salomon | 70288c0 | 2017-03-24 12:27:17 -0400 | [diff] [blame] | 37 | return this->numFragmentProcessors() - fColorFragmentProcessorCnt; |
Brian Salomon | 92ce594 | 2017-01-18 11:01:10 -0500 | [diff] [blame] | 38 | } |
Brian Salomon | 92ce594 | 2017-01-18 11:01:10 -0500 | [diff] [blame] | 39 | |
| 40 | const GrFragmentProcessor* colorFragmentProcessor(int idx) const { |
| 41 | SkASSERT(idx < fColorFragmentProcessorCnt); |
Brian Salomon | aff329b | 2017-08-11 09:40:37 -0400 | [diff] [blame] | 42 | return fFragmentProcessors[idx + fFragmentProcessorOffset].get(); |
Brian Salomon | 92ce594 | 2017-01-18 11:01:10 -0500 | [diff] [blame] | 43 | } |
| 44 | const GrFragmentProcessor* coverageFragmentProcessor(int idx) const { |
Brian Salomon | aff329b | 2017-08-11 09:40:37 -0400 | [diff] [blame] | 45 | return fFragmentProcessors[idx + fColorFragmentProcessorCnt + |
| 46 | fFragmentProcessorOffset].get(); |
Brian Salomon | 92ce594 | 2017-01-18 11:01:10 -0500 | [diff] [blame] | 47 | } |
| 48 | |
Brian Salomon | 48d1b4c | 2017-04-08 07:38:53 -0400 | [diff] [blame] | 49 | const GrXferProcessor* xferProcessor() const { |
| 50 | SkASSERT(this->isFinalized()); |
| 51 | return fXP.fProcessor; |
| 52 | } |
Brian Salomon | d61c9d9 | 2017-04-10 10:54:25 -0400 | [diff] [blame] | 53 | sk_sp<const GrXferProcessor> refXferProcessor() const { |
| 54 | SkASSERT(this->isFinalized()); |
| 55 | return sk_ref_sp(fXP.fProcessor); |
| 56 | } |
Brian Salomon | 92ce594 | 2017-01-18 11:01:10 -0500 | [diff] [blame] | 57 | |
Brian Salomon | aff329b | 2017-08-11 09:40:37 -0400 | [diff] [blame] | 58 | std::unique_ptr<const GrFragmentProcessor> detachColorFragmentProcessor(int idx) { |
| 59 | SkASSERT(idx < fColorFragmentProcessorCnt); |
| 60 | return std::move(fFragmentProcessors[idx + fFragmentProcessorOffset]); |
| 61 | } |
| 62 | |
| 63 | std::unique_ptr<const GrFragmentProcessor> detachCoverageFragmentProcessor(int idx) { |
| 64 | return std::move( |
| 65 | fFragmentProcessors[idx + fFragmentProcessorOffset + fColorFragmentProcessorCnt]); |
| 66 | } |
| 67 | |
Brian Salomon | 48d1b4c | 2017-04-08 07:38:53 -0400 | [diff] [blame] | 68 | /** Comparisons are only legal on finalized processor sets. */ |
Brian Salomon | 54d212e | 2017-03-21 14:22:38 -0400 | [diff] [blame] | 69 | bool operator==(const GrProcessorSet& that) const; |
| 70 | bool operator!=(const GrProcessorSet& that) const { return !(*this == that); } |
| 71 | |
Brian Salomon | 5298dc8 | 2017-02-22 11:52:03 -0500 | [diff] [blame] | 72 | /** |
Brian Salomon | 48d1b4c | 2017-04-08 07:38:53 -0400 | [diff] [blame] | 73 | * This is used to report results of processor analysis when a processor set is finalized (see |
| 74 | * below). |
Brian Salomon | 5298dc8 | 2017-02-22 11:52:03 -0500 | [diff] [blame] | 75 | */ |
Brian Salomon | a811b12 | 2017-03-30 08:21:32 -0400 | [diff] [blame] | 76 | class Analysis { |
Brian Salomon | 5298dc8 | 2017-02-22 11:52:03 -0500 | [diff] [blame] | 77 | public: |
Brian Salomon | 48d1b4c | 2017-04-08 07:38:53 -0400 | [diff] [blame] | 78 | Analysis(const Analysis&) = default; |
| 79 | Analysis() { *reinterpret_cast<uint32_t*>(this) = 0; } |
Brian Salomon | 8d2f90b | 2017-03-13 09:11:58 -0400 | [diff] [blame] | 80 | |
Brian Salomon | 48d1b4c | 2017-04-08 07:38:53 -0400 | [diff] [blame] | 81 | bool isInitialized() const { return fIsInitialized; } |
Brian Salomon | bfafcba | 2017-03-02 08:49:19 -0500 | [diff] [blame] | 82 | bool usesLocalCoords() const { return fUsesLocalCoords; } |
Brian Salomon | 3185384 | 2017-03-28 16:32:05 -0400 | [diff] [blame] | 83 | bool requiresDstTexture() const { return fRequiresDstTexture; } |
| 84 | bool canCombineOverlappedStencilAndCover() const { |
| 85 | return fCanCombineOverlappedStencilAndCover; |
| 86 | } |
Brian Salomon | 4fc7740 | 2017-03-30 16:48:26 -0400 | [diff] [blame] | 87 | bool requiresBarrierBetweenOverlappingDraws() const { |
| 88 | return fRequiresBarrierBetweenOverlappingDraws; |
| 89 | } |
Brian Salomon | 5298dc8 | 2017-02-22 11:52:03 -0500 | [diff] [blame] | 90 | bool isCompatibleWithCoverageAsAlpha() const { return fCompatibleWithCoverageAsAlpha; } |
Brian Salomon | 48d1b4c | 2017-04-08 07:38:53 -0400 | [diff] [blame] | 91 | |
| 92 | bool inputColorIsIgnored() const { return fInputColorType == kIgnored_InputColorType; } |
| 93 | bool inputColorIsOverridden() const { |
| 94 | return fInputColorType == kOverridden_InputColorType; |
Brian Salomon | c0b642c | 2017-03-27 13:09:36 -0400 | [diff] [blame] | 95 | } |
Brian Salomon | 5298dc8 | 2017-02-22 11:52:03 -0500 | [diff] [blame] | 96 | |
| 97 | private: |
Brian Salomon | 6d4b65e | 2017-05-03 17:06:09 -0400 | [diff] [blame] | 98 | constexpr Analysis(Empty) |
| 99 | : fUsesLocalCoords(false) |
| 100 | , fCompatibleWithCoverageAsAlpha(true) |
| 101 | , fRequiresDstTexture(false) |
| 102 | , fCanCombineOverlappedStencilAndCover(true) |
| 103 | , fRequiresBarrierBetweenOverlappingDraws(false) |
| 104 | , fIsInitialized(true) |
| 105 | , fInputColorType(kOriginal_InputColorType) {} |
Brian Salomon | 48d1b4c | 2017-04-08 07:38:53 -0400 | [diff] [blame] | 106 | enum InputColorType : uint32_t { |
| 107 | kOriginal_InputColorType, |
| 108 | kOverridden_InputColorType, |
| 109 | kIgnored_InputColorType |
| 110 | }; |
Brian Salomon | 5298dc8 | 2017-02-22 11:52:03 -0500 | [diff] [blame] | 111 | |
Brian Salomon | 48d1b4c | 2017-04-08 07:38:53 -0400 | [diff] [blame] | 112 | // MSVS 2015 won't pack different underlying types |
| 113 | using PackedBool = uint32_t; |
| 114 | using PackedInputColorType = uint32_t; |
Brian Salomon | 5298dc8 | 2017-02-22 11:52:03 -0500 | [diff] [blame] | 115 | |
Brian Salomon | 8d2f90b | 2017-03-13 09:11:58 -0400 | [diff] [blame] | 116 | PackedBool fUsesLocalCoords : 1; |
| 117 | PackedBool fCompatibleWithCoverageAsAlpha : 1; |
Brian Salomon | 3185384 | 2017-03-28 16:32:05 -0400 | [diff] [blame] | 118 | PackedBool fRequiresDstTexture : 1; |
| 119 | PackedBool fCanCombineOverlappedStencilAndCover : 1; |
Brian Salomon | 4fc7740 | 2017-03-30 16:48:26 -0400 | [diff] [blame] | 120 | PackedBool fRequiresBarrierBetweenOverlappingDraws : 1; |
Brian Salomon | 48d1b4c | 2017-04-08 07:38:53 -0400 | [diff] [blame] | 121 | PackedBool fIsInitialized : 1; |
| 122 | PackedInputColorType fInputColorType : 2; |
Brian Salomon | 70288c0 | 2017-03-24 12:27:17 -0400 | [diff] [blame] | 123 | |
| 124 | friend class GrProcessorSet; |
Brian Salomon | 5298dc8 | 2017-02-22 11:52:03 -0500 | [diff] [blame] | 125 | }; |
Brian Salomon | 48d1b4c | 2017-04-08 07:38:53 -0400 | [diff] [blame] | 126 | GR_STATIC_ASSERT(sizeof(Analysis) <= sizeof(uint32_t)); |
Brian Salomon | 5298dc8 | 2017-02-22 11:52:03 -0500 | [diff] [blame] | 127 | |
Brian Salomon | 48d1b4c | 2017-04-08 07:38:53 -0400 | [diff] [blame] | 128 | /** |
| 129 | * This analyzes the processors given an op's input color and coverage as well as a clip. The |
| 130 | * state of the processor set may change to an equivalent but more optimal set of processors. |
| 131 | * This new state requires that the caller respect the returned 'inputColorOverride'. This is |
| 132 | * indicated by the returned Analysis's inputColorIsOverriden(). 'inputColorOverride' will not |
| 133 | * be written if the analysis does not override the input color. |
| 134 | * |
| 135 | * This must be called before the processor set is used to construct a GrPipeline and may only |
| 136 | * be called once. |
| 137 | * |
| 138 | * This also puts the processors in "pending execution" state and must be called when an op |
| 139 | * that owns a processor set is recorded to ensure pending and writes are propagated to |
| 140 | * resources referred to by the processors. Otherwise, data hazards may occur. |
| 141 | */ |
| 142 | Analysis finalize(const GrProcessorAnalysisColor& colorInput, |
| 143 | const GrProcessorAnalysisCoverage coverageInput, const GrAppliedClip*, |
| 144 | bool isMixedSamples, const GrCaps&, GrColor* inputColorOverride); |
| 145 | |
| 146 | bool isFinalized() const { return SkToBool(kFinalized_Flag & fFlags); } |
Brian Salomon | 70288c0 | 2017-03-24 12:27:17 -0400 | [diff] [blame] | 147 | |
Brian Salomon | 44acb5b | 2017-07-18 19:59:24 -0400 | [diff] [blame] | 148 | /** These are valid only for non-LCD coverage. */ |
Brian Salomon | 292bf7a | 2017-05-17 09:43:55 -0400 | [diff] [blame] | 149 | static const GrProcessorSet& EmptySet(); |
Brian Salomon | 91326c3 | 2017-08-09 16:02:19 -0400 | [diff] [blame] | 150 | static GrProcessorSet MakeEmptySet(); |
Brian Salomon | 6d4b65e | 2017-05-03 17:06:09 -0400 | [diff] [blame] | 151 | static constexpr const Analysis EmptySetAnalysis() { return Analysis(Empty::kEmpty); } |
| 152 | |
Brian Salomon | 82dfd3d | 2017-06-14 12:30:35 -0400 | [diff] [blame] | 153 | SkString dumpProcessors() const; |
| 154 | |
Robert Phillips | f1748f5 | 2017-09-14 14:11:24 -0400 | [diff] [blame^] | 155 | void visitProxies(const std::function<void(GrSurfaceProxy*)>& func) const { |
Robert Phillips | b493eeb | 2017-09-13 13:10:52 -0400 | [diff] [blame] | 156 | for (int i = 0; i < this->numFragmentProcessors(); ++i) { |
| 157 | GrFragmentProcessor::TextureAccessIter iter(this->fragmentProcessor(i)); |
| 158 | while (const GrResourceIOProcessor::TextureSampler* sampler = iter.next()) { |
| 159 | func(sampler->proxy()); |
| 160 | } |
| 161 | } |
| 162 | } |
| 163 | |
Brian Salomon | 92ce594 | 2017-01-18 11:01:10 -0500 | [diff] [blame] | 164 | private: |
Brian Salomon | 6d4b65e | 2017-05-03 17:06:09 -0400 | [diff] [blame] | 165 | GrProcessorSet(Empty) : fXP((const GrXferProcessor*)nullptr), fFlags(kFinalized_Flag) {} |
Brian Salomon | 6d4b65e | 2017-05-03 17:06:09 -0400 | [diff] [blame] | 166 | |
Robert Phillips | b493eeb | 2017-09-13 13:10:52 -0400 | [diff] [blame] | 167 | int numFragmentProcessors() const { |
| 168 | return fFragmentProcessors.count() - fFragmentProcessorOffset; |
| 169 | } |
| 170 | |
| 171 | const GrFragmentProcessor* fragmentProcessor(int idx) const { |
| 172 | return fFragmentProcessors[idx + fFragmentProcessorOffset].get(); |
| 173 | } |
| 174 | |
Brian Salomon | a811b12 | 2017-03-30 08:21:32 -0400 | [diff] [blame] | 175 | // This absurdly large limit allows Analysis and this to pack fields together. |
Brian Salomon | 70288c0 | 2017-03-24 12:27:17 -0400 | [diff] [blame] | 176 | static constexpr int kMaxColorProcessors = UINT8_MAX; |
Brian Salomon | 8d2f90b | 2017-03-13 09:11:58 -0400 | [diff] [blame] | 177 | |
Brian Salomon | e23bffd | 2017-06-02 11:01:10 -0400 | [diff] [blame] | 178 | enum Flags : uint16_t { kFinalized_Flag = 0x1 }; |
Brian Salomon | 8d2f90b | 2017-03-13 09:11:58 -0400 | [diff] [blame] | 179 | |
Brian Salomon | 48d1b4c | 2017-04-08 07:38:53 -0400 | [diff] [blame] | 180 | union XP { |
| 181 | XP(const GrXPFactory* factory) : fFactory(factory) {} |
Brian Salomon | 6d4b65e | 2017-05-03 17:06:09 -0400 | [diff] [blame] | 182 | XP(const GrXferProcessor* processor) : fProcessor(processor) {} |
Brian Salomon | 91326c3 | 2017-08-09 16:02:19 -0400 | [diff] [blame] | 183 | explicit XP(XP&& that) : fProcessor(that.fProcessor) { |
| 184 | SkASSERT(fProcessor == that.fProcessor); |
| 185 | that.fProcessor = nullptr; |
| 186 | } |
Brian Salomon | 48d1b4c | 2017-04-08 07:38:53 -0400 | [diff] [blame] | 187 | const GrXPFactory* fFactory; |
| 188 | const GrXferProcessor* fProcessor; |
| 189 | }; |
| 190 | |
| 191 | const GrXPFactory* xpFactory() const { |
| 192 | SkASSERT(!this->isFinalized()); |
| 193 | return fXP.fFactory; |
| 194 | } |
| 195 | |
Brian Salomon | aff329b | 2017-08-11 09:40:37 -0400 | [diff] [blame] | 196 | SkAutoSTArray<4, std::unique_ptr<const GrFragmentProcessor>> fFragmentProcessors; |
Brian Salomon | 48d1b4c | 2017-04-08 07:38:53 -0400 | [diff] [blame] | 197 | XP fXP; |
Brian Salomon | 6d4b65e | 2017-05-03 17:06:09 -0400 | [diff] [blame] | 198 | uint8_t fColorFragmentProcessorCnt = 0; |
Brian Salomon | 70288c0 | 2017-03-24 12:27:17 -0400 | [diff] [blame] | 199 | uint8_t fFragmentProcessorOffset = 0; |
| 200 | uint8_t fFlags; |
Brian Salomon | 92ce594 | 2017-01-18 11:01:10 -0500 | [diff] [blame] | 201 | }; |
| 202 | |
| 203 | #endif |