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 | |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 8 | #include "src/gpu/GrPipeline.h" |
egdaniel | 3658f38 | 2014-09-15 07:01:59 -0700 | [diff] [blame] | 9 | |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 10 | #include "src/gpu/GrAppliedClip.h" |
| 11 | #include "src/gpu/GrCaps.h" |
| 12 | #include "src/gpu/GrGpu.h" |
| 13 | #include "src/gpu/GrRenderTargetContext.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 14 | #include "src/gpu/GrXferProcessor.h" |
egdaniel | 3658f38 | 2014-09-15 07:01:59 -0700 | [diff] [blame] | 15 | |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 16 | #include "src/gpu/ops/GrOp.h" |
joshualitt | 7441782 | 2015-08-07 11:42:16 -0700 | [diff] [blame] | 17 | |
Brian Salomon | 4934890 | 2018-06-26 09:12:38 -0400 | [diff] [blame] | 18 | GrPipeline::GrPipeline(const InitArgs& args, |
| 19 | GrProcessorSet&& processors, |
Greg Daniel | 2c3398d | 2019-06-19 11:58:01 -0400 | [diff] [blame] | 20 | GrAppliedClip&& appliedClip) |
| 21 | : fOutputSwizzle(args.fOutputSwizzle) { |
Brian Salomon | 91326c3 | 2017-08-09 16:02:19 -0400 | [diff] [blame] | 22 | SkASSERT(processors.isFinalized()); |
Brian Salomon | 92aee3d | 2016-12-21 09:20:25 -0500 | [diff] [blame] | 23 | |
Chris Dalton | baa1b35 | 2019-04-03 12:03:00 -0600 | [diff] [blame] | 24 | fFlags = (Flags)args.fInputFlags; |
Brian Salomon | bfd18cd | 2017-08-09 16:27:09 -0400 | [diff] [blame] | 25 | if (appliedClip.hasStencilClip()) { |
Chris Dalton | baa1b35 | 2019-04-03 12:03:00 -0600 | [diff] [blame] | 26 | fFlags |= Flags::kHasStencilClip; |
Brian Salomon | 54d212e | 2017-03-21 14:22:38 -0400 | [diff] [blame] | 27 | } |
Brian Salomon | d818ebf | 2018-07-02 14:08:49 +0000 | [diff] [blame] | 28 | if (appliedClip.scissorState().enabled()) { |
Chris Dalton | baa1b35 | 2019-04-03 12:03:00 -0600 | [diff] [blame] | 29 | fFlags |= Flags::kScissorEnabled; |
Brian Salomon | 4934890 | 2018-06-26 09:12:38 -0400 | [diff] [blame] | 30 | } |
| 31 | |
Brian Salomon | bfd18cd | 2017-08-09 16:27:09 -0400 | [diff] [blame] | 32 | fWindowRectsState = appliedClip.windowRectsState(); |
Chris Dalton | baa1b35 | 2019-04-03 12:03:00 -0600 | [diff] [blame] | 33 | if (!args.fUserStencil->isDisabled(fFlags & Flags::kHasStencilClip)) { |
| 34 | fFlags |= Flags::kStencilEnabled; |
Brian Salomon | 54d212e | 2017-03-21 14:22:38 -0400 | [diff] [blame] | 35 | } |
| 36 | |
| 37 | fUserStencilSettings = args.fUserStencil; |
| 38 | |
Brian Salomon | 91326c3 | 2017-08-09 16:02:19 -0400 | [diff] [blame] | 39 | fXferProcessor = processors.refXferProcessor(); |
Brian Salomon | 189098e7 | 2017-01-19 09:55:19 -0500 | [diff] [blame] | 40 | |
Greg Daniel | 524e28b | 2019-11-01 11:48:53 -0400 | [diff] [blame] | 41 | if (args.fDstProxyView.proxy()) { |
Greg Daniel | 524e28b | 2019-11-01 11:48:53 -0400 | [diff] [blame] | 42 | fDstProxyView = args.fDstProxyView.proxyView(); |
| 43 | fDstTextureOffset = args.fDstProxyView.offset(); |
Brian Salomon | 18dfa98 | 2017-04-03 16:57:43 -0400 | [diff] [blame] | 44 | } |
Brian Salomon | 3185384 | 2017-03-28 16:32:05 -0400 | [diff] [blame] | 45 | |
Brian Salomon | e5b399e | 2017-07-19 13:50:54 -0400 | [diff] [blame] | 46 | // Copy GrFragmentProcessors from GrProcessorSet to Pipeline |
Brian Salomon | 91326c3 | 2017-08-09 16:02:19 -0400 | [diff] [blame] | 47 | fNumColorProcessors = processors.numColorFragmentProcessors(); |
Chris Dalton | 6982400 | 2017-10-31 00:37:52 -0600 | [diff] [blame] | 48 | int numTotalProcessors = fNumColorProcessors + |
| 49 | processors.numCoverageFragmentProcessors() + |
| 50 | appliedClip.numClipCoverageFragmentProcessors(); |
Brian Salomon | b5cb683 | 2017-02-24 11:01:15 -0500 | [diff] [blame] | 51 | fFragmentProcessors.reset(numTotalProcessors); |
Robert Phillips | 82774f8 | 2019-06-20 14:38:27 -0400 | [diff] [blame] | 52 | |
bsalomon | ac856c9 | 2015-08-27 06:30:17 -0700 | [diff] [blame] | 53 | int currFPIdx = 0; |
Brian Salomon | 91326c3 | 2017-08-09 16:02:19 -0400 | [diff] [blame] | 54 | for (int i = 0; i < processors.numColorFragmentProcessors(); ++i, ++currFPIdx) { |
Brian Salomon | aff329b | 2017-08-11 09:40:37 -0400 | [diff] [blame] | 55 | fFragmentProcessors[currFPIdx] = processors.detachColorFragmentProcessor(i); |
bsalomon | ae59b77 | 2014-11-19 08:23:49 -0800 | [diff] [blame] | 56 | } |
Brian Salomon | 91326c3 | 2017-08-09 16:02:19 -0400 | [diff] [blame] | 57 | for (int i = 0; i < processors.numCoverageFragmentProcessors(); ++i, ++currFPIdx) { |
Brian Salomon | aff329b | 2017-08-11 09:40:37 -0400 | [diff] [blame] | 58 | fFragmentProcessors[currFPIdx] = processors.detachCoverageFragmentProcessor(i); |
egdaniel | 9cf45bf | 2014-10-08 06:49:10 -0700 | [diff] [blame] | 59 | } |
Chris Dalton | 6982400 | 2017-10-31 00:37:52 -0600 | [diff] [blame] | 60 | for (int i = 0; i < appliedClip.numClipCoverageFragmentProcessors(); ++i, ++currFPIdx) { |
| 61 | fFragmentProcessors[currFPIdx] = appliedClip.detachClipCoverageFragmentProcessor(i); |
Robert Phillips | 82774f8 | 2019-06-20 14:38:27 -0400 | [diff] [blame] | 62 | } |
egdaniel | c064824 | 2014-09-22 13:17:02 -0700 | [diff] [blame] | 63 | } |
| 64 | |
Robert Phillips | d0fe875 | 2019-01-31 14:13:59 -0500 | [diff] [blame] | 65 | GrXferBarrierType GrPipeline::xferBarrierType(GrTexture* texture, const GrCaps& caps) const { |
Greg Daniel | 524e28b | 2019-11-01 11:48:53 -0400 | [diff] [blame] | 66 | auto proxy = fDstProxyView.proxy(); |
| 67 | if (proxy && proxy->peekTexture() == texture) { |
Robert Phillips | c9c06d4 | 2017-06-12 10:58:31 -0400 | [diff] [blame] | 68 | return kTexture_GrXferBarrierType; |
| 69 | } |
| 70 | return this->getXferProcessor().xferBarrierType(caps); |
| 71 | } |
| 72 | |
Chris Dalton | c3318f0 | 2019-07-19 14:20:53 -0600 | [diff] [blame] | 73 | GrPipeline::GrPipeline(GrScissorTest scissorTest, sk_sp<const GrXferProcessor> xp, |
Greg Daniel | 2c3398d | 2019-06-19 11:58:01 -0400 | [diff] [blame] | 74 | const GrSwizzle& outputSwizzle, InputFlags inputFlags, |
Chris Dalton | d7291ba | 2019-03-07 14:17:03 -0700 | [diff] [blame] | 75 | const GrUserStencilSettings* userStencil) |
Robert Phillips | d0fe875 | 2019-01-31 14:13:59 -0500 | [diff] [blame] | 76 | : fWindowRectsState() |
Chris Dalton | d7291ba | 2019-03-07 14:17:03 -0700 | [diff] [blame] | 77 | , fUserStencilSettings(userStencil) |
Chris Dalton | baa1b35 | 2019-04-03 12:03:00 -0600 | [diff] [blame] | 78 | , fFlags((Flags)inputFlags) |
Chris Dalton | c3318f0 | 2019-07-19 14:20:53 -0600 | [diff] [blame] | 79 | , fXferProcessor(std::move(xp)) |
Robert Phillips | 2890fbf | 2017-07-26 15:48:41 -0400 | [diff] [blame] | 80 | , fFragmentProcessors() |
Greg Daniel | 2c3398d | 2019-06-19 11:58:01 -0400 | [diff] [blame] | 81 | , fNumColorProcessors(0) |
| 82 | , fOutputSwizzle(outputSwizzle) { |
Chris Dalton | 916c498 | 2018-08-15 00:53:25 -0600 | [diff] [blame] | 83 | if (GrScissorTest::kEnabled == scissorTest) { |
Chris Dalton | baa1b35 | 2019-04-03 12:03:00 -0600 | [diff] [blame] | 84 | fFlags |= Flags::kScissorEnabled; |
Chris Dalton | 46983b7 | 2017-06-06 12:27:16 -0600 | [diff] [blame] | 85 | } |
Chris Dalton | d7291ba | 2019-03-07 14:17:03 -0700 | [diff] [blame] | 86 | if (!userStencil->isDisabled(false)) { |
Chris Dalton | baa1b35 | 2019-04-03 12:03:00 -0600 | [diff] [blame] | 87 | fFlags |= Flags::kStencilEnabled; |
Chris Dalton | d7291ba | 2019-03-07 14:17:03 -0700 | [diff] [blame] | 88 | } |
Chris Dalton | 46983b7 | 2017-06-06 12:27:16 -0600 | [diff] [blame] | 89 | } |
Jim Van Verth | 1223e7f | 2019-02-28 17:38:35 -0500 | [diff] [blame] | 90 | |
Chris Dalton | b204e4c | 2019-11-07 12:43:13 -0700 | [diff] [blame] | 91 | void GrPipeline::genKey(GrProcessorKeyBuilder* b, const GrCaps& caps) const { |
| 92 | // kSnapVerticesToPixelCenters is implemented in a shader. |
| 93 | InputFlags ignoredFlags = InputFlags::kSnapVerticesToPixelCenters; |
| 94 | if (!caps.multisampleDisableSupport()) { |
| 95 | // Ganesh will omit kHWAntialias regardless multisampleDisableSupport. |
| 96 | ignoredFlags |= InputFlags::kHWAntialias; |
| 97 | } |
| 98 | b->add32((uint32_t)fFlags & ~(uint32_t)ignoredFlags); |
| 99 | |
Chris Dalton | bbb3f64 | 2019-07-24 12:25:08 -0400 | [diff] [blame] | 100 | const GrXferProcessor::BlendInfo& blendInfo = this->getXferProcessor().getBlendInfo(); |
Jim Van Verth | 1223e7f | 2019-02-28 17:38:35 -0500 | [diff] [blame] | 101 | |
| 102 | static const uint32_t kBlendWriteShift = 1; |
| 103 | static const uint32_t kBlendCoeffShift = 5; |
Brian Salomon | b0047b5 | 2019-12-05 19:52:25 +0000 | [diff] [blame] | 104 | GR_STATIC_ASSERT(kLast_GrBlendCoeff < (1 << kBlendCoeffShift)); |
| 105 | GR_STATIC_ASSERT(kFirstAdvancedGrBlendEquation - 1 < 4); |
Jim Van Verth | 1223e7f | 2019-02-28 17:38:35 -0500 | [diff] [blame] | 106 | |
Chris Dalton | b204e4c | 2019-11-07 12:43:13 -0700 | [diff] [blame] | 107 | uint32_t blendKey = blendInfo.fWriteColor; |
| 108 | blendKey |= (blendInfo.fSrcBlend << kBlendWriteShift); |
| 109 | blendKey |= (blendInfo.fDstBlend << (kBlendWriteShift + kBlendCoeffShift)); |
| 110 | blendKey |= (blendInfo.fEquation << (kBlendWriteShift + 2 * kBlendCoeffShift)); |
Jim Van Verth | 1223e7f | 2019-02-28 17:38:35 -0500 | [diff] [blame] | 111 | |
Chris Dalton | b204e4c | 2019-11-07 12:43:13 -0700 | [diff] [blame] | 112 | b->add32(blendKey); |
Jim Van Verth | 1223e7f | 2019-02-28 17:38:35 -0500 | [diff] [blame] | 113 | } |
Brian Salomon | c241b58 | 2019-11-27 08:57:17 -0500 | [diff] [blame] | 114 | |
| 115 | void GrPipeline::visitProxies(const GrOp::VisitProxyFunc& func) const { |
| 116 | // This iteration includes any clip coverage FPs |
| 117 | for (auto [sampler, fp] : GrFragmentProcessor::PipelineTextureSamplerRange(*this)) { |
| 118 | bool mipped = (GrSamplerState::Filter::kMipMap == sampler.samplerState().filter()); |
Robert Phillips | bd99c0c | 2019-12-12 13:26:58 +0000 | [diff] [blame^] | 119 | func(sampler.view().proxy(), GrMipMapped(mipped)); |
Brian Salomon | c241b58 | 2019-11-27 08:57:17 -0500 | [diff] [blame] | 120 | } |
| 121 | if (fDstProxyView.asTextureProxy()) { |
| 122 | func(fDstProxyView.asTextureProxy(), GrMipMapped::kNo); |
| 123 | } |
| 124 | } |