egdaniel | 3658f38 | 2014-09-15 07:01:59 -0700 | [diff] [blame] | 1 | /* |
egdaniel | 8dd688b | 2015-01-22 10:16:09 -0800 | [diff] [blame] | 2 | * Copyright 2015 Google Inc. |
egdaniel | 3658f38 | 2014-09-15 07:01:59 -0700 | [diff] [blame] | 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 | |
egdaniel | 8dd688b | 2015-01-22 10:16:09 -0800 | [diff] [blame] | 8 | #ifndef GrPipeline_DEFINED |
| 9 | #define GrPipeline_DEFINED |
egdaniel | 3658f38 | 2014-09-15 07:01:59 -0700 | [diff] [blame] | 10 | |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 11 | #include "include/core/SkMatrix.h" |
| 12 | #include "include/core/SkRefCnt.h" |
Greg Daniel | f91aeb2 | 2019-06-18 09:58:02 -0400 | [diff] [blame] | 13 | #include "src/gpu/GrColor.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 14 | #include "src/gpu/GrFragmentProcessor.h" |
| 15 | #include "src/gpu/GrNonAtomicRef.h" |
| 16 | #include "src/gpu/GrPendingIOResource.h" |
| 17 | #include "src/gpu/GrProcessorSet.h" |
| 18 | #include "src/gpu/GrProgramDesc.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 19 | #include "src/gpu/GrScissorState.h" |
| 20 | #include "src/gpu/GrUserStencilSettings.h" |
| 21 | #include "src/gpu/GrWindowRectsState.h" |
| 22 | #include "src/gpu/effects/GrCoverageSetOpXP.h" |
| 23 | #include "src/gpu/effects/GrDisableColorXP.h" |
| 24 | #include "src/gpu/effects/GrPorterDuffXferProcessor.h" |
| 25 | #include "src/gpu/effects/generated/GrSimpleTextureEffect.h" |
Michael Ludwig | 663afe5 | 2019-06-03 16:46:19 -0400 | [diff] [blame] | 26 | #include "src/gpu/geometry/GrRect.h" |
robertphillips | 5fa7f30 | 2016-07-21 09:21:04 -0700 | [diff] [blame] | 27 | |
Brian Salomon | 652ecb5 | 2017-01-17 12:39:53 -0500 | [diff] [blame] | 28 | class GrAppliedClip; |
Brian Salomon | 25a8809 | 2016-12-01 09:36:50 -0500 | [diff] [blame] | 29 | class GrOp; |
Brian Salomon | 25a8809 | 2016-12-01 09:36:50 -0500 | [diff] [blame] | 30 | class GrRenderTargetContext; |
egdaniel | 3658f38 | 2014-09-15 07:01:59 -0700 | [diff] [blame] | 31 | |
Brian Salomon | 92aee3d | 2016-12-21 09:20:25 -0500 | [diff] [blame] | 32 | /** |
Brian Salomon | e5b399e | 2017-07-19 13:50:54 -0400 | [diff] [blame] | 33 | * This immutable object contains information needed to set build a shader program and set API |
| 34 | * state for a draw. It is used along with a GrPrimitiveProcessor and a source of geometric |
| 35 | * data (GrMesh or GrPath) to draw. |
egdaniel | 3658f38 | 2014-09-15 07:01:59 -0700 | [diff] [blame] | 36 | */ |
Brian Salomon | 1635146 | 2017-07-19 16:35:31 -0400 | [diff] [blame] | 37 | class GrPipeline { |
egdaniel | 3658f38 | 2014-09-15 07:01:59 -0700 | [diff] [blame] | 38 | public: |
bsalomon | cb02b38 | 2015-08-12 11:14:50 -0700 | [diff] [blame] | 39 | /////////////////////////////////////////////////////////////////////////// |
| 40 | /// @name Creation |
| 41 | |
Chris Dalton | baa1b35 | 2019-04-03 12:03:00 -0600 | [diff] [blame] | 42 | // Pipeline options that the caller may enable. |
| 43 | // NOTE: This enum is extended later by GrPipeline::Flags. |
| 44 | enum class InputFlags : uint8_t { |
| 45 | kNone = 0, |
Brian Salomon | 189098e7 | 2017-01-19 09:55:19 -0500 | [diff] [blame] | 46 | /** |
| 47 | * Perform HW anti-aliasing. This means either HW FSAA, if supported by the render target, |
| 48 | * or smooth-line rendering if a line primitive is drawn and line smoothing is supported by |
| 49 | * the 3D API. |
| 50 | */ |
Chris Dalton | baa1b35 | 2019-04-03 12:03:00 -0600 | [diff] [blame] | 51 | kHWAntialias = (1 << 0), |
Brian Salomon | 189098e7 | 2017-01-19 09:55:19 -0500 | [diff] [blame] | 52 | /** |
| 53 | * Modifies the vertex shader so that vertices will be positioned at pixel centers. |
| 54 | */ |
Chris Dalton | baa1b35 | 2019-04-03 12:03:00 -0600 | [diff] [blame] | 55 | kSnapVerticesToPixelCenters = (1 << 1), // This value must be last. (See kLastInputFlag.) |
Brian Salomon | 189098e7 | 2017-01-19 09:55:19 -0500 | [diff] [blame] | 56 | }; |
| 57 | |
Brian Salomon | b5cb683 | 2017-02-24 11:01:15 -0500 | [diff] [blame] | 58 | struct InitArgs { |
Chris Dalton | baa1b35 | 2019-04-03 12:03:00 -0600 | [diff] [blame] | 59 | InputFlags fInputFlags = InputFlags::kNone; |
Brian Salomon | 189098e7 | 2017-01-19 09:55:19 -0500 | [diff] [blame] | 60 | const GrUserStencilSettings* fUserStencil = &GrUserStencilSettings::kUnused; |
Brian Salomon | 189098e7 | 2017-01-19 09:55:19 -0500 | [diff] [blame] | 61 | const GrCaps* fCaps = nullptr; |
Robert Phillips | 9bee2e5 | 2017-05-29 12:37:20 -0400 | [diff] [blame] | 62 | GrResourceProvider* fResourceProvider = nullptr; |
Robert Phillips | bb581ce | 2017-05-29 15:05:15 -0400 | [diff] [blame] | 63 | GrXferProcessor::DstProxy fDstProxy; |
Greg Daniel | 2c3398d | 2019-06-19 11:58:01 -0400 | [diff] [blame^] | 64 | GrSwizzle fOutputSwizzle; |
bsalomon | a387a11 | 2015-08-11 14:47:42 -0700 | [diff] [blame] | 65 | }; |
| 66 | |
Brian Salomon | b5cb683 | 2017-02-24 11:01:15 -0500 | [diff] [blame] | 67 | /** |
Brian Salomon | 4934890 | 2018-06-26 09:12:38 -0400 | [diff] [blame] | 68 | * Some state can be changed between GrMeshes without changing GrPipelines. This is generally |
| 69 | * less expensive then using multiple pipelines. Such state is called "dynamic state". It can |
| 70 | * be specified in two ways: |
| 71 | * 1) FixedDynamicState - use this to specify state that does not vary between GrMeshes. |
| 72 | * 2) DynamicStateArrays - use this to specify per mesh values for dynamic state. |
Chris Dalton | 46983b7 | 2017-06-06 12:27:16 -0600 | [diff] [blame] | 73 | **/ |
Brian Salomon | 4934890 | 2018-06-26 09:12:38 -0400 | [diff] [blame] | 74 | struct FixedDynamicState { |
Brian Salomon | 7eae3e0 | 2018-08-07 14:02:38 +0000 | [diff] [blame] | 75 | explicit FixedDynamicState(const SkIRect& scissorRect) : fScissorRect(scissorRect) {} |
| 76 | FixedDynamicState() = default; |
| 77 | SkIRect fScissorRect = SkIRect::EmptyIRect(); |
Brian Salomon | f723264 | 2018-09-19 08:58:08 -0400 | [diff] [blame] | 78 | // Must have GrPrimitiveProcessor::numTextureSamplers() entries. Can be null if no samplers |
| 79 | // or textures are passed using DynamicStateArrays. |
Brian Salomon | 7eae3e0 | 2018-08-07 14:02:38 +0000 | [diff] [blame] | 80 | GrTextureProxy** fPrimitiveProcessorTextures = nullptr; |
Chris Dalton | 46983b7 | 2017-06-06 12:27:16 -0600 | [diff] [blame] | 81 | }; |
| 82 | |
| 83 | /** |
Brian Salomon | 4934890 | 2018-06-26 09:12:38 -0400 | [diff] [blame] | 84 | * Any non-null array overrides the FixedDynamicState on a mesh-by-mesh basis. Arrays must |
| 85 | * have one entry for each GrMesh. |
| 86 | */ |
| 87 | struct DynamicStateArrays { |
| 88 | const SkIRect* fScissorRects = nullptr; |
Brian Salomon | f723264 | 2018-09-19 08:58:08 -0400 | [diff] [blame] | 89 | // Must have GrPrimitiveProcessor::numTextureSamplers() * num_meshes entries. |
| 90 | // Can be null if no samplers or to use the same textures for all meshes via' |
| 91 | // FixedDynamicState. |
| 92 | GrTextureProxy** fPrimitiveProcessorTextures = nullptr; |
Brian Salomon | 4934890 | 2018-06-26 09:12:38 -0400 | [diff] [blame] | 93 | }; |
| 94 | |
| 95 | /** |
csmartdalton | 119fb2b | 2017-02-08 14:41:05 -0500 | [diff] [blame] | 96 | * Creates a simple pipeline with default settings and no processors. The provided blend mode |
Chris Dalton | 916c498 | 2018-08-15 00:53:25 -0600 | [diff] [blame] | 97 | * must be "Porter Duff" (<= kLastCoeffMode). If using GrScissorTest::kEnabled, the caller must |
Chris Dalton | 46983b7 | 2017-06-06 12:27:16 -0600 | [diff] [blame] | 98 | * specify a scissor rectangle through the DynamicState struct. |
csmartdalton | 119fb2b | 2017-02-08 14:41:05 -0500 | [diff] [blame] | 99 | **/ |
Greg Daniel | 2c3398d | 2019-06-19 11:58:01 -0400 | [diff] [blame^] | 100 | GrPipeline(GrScissorTest, SkBlendMode, const GrSwizzle& outputSwizzle, |
| 101 | InputFlags = InputFlags::kNone, |
Chris Dalton | d7291ba | 2019-03-07 14:17:03 -0700 | [diff] [blame] | 102 | const GrUserStencilSettings* = &GrUserStencilSettings::kUnused); |
csmartdalton | 119fb2b | 2017-02-08 14:41:05 -0500 | [diff] [blame] | 103 | |
Brian Salomon | bfd18cd | 2017-08-09 16:27:09 -0400 | [diff] [blame] | 104 | GrPipeline(const InitArgs&, GrProcessorSet&&, GrAppliedClip&&); |
Brian Salomon | 6d4b65e | 2017-05-03 17:06:09 -0400 | [diff] [blame] | 105 | |
Brian Salomon | 1635146 | 2017-07-19 16:35:31 -0400 | [diff] [blame] | 106 | GrPipeline(const GrPipeline&) = delete; |
| 107 | GrPipeline& operator=(const GrPipeline&) = delete; |
| 108 | |
egdaniel | 89af44a | 2014-09-26 06:15:04 -0700 | [diff] [blame] | 109 | /// @} |
| 110 | |
| 111 | /////////////////////////////////////////////////////////////////////////// |
bsalomon | 6be6f7c | 2015-02-26 13:05:21 -0800 | [diff] [blame] | 112 | /// @name GrFragmentProcessors |
egdaniel | 89af44a | 2014-09-26 06:15:04 -0700 | [diff] [blame] | 113 | |
Robert Phillips | d261e10 | 2017-06-23 12:37:20 -0400 | [diff] [blame] | 114 | // Make the renderTargetContext's GrOpList be dependent on any GrOpLists in this pipeline |
| 115 | void addDependenciesTo(GrOpList* recipient, const GrCaps&) const; |
bsalomon | 6be6f7c | 2015-02-26 13:05:21 -0800 | [diff] [blame] | 116 | |
bsalomon | ac856c9 | 2015-08-27 06:30:17 -0700 | [diff] [blame] | 117 | int numColorFragmentProcessors() const { return fNumColorProcessors; } |
| 118 | int numCoverageFragmentProcessors() const { |
| 119 | return fFragmentProcessors.count() - fNumColorProcessors; |
| 120 | } |
| 121 | int numFragmentProcessors() const { return fFragmentProcessors.count(); } |
egdaniel | 89af44a | 2014-09-26 06:15:04 -0700 | [diff] [blame] | 122 | |
bsalomon | 2047b78 | 2015-12-21 13:12:54 -0800 | [diff] [blame] | 123 | const GrXferProcessor& getXferProcessor() const { |
Brian Salomon | d61c9d9 | 2017-04-10 10:54:25 -0400 | [diff] [blame] | 124 | if (fXferProcessor) { |
bsalomon | 2047b78 | 2015-12-21 13:12:54 -0800 | [diff] [blame] | 125 | return *fXferProcessor.get(); |
| 126 | } else { |
| 127 | // A null xp member means the common src-over case. GrXferProcessor's ref'ing |
| 128 | // mechanism is not thread safe so we do not hold a ref on this global. |
| 129 | return GrPorterDuffXPFactory::SimpleSrcOverXP(); |
| 130 | } |
| 131 | } |
egdaniel | 378092f | 2014-12-03 10:40:13 -0800 | [diff] [blame] | 132 | |
Brian Salomon | 18dfa98 | 2017-04-03 16:57:43 -0400 | [diff] [blame] | 133 | /** |
| 134 | * If the GrXferProcessor uses a texture to access the dst color, then this returns that |
| 135 | * texture and the offset to the dst contents within that texture. |
| 136 | */ |
Robert Phillips | bb581ce | 2017-05-29 15:05:15 -0400 | [diff] [blame] | 137 | GrTextureProxy* dstTextureProxy(SkIPoint* offset = nullptr) const { |
Brian Salomon | 18dfa98 | 2017-04-03 16:57:43 -0400 | [diff] [blame] | 138 | if (offset) { |
| 139 | *offset = fDstTextureOffset; |
| 140 | } |
Robert Phillips | 3d4cac5 | 2019-06-11 08:08:08 -0400 | [diff] [blame] | 141 | |
| 142 | return fDstTextureProxy ? fDstTextureProxy->asTextureProxy() : nullptr; |
Robert Phillips | bb581ce | 2017-05-29 15:05:15 -0400 | [diff] [blame] | 143 | } |
| 144 | |
| 145 | GrTexture* peekDstTexture(SkIPoint* offset = nullptr) const { |
| 146 | if (GrTextureProxy* dstProxy = this->dstTextureProxy(offset)) { |
Brian Salomon | fd98c2c | 2018-07-31 17:25:29 -0400 | [diff] [blame] | 147 | return dstProxy->peekTexture(); |
Robert Phillips | bb581ce | 2017-05-29 15:05:15 -0400 | [diff] [blame] | 148 | } |
| 149 | |
| 150 | return nullptr; |
Brian Salomon | 18dfa98 | 2017-04-03 16:57:43 -0400 | [diff] [blame] | 151 | } |
| 152 | |
bsalomon | ac856c9 | 2015-08-27 06:30:17 -0700 | [diff] [blame] | 153 | const GrFragmentProcessor& getColorFragmentProcessor(int idx) const { |
| 154 | SkASSERT(idx < this->numColorFragmentProcessors()); |
| 155 | return *fFragmentProcessors[idx].get(); |
egdaniel | d9aa218 | 2014-10-09 13:47:05 -0700 | [diff] [blame] | 156 | } |
bsalomon | ac856c9 | 2015-08-27 06:30:17 -0700 | [diff] [blame] | 157 | |
| 158 | const GrFragmentProcessor& getCoverageFragmentProcessor(int idx) const { |
| 159 | SkASSERT(idx < this->numCoverageFragmentProcessors()); |
| 160 | return *fFragmentProcessors[fNumColorProcessors + idx].get(); |
egdaniel | d9aa218 | 2014-10-09 13:47:05 -0700 | [diff] [blame] | 161 | } |
bsalomon | ac856c9 | 2015-08-27 06:30:17 -0700 | [diff] [blame] | 162 | |
| 163 | const GrFragmentProcessor& getFragmentProcessor(int idx) const { |
| 164 | return *fFragmentProcessors[idx].get(); |
bsalomon | ae59b77 | 2014-11-19 08:23:49 -0800 | [diff] [blame] | 165 | } |
egdaniel | 89af44a | 2014-09-26 06:15:04 -0700 | [diff] [blame] | 166 | |
| 167 | /// @} |
| 168 | |
csmartdalton | c633abb | 2016-11-01 08:55:55 -0700 | [diff] [blame] | 169 | const GrUserStencilSettings* getUserStencil() const { return fUserStencilSettings; } |
egdaniel | 89af44a | 2014-09-26 06:15:04 -0700 | [diff] [blame] | 170 | |
Chris Dalton | 916c498 | 2018-08-15 00:53:25 -0600 | [diff] [blame] | 171 | bool isScissorEnabled() const { |
Chris Dalton | baa1b35 | 2019-04-03 12:03:00 -0600 | [diff] [blame] | 172 | return SkToBool(fFlags & Flags::kScissorEnabled); |
Brian Salomon | 4934890 | 2018-06-26 09:12:38 -0400 | [diff] [blame] | 173 | } |
joshualitt | 54e0c12 | 2014-11-19 09:38:51 -0800 | [diff] [blame] | 174 | |
csmartdalton | bf4a8f9 | 2016-09-06 10:01:06 -0700 | [diff] [blame] | 175 | const GrWindowRectsState& getWindowRectsState() const { return fWindowRectsState; } |
csmartdalton | 28341fa | 2016-08-17 10:00:21 -0700 | [diff] [blame] | 176 | |
Chris Dalton | baa1b35 | 2019-04-03 12:03:00 -0600 | [diff] [blame] | 177 | bool isHWAntialiasState() const { return SkToBool(fFlags & InputFlags::kHWAntialias); } |
Brian Salomon | 189098e7 | 2017-01-19 09:55:19 -0500 | [diff] [blame] | 178 | bool snapVerticesToPixelCenters() const { |
Chris Dalton | baa1b35 | 2019-04-03 12:03:00 -0600 | [diff] [blame] | 179 | return SkToBool(fFlags & InputFlags::kSnapVerticesToPixelCenters); |
Brian Salomon | 189098e7 | 2017-01-19 09:55:19 -0500 | [diff] [blame] | 180 | } |
cdalton | 193d9cf | 2016-05-12 11:52:02 -0700 | [diff] [blame] | 181 | bool hasStencilClip() const { |
Chris Dalton | baa1b35 | 2019-04-03 12:03:00 -0600 | [diff] [blame] | 182 | return SkToBool(fFlags & Flags::kHasStencilClip); |
cdalton | 193d9cf | 2016-05-12 11:52:02 -0700 | [diff] [blame] | 183 | } |
csmartdalton | c633abb | 2016-11-01 08:55:55 -0700 | [diff] [blame] | 184 | bool isStencilEnabled() const { |
Chris Dalton | baa1b35 | 2019-04-03 12:03:00 -0600 | [diff] [blame] | 185 | return SkToBool(fFlags & Flags::kStencilEnabled); |
csmartdalton | c633abb | 2016-11-01 08:55:55 -0700 | [diff] [blame] | 186 | } |
Chris Dalton | baa1b35 | 2019-04-03 12:03:00 -0600 | [diff] [blame] | 187 | bool isBad() const { return SkToBool(fFlags & Flags::kIsBad); } |
bsalomon | ae59b77 | 2014-11-19 08:23:49 -0800 | [diff] [blame] | 188 | |
Robert Phillips | d0fe875 | 2019-01-31 14:13:59 -0500 | [diff] [blame] | 189 | GrXferBarrierType xferBarrierType(GrTexture*, const GrCaps&) const; |
bsalomon | cb02b38 | 2015-08-12 11:14:50 -0700 | [diff] [blame] | 190 | |
Jim Van Verth | 1223e7f | 2019-02-28 17:38:35 -0500 | [diff] [blame] | 191 | // Used by Vulkan and Metal to cache their respective pipeline objects |
| 192 | uint32_t getBlendInfoKey() const; |
| 193 | |
Greg Daniel | 2c3398d | 2019-06-19 11:58:01 -0400 | [diff] [blame^] | 194 | const GrSwizzle& outputSwizzle() const { return fOutputSwizzle; } |
| 195 | |
bsalomon | ae59b77 | 2014-11-19 08:23:49 -0800 | [diff] [blame] | 196 | private: |
Chris Dalton | baa1b35 | 2019-04-03 12:03:00 -0600 | [diff] [blame] | 197 | void markAsBad() { fFlags |= Flags::kIsBad; } |
Robert Phillips | a91e0b7 | 2017-05-01 13:12:20 -0400 | [diff] [blame] | 198 | |
Chris Dalton | baa1b35 | 2019-04-03 12:03:00 -0600 | [diff] [blame] | 199 | static constexpr uint8_t kLastInputFlag = (uint8_t)InputFlags::kSnapVerticesToPixelCenters; |
| 200 | |
| 201 | /** This is a continuation of the public "InputFlags" enum. */ |
| 202 | enum class Flags : uint8_t { |
| 203 | kHasStencilClip = (kLastInputFlag << 1), |
| 204 | kStencilEnabled = (kLastInputFlag << 2), |
| 205 | kScissorEnabled = (kLastInputFlag << 3), |
| 206 | kIsBad = (kLastInputFlag << 4), |
bsalomon | 04ddf89 | 2014-11-19 12:36:22 -0800 | [diff] [blame] | 207 | }; |
| 208 | |
Chris Dalton | baa1b35 | 2019-04-03 12:03:00 -0600 | [diff] [blame] | 209 | GR_DECL_BITFIELD_CLASS_OPS_FRIENDS(Flags); |
| 210 | |
| 211 | friend bool operator&(Flags, InputFlags); |
| 212 | |
Brian Salomon | aff329b | 2017-08-11 09:40:37 -0400 | [diff] [blame] | 213 | using FragmentProcessorArray = SkAutoSTArray<8, std::unique_ptr<const GrFragmentProcessor>>; |
Brian Salomon | 18dfa98 | 2017-04-03 16:57:43 -0400 | [diff] [blame] | 214 | |
Robert Phillips | 3d4cac5 | 2019-06-11 08:08:08 -0400 | [diff] [blame] | 215 | GrProxyPendingIO fDstTextureProxy; |
Brian Salomon | 18dfa98 | 2017-04-03 16:57:43 -0400 | [diff] [blame] | 216 | SkIPoint fDstTextureOffset; |
Brian Salomon | 18dfa98 | 2017-04-03 16:57:43 -0400 | [diff] [blame] | 217 | GrWindowRectsState fWindowRectsState; |
| 218 | const GrUserStencilSettings* fUserStencilSettings; |
Chris Dalton | baa1b35 | 2019-04-03 12:03:00 -0600 | [diff] [blame] | 219 | Flags fFlags; |
Brian Salomon | d61c9d9 | 2017-04-10 10:54:25 -0400 | [diff] [blame] | 220 | sk_sp<const GrXferProcessor> fXferProcessor; |
Brian Salomon | 18dfa98 | 2017-04-03 16:57:43 -0400 | [diff] [blame] | 221 | FragmentProcessorArray fFragmentProcessors; |
egdaniel | d9aa218 | 2014-10-09 13:47:05 -0700 | [diff] [blame] | 222 | |
bsalomon | ac856c9 | 2015-08-27 06:30:17 -0700 | [diff] [blame] | 223 | // This value is also the index in fFragmentProcessors where coverage processors begin. |
Brian Salomon | 18dfa98 | 2017-04-03 16:57:43 -0400 | [diff] [blame] | 224 | int fNumColorProcessors; |
Greg Daniel | 2c3398d | 2019-06-19 11:58:01 -0400 | [diff] [blame^] | 225 | |
| 226 | GrSwizzle fOutputSwizzle; |
egdaniel | 3658f38 | 2014-09-15 07:01:59 -0700 | [diff] [blame] | 227 | }; |
| 228 | |
Chris Dalton | baa1b35 | 2019-04-03 12:03:00 -0600 | [diff] [blame] | 229 | GR_MAKE_BITFIELD_CLASS_OPS(GrPipeline::InputFlags); |
| 230 | GR_MAKE_BITFIELD_CLASS_OPS(GrPipeline::Flags); |
| 231 | |
| 232 | inline bool operator&(GrPipeline::Flags flags, GrPipeline::InputFlags inputFlag) { |
| 233 | return (flags & (GrPipeline::Flags)inputFlag); |
| 234 | } |
| 235 | |
egdaniel | 3658f38 | 2014-09-15 07:01:59 -0700 | [diff] [blame] | 236 | #endif |