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