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