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 | #include "GrPipeline.h" |
egdaniel | 3658f38 | 2014-09-15 07:01:59 -0700 | [diff] [blame] | 9 | |
Brian Salomon | 652ecb5 | 2017-01-17 12:39:53 -0500 | [diff] [blame] | 10 | #include "GrAppliedClip.h" |
bsalomon | eb1cb5c | 2015-05-22 08:01:09 -0700 | [diff] [blame] | 11 | #include "GrCaps.h" |
joshualitt | 4973d9d | 2014-11-08 09:24:25 -0800 | [diff] [blame] | 12 | #include "GrGpu.h" |
egdaniel | 8dd688b | 2015-01-22 10:16:09 -0800 | [diff] [blame] | 13 | #include "GrPipelineBuilder.h" |
Brian Salomon | 652ecb5 | 2017-01-17 12:39:53 -0500 | [diff] [blame] | 14 | #include "GrRenderTargetContext.h" |
Robert Phillips | f2361d2 | 2016-10-25 14:20:06 -0400 | [diff] [blame] | 15 | #include "GrRenderTargetOpList.h" |
cdalton | 193d9cf | 2016-05-12 11:52:02 -0700 | [diff] [blame] | 16 | #include "GrRenderTargetPriv.h" |
egdaniel | 9513143 | 2014-12-09 11:15:43 -0800 | [diff] [blame] | 17 | #include "GrXferProcessor.h" |
egdaniel | 3658f38 | 2014-09-15 07:01:59 -0700 | [diff] [blame] | 18 | |
Brian Salomon | 8952743 | 2016-12-16 09:52:16 -0500 | [diff] [blame] | 19 | #include "ops/GrOp.h" |
joshualitt | 7441782 | 2015-08-07 11:42:16 -0700 | [diff] [blame] | 20 | |
Brian Salomon | e7d3048 | 2017-03-29 12:09:15 -0400 | [diff] [blame] | 21 | void GrPipeline::init(const InitArgs& args) { |
Brian Salomon | b16e8ac | 2017-02-22 11:52:36 -0500 | [diff] [blame] | 22 | SkASSERT(args.fRenderTarget); |
Brian Salomon | 48d1b4c | 2017-04-08 07:38:53 -0400 | [diff] [blame] | 23 | SkASSERT(args.fProcessors); |
| 24 | SkASSERT(args.fProcessors->isFinalized()); |
Brian Salomon | 92aee3d | 2016-12-21 09:20:25 -0500 | [diff] [blame] | 25 | |
Brian Salomon | b5cb683 | 2017-02-24 11:01:15 -0500 | [diff] [blame] | 26 | fRenderTarget.reset(args.fRenderTarget); |
cdalton | 93a379b | 2016-05-11 13:58:08 -0700 | [diff] [blame] | 27 | |
Brian Salomon | b5cb683 | 2017-02-24 11:01:15 -0500 | [diff] [blame] | 28 | fFlags = args.fFlags; |
Brian Salomon | 54d212e | 2017-03-21 14:22:38 -0400 | [diff] [blame] | 29 | if (args.fAppliedClip) { |
| 30 | fScissorState = args.fAppliedClip->scissorState(); |
| 31 | if (args.fAppliedClip->hasStencilClip()) { |
| 32 | fFlags |= kHasStencilClip_Flag; |
| 33 | } |
| 34 | fWindowRectsState = args.fAppliedClip->windowRectsState(); |
| 35 | } |
Brian Salomon | 189098e7 | 2017-01-19 09:55:19 -0500 | [diff] [blame] | 36 | if (args.fProcessors->usesDistanceVectorField()) { |
Brian Salomon | b5cb683 | 2017-02-24 11:01:15 -0500 | [diff] [blame] | 37 | fFlags |= kUsesDistanceVectorField_Flag; |
dvonbeck | 9b03e7b | 2016-08-01 11:01:56 -0700 | [diff] [blame] | 38 | } |
Brian Salomon | 54d212e | 2017-03-21 14:22:38 -0400 | [diff] [blame] | 39 | if (!args.fUserStencil->isDisabled(fFlags & kHasStencilClip_Flag)) { |
| 40 | fFlags |= kStencilEnabled_Flag; |
| 41 | } |
| 42 | |
| 43 | fUserStencilSettings = args.fUserStencil; |
| 44 | |
Brian Salomon | d61c9d9 | 2017-04-10 10:54:25 -0400 | [diff] [blame] | 45 | fXferProcessor = args.fProcessors->refXferProcessor(); |
Brian Salomon | 189098e7 | 2017-01-19 09:55:19 -0500 | [diff] [blame] | 46 | |
Robert Phillips | c375704 | 2017-05-17 13:00:14 +0000 | [diff] [blame] | 47 | if (args.fDstTexture.texture()) { |
| 48 | fDstTexture.reset(args.fDstTexture.texture()); |
| 49 | fDstTextureOffset = args.fDstTexture.offset(); |
Brian Salomon | 18dfa98 | 2017-04-03 16:57:43 -0400 | [diff] [blame] | 50 | } |
Brian Salomon | 3185384 | 2017-03-28 16:32:05 -0400 | [diff] [blame] | 51 | |
Brian Salomon | eec6f7b | 2017-02-10 14:29:38 -0500 | [diff] [blame] | 52 | // Copy GrFragmentProcessors from GrPipelineBuilder to Pipeline, possibly removing some of the |
| 53 | // color fragment processors. |
Brian Salomon | e14bd80 | 2017-04-04 15:13:25 -0400 | [diff] [blame] | 54 | fNumColorProcessors = args.fProcessors->numColorFragmentProcessors(); |
Brian Salomon | eec6f7b | 2017-02-10 14:29:38 -0500 | [diff] [blame] | 55 | int numTotalProcessors = |
Brian Salomon | b5cb683 | 2017-02-24 11:01:15 -0500 | [diff] [blame] | 56 | fNumColorProcessors + args.fProcessors->numCoverageFragmentProcessors(); |
Brian Salomon | 54d212e | 2017-03-21 14:22:38 -0400 | [diff] [blame] | 57 | if (args.fAppliedClip && args.fAppliedClip->clipCoverageFragmentProcessor()) { |
Brian Salomon | 652ecb5 | 2017-01-17 12:39:53 -0500 | [diff] [blame] | 58 | ++numTotalProcessors; |
| 59 | } |
Brian Salomon | b5cb683 | 2017-02-24 11:01:15 -0500 | [diff] [blame] | 60 | fFragmentProcessors.reset(numTotalProcessors); |
bsalomon | ac856c9 | 2015-08-27 06:30:17 -0700 | [diff] [blame] | 61 | int currFPIdx = 0; |
Brian Salomon | e14bd80 | 2017-04-04 15:13:25 -0400 | [diff] [blame] | 62 | for (int i = 0; i < args.fProcessors->numColorFragmentProcessors(); ++i, ++currFPIdx) { |
Brian Salomon | 189098e7 | 2017-01-19 09:55:19 -0500 | [diff] [blame] | 63 | const GrFragmentProcessor* fp = args.fProcessors->colorFragmentProcessor(i); |
Brian Salomon | b5cb683 | 2017-02-24 11:01:15 -0500 | [diff] [blame] | 64 | fFragmentProcessors[currFPIdx].reset(fp); |
Robert Phillips | a91e0b7 | 2017-05-01 13:12:20 -0400 | [diff] [blame] | 65 | if (fp->isBad()) { |
| 66 | this->markAsBad(); |
| 67 | } |
bsalomon | ae59b77 | 2014-11-19 08:23:49 -0800 | [diff] [blame] | 68 | } |
egdaniel | 9513143 | 2014-12-09 11:15:43 -0800 | [diff] [blame] | 69 | |
Brian Salomon | eec6f7b | 2017-02-10 14:29:38 -0500 | [diff] [blame] | 70 | for (int i = 0; i < args.fProcessors->numCoverageFragmentProcessors(); ++i, ++currFPIdx) { |
Brian Salomon | 189098e7 | 2017-01-19 09:55:19 -0500 | [diff] [blame] | 71 | const GrFragmentProcessor* fp = args.fProcessors->coverageFragmentProcessor(i); |
Brian Salomon | b5cb683 | 2017-02-24 11:01:15 -0500 | [diff] [blame] | 72 | fFragmentProcessors[currFPIdx].reset(fp); |
Robert Phillips | a91e0b7 | 2017-05-01 13:12:20 -0400 | [diff] [blame] | 73 | if (fp->isBad()) { |
| 74 | this->markAsBad(); |
| 75 | } |
egdaniel | 9cf45bf | 2014-10-08 06:49:10 -0700 | [diff] [blame] | 76 | } |
Brian Salomon | 54d212e | 2017-03-21 14:22:38 -0400 | [diff] [blame] | 77 | if (args.fAppliedClip) { |
| 78 | if (const GrFragmentProcessor* fp = args.fAppliedClip->clipCoverageFragmentProcessor()) { |
| 79 | fFragmentProcessors[currFPIdx].reset(fp); |
Robert Phillips | a91e0b7 | 2017-05-01 13:12:20 -0400 | [diff] [blame] | 80 | if (fp->isBad()) { |
| 81 | this->markAsBad(); |
| 82 | } |
Brian Salomon | 54d212e | 2017-03-21 14:22:38 -0400 | [diff] [blame] | 83 | } |
Brian Salomon | 652ecb5 | 2017-01-17 12:39:53 -0500 | [diff] [blame] | 84 | } |
egdaniel | c064824 | 2014-09-22 13:17:02 -0700 | [diff] [blame] | 85 | } |
| 86 | |
Robert Phillips | c589b0b | 2017-04-17 07:53:07 -0400 | [diff] [blame] | 87 | // MDB TODO: re-enable when TextureSamplers store texture proxies |
| 88 | #if 0 |
| 89 | static void add_dependencies_for_processor(const GrFragmentProcessor* proc, |
| 90 | GrRenderTargetProxy* rtp) { |
bsalomon | b58a2b4 | 2016-09-26 06:55:02 -0700 | [diff] [blame] | 91 | GrFragmentProcessor::TextureAccessIter iter(proc); |
Brian Salomon | ab015ef | 2017-04-04 10:15:51 -0400 | [diff] [blame] | 92 | while (const GrResourceIOProcessor::TextureSampler* sampler = iter.next()) { |
Robert Phillips | c589b0b | 2017-04-17 07:53:07 -0400 | [diff] [blame] | 93 | SkASSERT(rtp->getLastOpList()); |
Robert Phillips | c375704 | 2017-05-17 13:00:14 +0000 | [diff] [blame] | 94 | rtp->getLastOpList()->addDependency(sampler->texture()); |
robertphillips | 498d7ac | 2015-10-30 10:11:30 -0700 | [diff] [blame] | 95 | } |
| 96 | } |
Robert Phillips | c589b0b | 2017-04-17 07:53:07 -0400 | [diff] [blame] | 97 | #endif |
robertphillips | 498d7ac | 2015-10-30 10:11:30 -0700 | [diff] [blame] | 98 | |
Robert Phillips | c589b0b | 2017-04-17 07:53:07 -0400 | [diff] [blame] | 99 | void GrPipeline::addDependenciesTo(GrRenderTargetProxy* rtp) const { |
| 100 | // MDB TODO: re-enable when TextureSamplers store texture proxies |
| 101 | #if 0 |
robertphillips | 498d7ac | 2015-10-30 10:11:30 -0700 | [diff] [blame] | 102 | for (int i = 0; i < fFragmentProcessors.count(); ++i) { |
Robert Phillips | c589b0b | 2017-04-17 07:53:07 -0400 | [diff] [blame] | 103 | add_dependencies_for_processor(fFragmentProcessors[i].get(), rtp); |
robertphillips | 498d7ac | 2015-10-30 10:11:30 -0700 | [diff] [blame] | 104 | } |
Robert Phillips | c589b0b | 2017-04-17 07:53:07 -0400 | [diff] [blame] | 105 | #endif |
robertphillips | 498d7ac | 2015-10-30 10:11:30 -0700 | [diff] [blame] | 106 | |
Robert Phillips | c375704 | 2017-05-17 13:00:14 +0000 | [diff] [blame] | 107 | if (fDstTexture) { |
| 108 | //SkASSERT(rtp->getLastOpList()); |
Robert Phillips | c589b0b | 2017-04-17 07:53:07 -0400 | [diff] [blame] | 109 | // MDB TODO: re-enable when TextureSamplers store texture proxies |
| 110 | //rtp->getLastOpList()->addDependency(fDstTexture.get()); |
robertphillips | 498d7ac | 2015-10-30 10:11:30 -0700 | [diff] [blame] | 111 | } |
| 112 | } |
| 113 | |
csmartdalton | 119fb2b | 2017-02-08 14:41:05 -0500 | [diff] [blame] | 114 | GrPipeline::GrPipeline(GrRenderTarget* rt, SkBlendMode blendmode) |
Brian Salomon | d61c9d9 | 2017-04-10 10:54:25 -0400 | [diff] [blame] | 115 | : fRenderTarget(rt) |
| 116 | , fScissorState() |
| 117 | , fWindowRectsState() |
| 118 | , fUserStencilSettings(&GrUserStencilSettings::kUnused) |
Brian Salomon | d61c9d9 | 2017-04-10 10:54:25 -0400 | [diff] [blame] | 119 | , fFlags() |
| 120 | , fXferProcessor(GrPorterDuffXPFactory::MakeNoCoverageXP(blendmode)) |
| 121 | , fFragmentProcessors() |
| 122 | , fNumColorProcessors(0) {} |
csmartdalton | 119fb2b | 2017-02-08 14:41:05 -0500 | [diff] [blame] | 123 | |
egdaniel | 89af44a | 2014-09-26 06:15:04 -0700 | [diff] [blame] | 124 | //////////////////////////////////////////////////////////////////////////////// |
| 125 | |
bsalomon | 7312ff8 | 2016-09-12 08:55:38 -0700 | [diff] [blame] | 126 | bool GrPipeline::AreEqual(const GrPipeline& a, const GrPipeline& b) { |
bsalomon | cb02b38 | 2015-08-12 11:14:50 -0700 | [diff] [blame] | 127 | SkASSERT(&a != &b); |
joshualitt | 8cab9a7 | 2015-07-16 09:13:50 -0700 | [diff] [blame] | 128 | |
bsalomon | cb02b38 | 2015-08-12 11:14:50 -0700 | [diff] [blame] | 129 | if (a.getRenderTarget() != b.getRenderTarget() || |
bsalomon | ac856c9 | 2015-08-27 06:30:17 -0700 | [diff] [blame] | 130 | a.fFragmentProcessors.count() != b.fFragmentProcessors.count() || |
| 131 | a.fNumColorProcessors != b.fNumColorProcessors || |
bsalomon | cb02b38 | 2015-08-12 11:14:50 -0700 | [diff] [blame] | 132 | a.fScissorState != b.fScissorState || |
Brian Salomon | 9a76772 | 2017-03-13 17:57:28 -0400 | [diff] [blame] | 133 | a.fWindowRectsState != b.fWindowRectsState || |
bsalomon | cb02b38 | 2015-08-12 11:14:50 -0700 | [diff] [blame] | 134 | a.fFlags != b.fFlags || |
Robert Phillips | 6410d29 | 2017-05-09 08:15:18 -0400 | [diff] [blame] | 135 | a.fUserStencilSettings != b.fUserStencilSettings) { |
egdaniel | 89af44a | 2014-09-26 06:15:04 -0700 | [diff] [blame] | 136 | return false; |
| 137 | } |
| 138 | |
bsalomon | 2047b78 | 2015-12-21 13:12:54 -0800 | [diff] [blame] | 139 | // Most of the time both are nullptr |
| 140 | if (a.fXferProcessor.get() || b.fXferProcessor.get()) { |
| 141 | if (!a.getXferProcessor().isEqual(b.getXferProcessor())) { |
| 142 | return false; |
| 143 | } |
egdaniel | c230414 | 2014-12-11 13:15:13 -0800 | [diff] [blame] | 144 | } |
| 145 | |
bsalomon | ac856c9 | 2015-08-27 06:30:17 -0700 | [diff] [blame] | 146 | for (int i = 0; i < a.numFragmentProcessors(); i++) { |
bsalomon | 7312ff8 | 2016-09-12 08:55:38 -0700 | [diff] [blame] | 147 | if (!a.getFragmentProcessor(i).isEqual(b.getFragmentProcessor(i))) { |
egdaniel | 89af44a | 2014-09-26 06:15:04 -0700 | [diff] [blame] | 148 | return false; |
| 149 | } |
| 150 | } |
egdaniel | 89af44a | 2014-09-26 06:15:04 -0700 | [diff] [blame] | 151 | return true; |
| 152 | } |