reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 1 | /* |
epoger@google.com | ec3ed6a | 2011-07-28 14:26:00 +0000 | [diff] [blame] | 2 | * Copyright 2010 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. |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 6 | */ |
| 7 | |
Robert Phillips | f2361d2 | 2016-10-25 14:20:06 -0400 | [diff] [blame] | 8 | #include "GrRenderTargetOpList.h" |
joshualitt | 086cee1 | 2016-01-12 06:45:24 -0800 | [diff] [blame] | 9 | #include "GrAuditTrail.h" |
bsalomon | eb1cb5c | 2015-05-22 08:01:09 -0700 | [diff] [blame] | 10 | #include "GrCaps.h" |
bsalomon | 4061b12 | 2015-05-29 10:26:19 -0700 | [diff] [blame] | 11 | #include "GrGpu.h" |
egdaniel | 9cb6340 | 2016-06-23 08:37:05 -0700 | [diff] [blame] | 12 | #include "GrGpuCommandBuffer.h" |
Robert Phillips | 7c525e6 | 2018-06-12 10:11:12 -0400 | [diff] [blame] | 13 | #include "GrMemoryPool.h" |
Brian Salomon | a4677b5 | 2017-05-04 12:39:56 -0400 | [diff] [blame] | 14 | #include "GrRect.h" |
Brian Salomon | 467921e | 2017-03-06 16:17:12 -0500 | [diff] [blame] | 15 | #include "GrRenderTargetContext.h" |
Robert Phillips | d375dbf | 2017-09-14 12:45:25 -0400 | [diff] [blame] | 16 | #include "GrResourceAllocator.h" |
Brian Salomon | 8952743 | 2016-12-16 09:52:16 -0500 | [diff] [blame] | 17 | #include "ops/GrClearOp.h" |
Brian Salomon | 8952743 | 2016-12-16 09:52:16 -0500 | [diff] [blame] | 18 | #include "ops/GrCopySurfaceOp.h" |
Stan Iliev | 2af578d | 2017-08-16 13:00:28 -0400 | [diff] [blame] | 19 | #include "SkTraceEvent.h" |
csmartdalton | a7f2964 | 2016-07-07 08:49:11 -0700 | [diff] [blame] | 20 | |
Robert Phillips | f2361d2 | 2016-10-25 14:20:06 -0400 | [diff] [blame] | 21 | |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 22 | //////////////////////////////////////////////////////////////////////////////// |
| 23 | |
Brian Salomon | 09d994e | 2016-12-21 11:14:46 -0500 | [diff] [blame] | 24 | // Experimentally we have found that most combining occurs within the first 10 comparisons. |
Robert Phillips | 8185f59 | 2017-04-26 08:31:08 -0400 | [diff] [blame] | 25 | static const int kMaxOpLookback = 10; |
| 26 | static const int kMaxOpLookahead = 10; |
bsalomon | 489147c | 2015-12-14 12:13:09 -0800 | [diff] [blame] | 27 | |
Robert Phillips | 3a9710b | 2018-03-27 17:51:55 -0400 | [diff] [blame] | 28 | GrRenderTargetOpList::GrRenderTargetOpList(GrResourceProvider* resourceProvider, |
Robert Phillips | c994a93 | 2018-06-19 13:09:54 -0400 | [diff] [blame] | 29 | sk_sp<GrOpMemoryPool> opMemoryPool, |
Robert Phillips | 3a9710b | 2018-03-27 17:51:55 -0400 | [diff] [blame] | 30 | GrRenderTargetProxy* proxy, |
Robert Phillips | 8185f59 | 2017-04-26 08:31:08 -0400 | [diff] [blame] | 31 | GrAuditTrail* auditTrail) |
Robert Phillips | c994a93 | 2018-06-19 13:09:54 -0400 | [diff] [blame] | 32 | : INHERITED(resourceProvider, std::move(opMemoryPool), proxy, auditTrail) |
Brian Salomon | c3833b4 | 2018-07-09 18:23:58 +0000 | [diff] [blame] | 33 | , fLastClipStackGenID(SK_InvalidUniqueID) |
Robert Phillips | b6deea8 | 2017-05-11 14:14:30 -0400 | [diff] [blame] | 34 | SkDEBUGCODE(, fNumClips(0)) { |
bsalomon | 4061b12 | 2015-05-29 10:26:19 -0700 | [diff] [blame] | 35 | } |
| 36 | |
Robert Phillips | c994a93 | 2018-06-19 13:09:54 -0400 | [diff] [blame] | 37 | void GrRenderTargetOpList::RecordedOp::deleteOp(GrOpMemoryPool* opMemoryPool) { |
| 38 | opMemoryPool->release(std::move(fOp)); |
| 39 | } |
| 40 | |
| 41 | void GrRenderTargetOpList::deleteOps() { |
| 42 | for (int i = 0; i < fRecordedOps.count(); ++i) { |
| 43 | if (fRecordedOps[i].fOp) { |
| 44 | fRecordedOps[i].deleteOp(fOpMemoryPool.get()); |
| 45 | } |
| 46 | } |
| 47 | fRecordedOps.reset(); |
| 48 | } |
| 49 | |
Robert Phillips | f2361d2 | 2016-10-25 14:20:06 -0400 | [diff] [blame] | 50 | GrRenderTargetOpList::~GrRenderTargetOpList() { |
Robert Phillips | c994a93 | 2018-06-19 13:09:54 -0400 | [diff] [blame] | 51 | this->deleteOps(); |
bsalomon@google.com | 25fb21f | 2011-06-21 18:17:25 +0000 | [diff] [blame] | 52 | } |
| 53 | |
| 54 | //////////////////////////////////////////////////////////////////////////////// |
| 55 | |
robertphillips | 4beb5c1 | 2015-10-20 07:50:00 -0700 | [diff] [blame] | 56 | #ifdef SK_DEBUG |
Robert Phillips | 2748391 | 2018-04-20 12:43:18 -0400 | [diff] [blame] | 57 | void GrRenderTargetOpList::dump(bool printDependencies) const { |
| 58 | INHERITED::dump(printDependencies); |
Robert Phillips | f2361d2 | 2016-10-25 14:20:06 -0400 | [diff] [blame] | 59 | |
Brian Salomon | 1e41f4a | 2016-12-07 15:05:04 -0500 | [diff] [blame] | 60 | SkDebugf("ops (%d):\n", fRecordedOps.count()); |
| 61 | for (int i = 0; i < fRecordedOps.count(); ++i) { |
robertphillips | 4beb5c1 | 2015-10-20 07:50:00 -0700 | [diff] [blame] | 62 | SkDebugf("*******************************\n"); |
Brian Salomon | 1e41f4a | 2016-12-07 15:05:04 -0500 | [diff] [blame] | 63 | if (!fRecordedOps[i].fOp) { |
Greg Daniel | aa3dfbe | 2018-01-29 10:34:25 -0500 | [diff] [blame] | 64 | SkDebugf("%d: <combined forward or failed instantiation>\n", i); |
bsalomon | aecc018 | 2016-03-07 11:50:44 -0800 | [diff] [blame] | 65 | } else { |
Brian Salomon | 1e41f4a | 2016-12-07 15:05:04 -0500 | [diff] [blame] | 66 | SkDebugf("%d: %s\n", i, fRecordedOps[i].fOp->name()); |
| 67 | SkString str = fRecordedOps[i].fOp->dumpInfo(); |
bsalomon | aecc018 | 2016-03-07 11:50:44 -0800 | [diff] [blame] | 68 | SkDebugf("%s\n", str.c_str()); |
Brian Salomon | 9e50f7b | 2017-03-06 12:02:34 -0500 | [diff] [blame] | 69 | const SkRect& bounds = fRecordedOps[i].fOp->bounds(); |
| 70 | SkDebugf("ClippedBounds: [L: %.2f, T: %.2f, R: %.2f, B: %.2f]\n", bounds.fLeft, |
| 71 | bounds.fTop, bounds.fRight, bounds.fBottom); |
bsalomon | aecc018 | 2016-03-07 11:50:44 -0800 | [diff] [blame] | 72 | } |
robertphillips | 4beb5c1 | 2015-10-20 07:50:00 -0700 | [diff] [blame] | 73 | } |
| 74 | } |
Chris Dalton | 706a6ff | 2017-11-29 22:01:06 -0700 | [diff] [blame] | 75 | |
| 76 | void GrRenderTargetOpList::visitProxies_debugOnly(const GrOp::VisitProxyFunc& func) const { |
| 77 | for (const RecordedOp& recordedOp : fRecordedOps) { |
| 78 | recordedOp.visitProxies(func); |
| 79 | } |
| 80 | } |
robertphillips | 4beb5c1 | 2015-10-20 07:50:00 -0700 | [diff] [blame] | 81 | #endif |
| 82 | |
Brian Osman | 407b342 | 2017-08-22 15:01:32 -0400 | [diff] [blame] | 83 | void GrRenderTargetOpList::onPrepare(GrOpFlushState* flushState) { |
Brian Salomon | fd98c2c | 2018-07-31 17:25:29 -0400 | [diff] [blame] | 84 | SkASSERT(fTarget.get()->peekRenderTarget()); |
Robert Phillips | 6cdc22c | 2017-05-11 16:29:14 -0400 | [diff] [blame] | 85 | SkASSERT(this->isClosed()); |
Stan Iliev | 2af578d | 2017-08-16 13:00:28 -0400 | [diff] [blame] | 86 | #ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK |
| 87 | TRACE_EVENT0("skia", TRACE_FUNC); |
| 88 | #endif |
robertphillips | a106c62 | 2015-10-16 09:07:06 -0700 | [diff] [blame] | 89 | |
Brian Salomon | 1e41f4a | 2016-12-07 15:05:04 -0500 | [diff] [blame] | 90 | // Loop over the ops that haven't yet been prepared. |
| 91 | for (int i = 0; i < fRecordedOps.count(); ++i) { |
Brian Salomon | d25f5bc | 2018-08-08 11:25:17 -0400 | [diff] [blame] | 92 | if (fRecordedOps[i].fOp && fRecordedOps[i].fOp->isChainHead()) { |
Stan Iliev | 2af578d | 2017-08-16 13:00:28 -0400 | [diff] [blame] | 93 | #ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK |
| 94 | TRACE_EVENT0("skia", fRecordedOps[i].fOp->name()); |
| 95 | #endif |
Brian Salomon | 29b60c9 | 2017-10-31 14:42:10 -0400 | [diff] [blame] | 96 | GrOpFlushState::OpArgs opArgs = { |
| 97 | fRecordedOps[i].fOp.get(), |
Robert Phillips | 2890fbf | 2017-07-26 15:48:41 -0400 | [diff] [blame] | 98 | fTarget.get()->asRenderTargetProxy(), |
Robert Phillips | 318c419 | 2017-05-17 09:36:38 -0400 | [diff] [blame] | 99 | fRecordedOps[i].fAppliedClip, |
Robert Phillips | bb581ce | 2017-05-29 15:05:15 -0400 | [diff] [blame] | 100 | fRecordedOps[i].fDstProxy |
Robert Phillips | 318c419 | 2017-05-17 09:36:38 -0400 | [diff] [blame] | 101 | }; |
| 102 | |
Brian Salomon | 29b60c9 | 2017-10-31 14:42:10 -0400 | [diff] [blame] | 103 | flushState->setOpArgs(&opArgs); |
Brian Salomon | 1e41f4a | 2016-12-07 15:05:04 -0500 | [diff] [blame] | 104 | fRecordedOps[i].fOp->prepare(flushState); |
Brian Salomon | 29b60c9 | 2017-10-31 14:42:10 -0400 | [diff] [blame] | 105 | flushState->setOpArgs(nullptr); |
bsalomon | aecc018 | 2016-03-07 11:50:44 -0800 | [diff] [blame] | 106 | } |
bsalomon | 512be53 | 2015-09-10 10:42:55 -0700 | [diff] [blame] | 107 | } |
robertphillips | a13e202 | 2015-11-11 12:01:09 -0800 | [diff] [blame] | 108 | } |
bsalomon | 512be53 | 2015-09-10 10:42:55 -0700 | [diff] [blame] | 109 | |
Robert Phillips | 5b5d84c | 2018-08-09 15:12:18 -0400 | [diff] [blame] | 110 | static GrGpuRTCommandBuffer* create_command_buffer(GrGpu* gpu, |
| 111 | GrRenderTarget* rt, |
| 112 | GrSurfaceOrigin origin, |
| 113 | GrLoadOp colorLoadOp, |
| 114 | GrColor loadClearColor, |
| 115 | GrLoadOp stencilLoadOp) { |
Robert Phillips | cb2e235 | 2017-08-30 16:44:40 -0400 | [diff] [blame] | 116 | const GrGpuRTCommandBuffer::LoadAndStoreInfo kColorLoadStoreInfo { |
Robert Phillips | 6b47c7d | 2017-08-29 07:24:09 -0400 | [diff] [blame] | 117 | colorLoadOp, |
| 118 | GrStoreOp::kStore, |
| 119 | loadClearColor |
Robert Phillips | 178ce3e | 2017-04-13 09:15:47 -0400 | [diff] [blame] | 120 | }; |
| 121 | |
Robert Phillips | 9521447 | 2017-08-08 18:00:03 -0400 | [diff] [blame] | 122 | // TODO: |
| 123 | // We would like to (at this level) only ever clear & discard. We would need |
| 124 | // to stop splitting up higher level opLists for copyOps to achieve that. |
| 125 | // Note: we would still need SB loads and stores but they would happen at a |
| 126 | // lower level (inside the VK command buffer). |
Greg Daniel | 500d58b | 2017-08-24 15:59:33 -0400 | [diff] [blame] | 127 | const GrGpuRTCommandBuffer::StencilLoadAndStoreInfo stencilLoadAndStoreInfo { |
Robert Phillips | 6b47c7d | 2017-08-29 07:24:09 -0400 | [diff] [blame] | 128 | stencilLoadOp, |
| 129 | GrStoreOp::kStore, |
Robert Phillips | 9521447 | 2017-08-08 18:00:03 -0400 | [diff] [blame] | 130 | }; |
| 131 | |
Robert Phillips | 5b5d84c | 2018-08-09 15:12:18 -0400 | [diff] [blame] | 132 | return gpu->getCommandBuffer(rt, origin, kColorLoadStoreInfo, stencilLoadAndStoreInfo); |
Robert Phillips | 178ce3e | 2017-04-13 09:15:47 -0400 | [diff] [blame] | 133 | } |
| 134 | |
Brian Salomon | 25a8809 | 2016-12-01 09:36:50 -0500 | [diff] [blame] | 135 | // TODO: this is where GrOp::renderTarget is used (which is fine since it |
Robert Phillips | 294870f | 2016-11-11 12:38:40 -0500 | [diff] [blame] | 136 | // is at flush time). However, we need to store the RenderTargetProxy in the |
Brian Salomon | 1e41f4a | 2016-12-07 15:05:04 -0500 | [diff] [blame] | 137 | // Ops and instantiate them here. |
Brian Osman | 407b342 | 2017-08-22 15:01:32 -0400 | [diff] [blame] | 138 | bool GrRenderTargetOpList::onExecute(GrOpFlushState* flushState) { |
Greg Daniel | dbdba60 | 2018-04-20 11:52:43 -0400 | [diff] [blame] | 139 | // TODO: Forcing the execution of the discard here isn't ideal since it will cause us to do a |
| 140 | // discard and then store the data back in memory so that the load op on future draws doesn't |
| 141 | // think the memory is unitialized. Ideally we would want a system where we are tracking whether |
| 142 | // the proxy itself has valid data or not, and then use that as a signal on whether we should be |
| 143 | // loading or discarding. In that world we wouldni;t need to worry about executing oplists with |
| 144 | // no ops just to do a discard. |
| 145 | if (0 == fRecordedOps.count() && GrLoadOp::kClear != fColorLoadOp && |
| 146 | GrLoadOp::kDiscard != fColorLoadOp) { |
bsalomon | dc43898 | 2016-08-31 11:53:49 -0700 | [diff] [blame] | 147 | return false; |
egdaniel | b4021cf | 2016-07-28 08:53:07 -0700 | [diff] [blame] | 148 | } |
Robert Phillips | 4a39504 | 2017-04-24 16:27:17 +0000 | [diff] [blame] | 149 | |
Brian Salomon | fd98c2c | 2018-07-31 17:25:29 -0400 | [diff] [blame] | 150 | SkASSERT(fTarget.get()->peekRenderTarget()); |
Stan Iliev | 2af578d | 2017-08-16 13:00:28 -0400 | [diff] [blame] | 151 | TRACE_EVENT0("skia", TRACE_FUNC); |
Robert Phillips | 6cdc22c | 2017-05-11 16:29:14 -0400 | [diff] [blame] | 152 | |
Robert Phillips | 6b47c7d | 2017-08-29 07:24:09 -0400 | [diff] [blame] | 153 | // TODO: at the very least, we want the stencil store op to always be discard (at this |
| 154 | // level). In Vulkan, sub-command buffers would still need to load & store the stencil buffer. |
Robert Phillips | 5b5d84c | 2018-08-09 15:12:18 -0400 | [diff] [blame] | 155 | GrGpuRTCommandBuffer* commandBuffer = create_command_buffer( |
Robert Phillips | 9521447 | 2017-08-08 18:00:03 -0400 | [diff] [blame] | 156 | flushState->gpu(), |
Brian Salomon | fd98c2c | 2018-07-31 17:25:29 -0400 | [diff] [blame] | 157 | fTarget.get()->peekRenderTarget(), |
Robert Phillips | 9521447 | 2017-08-08 18:00:03 -0400 | [diff] [blame] | 158 | fTarget.get()->origin(), |
Brian Salomon | fd98c2c | 2018-07-31 17:25:29 -0400 | [diff] [blame] | 159 | fColorLoadOp, |
| 160 | fLoadClearColor, |
Robert Phillips | 6b47c7d | 2017-08-29 07:24:09 -0400 | [diff] [blame] | 161 | fStencilLoadOp); |
Robert Phillips | 5b5d84c | 2018-08-09 15:12:18 -0400 | [diff] [blame] | 162 | flushState->setCommandBuffer(commandBuffer); |
Robert Phillips | 9521447 | 2017-08-08 18:00:03 -0400 | [diff] [blame] | 163 | commandBuffer->begin(); |
Robert Phillips | 6cdc22c | 2017-05-11 16:29:14 -0400 | [diff] [blame] | 164 | |
| 165 | // Draw all the generated geometry. |
Brian Salomon | 1e41f4a | 2016-12-07 15:05:04 -0500 | [diff] [blame] | 166 | for (int i = 0; i < fRecordedOps.count(); ++i) { |
Brian Salomon | d25f5bc | 2018-08-08 11:25:17 -0400 | [diff] [blame] | 167 | if (!fRecordedOps[i].fOp || !fRecordedOps[i].fOp->isChainHead()) { |
bsalomon | aecc018 | 2016-03-07 11:50:44 -0800 | [diff] [blame] | 168 | continue; |
| 169 | } |
Stan Iliev | 2af578d | 2017-08-16 13:00:28 -0400 | [diff] [blame] | 170 | #ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK |
| 171 | TRACE_EVENT0("skia", fRecordedOps[i].fOp->name()); |
| 172 | #endif |
Robert Phillips | 178ce3e | 2017-04-13 09:15:47 -0400 | [diff] [blame] | 173 | |
Brian Salomon | 29b60c9 | 2017-10-31 14:42:10 -0400 | [diff] [blame] | 174 | GrOpFlushState::OpArgs opArgs { |
| 175 | fRecordedOps[i].fOp.get(), |
Robert Phillips | 2890fbf | 2017-07-26 15:48:41 -0400 | [diff] [blame] | 176 | fTarget.get()->asRenderTargetProxy(), |
Robert Phillips | 178ce3e | 2017-04-13 09:15:47 -0400 | [diff] [blame] | 177 | fRecordedOps[i].fAppliedClip, |
Robert Phillips | bb581ce | 2017-05-29 15:05:15 -0400 | [diff] [blame] | 178 | fRecordedOps[i].fDstProxy |
Robert Phillips | 178ce3e | 2017-04-13 09:15:47 -0400 | [diff] [blame] | 179 | }; |
| 180 | |
Brian Salomon | 29b60c9 | 2017-10-31 14:42:10 -0400 | [diff] [blame] | 181 | flushState->setOpArgs(&opArgs); |
Brian Salomon | 9e50f7b | 2017-03-06 12:02:34 -0500 | [diff] [blame] | 182 | fRecordedOps[i].fOp->execute(flushState); |
Brian Salomon | 29b60c9 | 2017-10-31 14:42:10 -0400 | [diff] [blame] | 183 | flushState->setOpArgs(nullptr); |
bsalomon | 512be53 | 2015-09-10 10:42:55 -0700 | [diff] [blame] | 184 | } |
Robert Phillips | 178ce3e | 2017-04-13 09:15:47 -0400 | [diff] [blame] | 185 | |
Robert Phillips | 5b5d84c | 2018-08-09 15:12:18 -0400 | [diff] [blame] | 186 | commandBuffer->end(); |
| 187 | flushState->gpu()->submit(commandBuffer); |
Robert Phillips | 178ce3e | 2017-04-13 09:15:47 -0400 | [diff] [blame] | 188 | flushState->setCommandBuffer(nullptr); |
ethannicholas | 2279325 | 2016-01-30 09:59:10 -0800 | [diff] [blame] | 189 | |
bsalomon | dc43898 | 2016-08-31 11:53:49 -0700 | [diff] [blame] | 190 | return true; |
bsalomon | a73239a | 2015-04-28 13:35:17 -0700 | [diff] [blame] | 191 | } |
| 192 | |
Chris Dalton | a84cacf | 2017-10-04 10:30:29 -0600 | [diff] [blame] | 193 | void GrRenderTargetOpList::endFlush() { |
Brian Salomon | c3833b4 | 2018-07-09 18:23:58 +0000 | [diff] [blame] | 194 | fLastClipStackGenID = SK_InvalidUniqueID; |
Robert Phillips | c994a93 | 2018-06-19 13:09:54 -0400 | [diff] [blame] | 195 | this->deleteOps(); |
Chris Dalton | c82dd4e | 2017-11-20 18:20:28 -0700 | [diff] [blame] | 196 | fClipAllocator.reset(); |
Chris Dalton | a84cacf | 2017-10-04 10:30:29 -0600 | [diff] [blame] | 197 | INHERITED::endFlush(); |
bsalomon | 512be53 | 2015-09-10 10:42:55 -0700 | [diff] [blame] | 198 | } |
| 199 | |
Robert Phillips | 380b90c | 2017-08-30 07:41:07 -0400 | [diff] [blame] | 200 | void GrRenderTargetOpList::discard() { |
| 201 | // Discard calls to in-progress opLists are ignored. Calls at the start update the |
| 202 | // opLists' color & stencil load ops. |
| 203 | if (this->isEmpty()) { |
| 204 | fColorLoadOp = GrLoadOp::kDiscard; |
| 205 | fStencilLoadOp = GrLoadOp::kDiscard; |
| 206 | } |
| 207 | } |
| 208 | |
Robert Phillips | 7c525e6 | 2018-06-12 10:11:12 -0400 | [diff] [blame] | 209 | void GrRenderTargetOpList::fullClear(GrContext* context, GrColor color) { |
Robert Phillips | 380b90c | 2017-08-30 07:41:07 -0400 | [diff] [blame] | 210 | |
| 211 | // This is conservative. If the opList is marked as needing a stencil buffer then there |
| 212 | // may be a prior op that writes to the stencil buffer. Although the clear will ignore the |
| 213 | // stencil buffer, following draw ops may not so we can't get rid of all the preceding ops. |
| 214 | // Beware! If we ever add any ops that have a side effect beyond modifying the stencil |
| 215 | // buffer we will need a more elaborate tracking system (skbug.com/7002). |
| 216 | if (this->isEmpty() || !fTarget.get()->asRenderTargetProxy()->needsStencil()) { |
Robert Phillips | c994a93 | 2018-06-19 13:09:54 -0400 | [diff] [blame] | 217 | this->deleteOps(); |
Brian Osman | 099fa0f | 2017-10-02 16:38:32 -0400 | [diff] [blame] | 218 | fDeferredProxies.reset(); |
Robert Phillips | 380b90c | 2017-08-30 07:41:07 -0400 | [diff] [blame] | 219 | fColorLoadOp = GrLoadOp::kClear; |
| 220 | fLoadClearColor = color; |
bsalomon | fd8d013 | 2016-08-11 11:25:33 -0700 | [diff] [blame] | 221 | return; |
| 222 | } |
Robert Phillips | 380b90c | 2017-08-30 07:41:07 -0400 | [diff] [blame] | 223 | |
Robert Phillips | 7c525e6 | 2018-06-12 10:11:12 -0400 | [diff] [blame] | 224 | std::unique_ptr<GrClearOp> op(GrClearOp::Make(context, GrFixedClip::Disabled(), |
| 225 | color, fTarget.get())); |
Robert Phillips | f7a7261 | 2017-03-31 10:03:45 -0400 | [diff] [blame] | 226 | if (!op) { |
| 227 | return; |
| 228 | } |
Robert Phillips | 5efd5ea | 2017-05-30 13:47:32 -0400 | [diff] [blame] | 229 | |
Robert Phillips | 7c525e6 | 2018-06-12 10:11:12 -0400 | [diff] [blame] | 230 | this->recordOp(std::move(op), *context->contextPriv().caps()); |
bsalomon | 9f129de | 2016-08-10 16:31:05 -0700 | [diff] [blame] | 231 | } |
| 232 | |
bsalomon@google.com | 25fb21f | 2011-06-21 18:17:25 +0000 | [diff] [blame] | 233 | //////////////////////////////////////////////////////////////////////////////// |
bsalomon@google.com | 86afc2a | 2011-02-16 16:12:19 +0000 | [diff] [blame] | 234 | |
Robert Phillips | 81dd3e0 | 2017-06-23 11:59:24 -0400 | [diff] [blame] | 235 | // This closely parallels GrTextureOpList::copySurface but renderTargetOpLists |
| 236 | // also store the applied clip and dest proxy with the op |
Robert Phillips | 7c525e6 | 2018-06-12 10:11:12 -0400 | [diff] [blame] | 237 | bool GrRenderTargetOpList::copySurface(GrContext* context, |
Robert Phillips | a16f6cb | 2017-06-01 11:06:13 -0400 | [diff] [blame] | 238 | GrSurfaceProxy* dst, |
Robert Phillips | bf25d43 | 2017-04-07 10:08:53 -0400 | [diff] [blame] | 239 | GrSurfaceProxy* src, |
Robert Phillips | f2361d2 | 2016-10-25 14:20:06 -0400 | [diff] [blame] | 240 | const SkIRect& srcRect, |
| 241 | const SkIPoint& dstPoint) { |
Robert Phillips | 5efd5ea | 2017-05-30 13:47:32 -0400 | [diff] [blame] | 242 | SkASSERT(dst->asRenderTargetProxy() == fTarget.get()); |
Robert Phillips | 7c525e6 | 2018-06-12 10:11:12 -0400 | [diff] [blame] | 243 | std::unique_ptr<GrOp> op = GrCopySurfaceOp::Make(context, dst, src, srcRect, dstPoint); |
Brian Salomon | 1e41f4a | 2016-12-07 15:05:04 -0500 | [diff] [blame] | 244 | if (!op) { |
bsalomon | b8fea97 | 2016-02-16 07:34:17 -0800 | [diff] [blame] | 245 | return false; |
| 246 | } |
robertphillips | 498d7ac | 2015-10-30 10:11:30 -0700 | [diff] [blame] | 247 | |
Robert Phillips | 7c525e6 | 2018-06-12 10:11:12 -0400 | [diff] [blame] | 248 | this->addOp(std::move(op), *context->contextPriv().caps()); |
bsalomon | b8fea97 | 2016-02-16 07:34:17 -0800 | [diff] [blame] | 249 | return true; |
bsalomon@google.com | eb85117 | 2013-04-15 13:51:00 +0000 | [diff] [blame] | 250 | } |
| 251 | |
Greg Daniel | aa3dfbe | 2018-01-29 10:34:25 -0500 | [diff] [blame] | 252 | void GrRenderTargetOpList::purgeOpsWithUninstantiatedProxies() { |
| 253 | bool hasUninstantiatedProxy = false; |
Brian Salomon | fd98c2c | 2018-07-31 17:25:29 -0400 | [diff] [blame] | 254 | auto checkInstantiation = [&hasUninstantiatedProxy](GrSurfaceProxy* p) { |
| 255 | if (!p->isInstantiated()) { |
Greg Daniel | aa3dfbe | 2018-01-29 10:34:25 -0500 | [diff] [blame] | 256 | hasUninstantiatedProxy = true; |
| 257 | } |
| 258 | }; |
| 259 | for (RecordedOp& recordedOp : fRecordedOps) { |
| 260 | hasUninstantiatedProxy = false; |
Robert Phillips | ed1205a | 2018-07-13 11:44:53 -0400 | [diff] [blame] | 261 | if (recordedOp.fOp) { |
| 262 | recordedOp.visitProxies(checkInstantiation); |
| 263 | } |
Greg Daniel | aa3dfbe | 2018-01-29 10:34:25 -0500 | [diff] [blame] | 264 | if (hasUninstantiatedProxy) { |
| 265 | // When instantiation of the proxy fails we drop the Op |
Robert Phillips | c994a93 | 2018-06-19 13:09:54 -0400 | [diff] [blame] | 266 | recordedOp.deleteOp(fOpMemoryPool.get()); |
Greg Daniel | aa3dfbe | 2018-01-29 10:34:25 -0500 | [diff] [blame] | 267 | } |
| 268 | } |
| 269 | } |
| 270 | |
Robert Phillips | d375dbf | 2017-09-14 12:45:25 -0400 | [diff] [blame] | 271 | void GrRenderTargetOpList::gatherProxyIntervals(GrResourceAllocator* alloc) const { |
| 272 | unsigned int cur = alloc->numOps(); |
| 273 | |
Robert Phillips | 51b20f2 | 2017-12-01 15:32:35 -0500 | [diff] [blame] | 274 | for (int i = 0; i < fDeferredProxies.count(); ++i) { |
Brian Salomon | fd98c2c | 2018-07-31 17:25:29 -0400 | [diff] [blame] | 275 | SkASSERT(!fDeferredProxies[i]->isInstantiated()); |
Robert Phillips | 51b20f2 | 2017-12-01 15:32:35 -0500 | [diff] [blame] | 276 | // We give all the deferred proxies a write usage at the very start of flushing. This |
| 277 | // locks them out of being reused for the entire flush until they are read - and then |
| 278 | // they can be recycled. This is a bit unfortunate because a flush can proceed in waves |
| 279 | // with sub-flushes. The deferred proxies only need to be pinned from the start of |
| 280 | // the sub-flush in which they appear. |
| 281 | alloc->addInterval(fDeferredProxies[i], 0, 0); |
| 282 | } |
| 283 | |
Robert Phillips | d375dbf | 2017-09-14 12:45:25 -0400 | [diff] [blame] | 284 | // Add the interval for all the writes to this opList's target |
Robert Phillips | f8e2502 | 2017-11-08 15:24:31 -0500 | [diff] [blame] | 285 | if (fRecordedOps.count()) { |
| 286 | alloc->addInterval(fTarget.get(), cur, cur+fRecordedOps.count()-1); |
| 287 | } else { |
| 288 | // This can happen if there is a loadOp (e.g., a clear) but no other draws. In this case we |
| 289 | // still need to add an interval for the destination so we create a fake op# for |
| 290 | // the missing clear op. |
| 291 | alloc->addInterval(fTarget.get()); |
| 292 | alloc->incOps(); |
| 293 | } |
Robert Phillips | d375dbf | 2017-09-14 12:45:25 -0400 | [diff] [blame] | 294 | |
Chris Dalton | 8816b93 | 2017-11-29 16:48:25 -0700 | [diff] [blame] | 295 | auto gather = [ alloc SkDEBUGCODE(, this) ] (GrSurfaceProxy* p) { |
| 296 | alloc->addInterval(p SkDEBUGCODE(, fTarget.get() == p)); |
Robert Phillips | d375dbf | 2017-09-14 12:45:25 -0400 | [diff] [blame] | 297 | }; |
Chris Dalton | 8816b93 | 2017-11-29 16:48:25 -0700 | [diff] [blame] | 298 | for (const RecordedOp& recordedOp : fRecordedOps) { |
| 299 | recordedOp.visitProxies(gather); // only diff from the GrTextureOpList version |
Robert Phillips | f8e2502 | 2017-11-08 15:24:31 -0500 | [diff] [blame] | 300 | |
| 301 | // Even though the op may have been moved we still need to increment the op count to |
| 302 | // keep all the math consistent. |
| 303 | alloc->incOps(); |
Robert Phillips | d375dbf | 2017-09-14 12:45:25 -0400 | [diff] [blame] | 304 | } |
| 305 | } |
| 306 | |
Brian Salomon | a4677b5 | 2017-05-04 12:39:56 -0400 | [diff] [blame] | 307 | static inline bool can_reorder(const SkRect& a, const SkRect& b) { return !GrRectsOverlap(a, b); } |
bsalomon | 88cf17d | 2016-07-08 06:40:56 -0700 | [diff] [blame] | 308 | |
Brian Salomon | d25f5bc | 2018-08-08 11:25:17 -0400 | [diff] [blame] | 309 | GrOp::CombineResult GrRenderTargetOpList::combineIfPossible(const RecordedOp& a, GrOp* b, |
| 310 | const GrAppliedClip* bClip, |
| 311 | const DstProxy* bDstProxy, |
| 312 | const GrCaps& caps) { |
Brian Salomon | 54d212e | 2017-03-21 14:22:38 -0400 | [diff] [blame] | 313 | if (a.fAppliedClip) { |
| 314 | if (!bClip) { |
Brian Salomon | d25f5bc | 2018-08-08 11:25:17 -0400 | [diff] [blame] | 315 | return GrOp::CombineResult::kCannotCombine; |
Brian Salomon | 54d212e | 2017-03-21 14:22:38 -0400 | [diff] [blame] | 316 | } |
| 317 | if (*a.fAppliedClip != *bClip) { |
Brian Salomon | d25f5bc | 2018-08-08 11:25:17 -0400 | [diff] [blame] | 318 | return GrOp::CombineResult::kCannotCombine; |
Brian Salomon | 54d212e | 2017-03-21 14:22:38 -0400 | [diff] [blame] | 319 | } |
| 320 | } else if (bClip) { |
Brian Salomon | d25f5bc | 2018-08-08 11:25:17 -0400 | [diff] [blame] | 321 | return GrOp::CombineResult::kCannotCombine; |
Brian Salomon | 54d212e | 2017-03-21 14:22:38 -0400 | [diff] [blame] | 322 | } |
Robert Phillips | bb581ce | 2017-05-29 15:05:15 -0400 | [diff] [blame] | 323 | if (bDstProxy) { |
| 324 | if (a.fDstProxy != *bDstProxy) { |
Brian Salomon | d25f5bc | 2018-08-08 11:25:17 -0400 | [diff] [blame] | 325 | return GrOp::CombineResult::kCannotCombine; |
Brian Salomon | 54d212e | 2017-03-21 14:22:38 -0400 | [diff] [blame] | 326 | } |
Robert Phillips | bb581ce | 2017-05-29 15:05:15 -0400 | [diff] [blame] | 327 | } else if (a.fDstProxy.proxy()) { |
Brian Salomon | d25f5bc | 2018-08-08 11:25:17 -0400 | [diff] [blame] | 328 | return GrOp::CombineResult::kCannotCombine; |
Brian Salomon | 54d212e | 2017-03-21 14:22:38 -0400 | [diff] [blame] | 329 | } |
Brian Salomon | d25f5bc | 2018-08-08 11:25:17 -0400 | [diff] [blame] | 330 | return a.fOp->combineIfPossible(b, caps); |
Brian Salomon | 54d212e | 2017-03-21 14:22:38 -0400 | [diff] [blame] | 331 | } |
| 332 | |
Chris Dalton | f104fec | 2018-05-22 16:17:48 -0600 | [diff] [blame] | 333 | uint32_t GrRenderTargetOpList::recordOp(std::unique_ptr<GrOp> op, |
| 334 | const GrCaps& caps, |
| 335 | GrAppliedClip* clip, |
| 336 | const DstProxy* dstProxy) { |
Robert Phillips | 318c419 | 2017-05-17 09:36:38 -0400 | [diff] [blame] | 337 | SkASSERT(fTarget.get()); |
Robert Phillips | ee68365 | 2017-04-26 11:53:10 -0400 | [diff] [blame] | 338 | |
Brian Salomon | 1e41f4a | 2016-12-07 15:05:04 -0500 | [diff] [blame] | 339 | // A closed GrOpList should never receive new/more ops |
robertphillips | 6a18665 | 2015-10-20 07:37:58 -0700 | [diff] [blame] | 340 | SkASSERT(!this->isClosed()); |
robertphillips | a106c62 | 2015-10-16 09:07:06 -0700 | [diff] [blame] | 341 | |
Brian Salomon | 1e41f4a | 2016-12-07 15:05:04 -0500 | [diff] [blame] | 342 | // Check if there is an op we can combine with by linearly searching back until we either |
| 343 | // 1) check every op |
bsalomon | 512be53 | 2015-09-10 10:42:55 -0700 | [diff] [blame] | 344 | // 2) intersect with something |
| 345 | // 3) find a 'blocker' |
Robert Phillips | 5efd5ea | 2017-05-30 13:47:32 -0400 | [diff] [blame] | 346 | GR_AUDIT_TRAIL_ADD_OP(fAuditTrail, op.get(), fTarget.get()->uniqueID()); |
Robert Phillips | f5442bb | 2017-04-17 14:18:34 -0400 | [diff] [blame] | 347 | GrOP_INFO("opList: %d Recording (%s, opID: %u)\n" |
| 348 | "\tBounds [L: %.2f, T: %.2f R: %.2f B: %.2f]\n", |
| 349 | this->uniqueID(), |
Brian Salomon | 1e41f4a | 2016-12-07 15:05:04 -0500 | [diff] [blame] | 350 | op->name(), |
| 351 | op->uniqueID(), |
Robert Phillips | 1119dc3 | 2017-04-11 12:54:57 -0400 | [diff] [blame] | 352 | op->bounds().fLeft, op->bounds().fTop, |
| 353 | op->bounds().fRight, op->bounds().fBottom); |
Brian Salomon | 1e41f4a | 2016-12-07 15:05:04 -0500 | [diff] [blame] | 354 | GrOP_INFO(SkTabString(op->dumpInfo(), 1).c_str()); |
Brian Salomon | 25a8809 | 2016-12-01 09:36:50 -0500 | [diff] [blame] | 355 | GrOP_INFO("\tOutcome:\n"); |
Robert Phillips | 8185f59 | 2017-04-26 08:31:08 -0400 | [diff] [blame] | 356 | int maxCandidates = SkTMin(kMaxOpLookback, fRecordedOps.count()); |
Brian Salomon | d25f5bc | 2018-08-08 11:25:17 -0400 | [diff] [blame] | 357 | int firstChainableIdx = -1; |
Robert Phillips | 318c419 | 2017-05-17 09:36:38 -0400 | [diff] [blame] | 358 | if (maxCandidates) { |
bsalomon | 512be53 | 2015-09-10 10:42:55 -0700 | [diff] [blame] | 359 | int i = 0; |
| 360 | while (true) { |
Brian Salomon | 69868af | 2016-12-22 15:42:51 -0500 | [diff] [blame] | 361 | const RecordedOp& candidate = fRecordedOps.fromBack(i); |
Brian Salomon | d25f5bc | 2018-08-08 11:25:17 -0400 | [diff] [blame] | 362 | auto combineResult = this->combineIfPossible(candidate, op.get(), clip, dstProxy, caps); |
| 363 | switch (combineResult) { |
| 364 | case GrOp::CombineResult::kMayChain: |
| 365 | if (candidate.fOp->isChainTail() && firstChainableIdx < 0) { |
| 366 | GrOP_INFO("\t\tBackward: Can chain with (%s, opID: %u)\n", |
| 367 | candidate.fOp->name(), candidate.fOp->uniqueID()); |
| 368 | firstChainableIdx = i; |
| 369 | } |
| 370 | break; |
| 371 | case GrOp::CombineResult::kMerged: |
| 372 | GrOP_INFO("\t\tBackward: Combining with (%s, opID: %u)\n", |
| 373 | candidate.fOp->name(), candidate.fOp->uniqueID()); |
| 374 | GrOP_INFO("\t\t\tBackward: Combined op info:\n"); |
| 375 | GrOP_INFO(SkTabString(candidate.fOp->dumpInfo(), 4).c_str()); |
| 376 | GR_AUDIT_TRAIL_OPS_RESULT_COMBINED(fAuditTrail, candidate.fOp.get(), op.get()); |
| 377 | fOpMemoryPool->release(std::move(op)); |
| 378 | return SK_InvalidUniqueID; |
| 379 | case GrOp::CombineResult::kCannotCombine: |
| 380 | break; |
bsalomon | 512be53 | 2015-09-10 10:42:55 -0700 | [diff] [blame] | 381 | } |
Brian Salomon | 764e546 | 2018-08-21 12:07:00 -0400 | [diff] [blame] | 382 | // Stop going backwards if we would cause a painter's order violation. We only need to |
| 383 | // test against chain heads as elements of a chain always draw in their chain head's |
| 384 | // slot. |
| 385 | if (candidate.fOp->isChainHead() && |
| 386 | !can_reorder(candidate.fOp->bounds(), op->bounds())) { |
Robert Phillips | f5442bb | 2017-04-17 14:18:34 -0400 | [diff] [blame] | 387 | GrOP_INFO("\t\tBackward: Intersects with (%s, opID: %u)\n", candidate.fOp->name(), |
Brian Salomon | 69868af | 2016-12-22 15:42:51 -0500 | [diff] [blame] | 388 | candidate.fOp->uniqueID()); |
bsalomon | 512be53 | 2015-09-10 10:42:55 -0700 | [diff] [blame] | 389 | break; |
| 390 | } |
| 391 | ++i; |
| 392 | if (i == maxCandidates) { |
Robert Phillips | f5442bb | 2017-04-17 14:18:34 -0400 | [diff] [blame] | 393 | GrOP_INFO("\t\tBackward: Reached max lookback or beginning of op array %d\n", i); |
bsalomon | 512be53 | 2015-09-10 10:42:55 -0700 | [diff] [blame] | 394 | break; |
| 395 | } |
| 396 | } |
| 397 | } else { |
Robert Phillips | f5442bb | 2017-04-17 14:18:34 -0400 | [diff] [blame] | 398 | GrOP_INFO("\t\tBackward: FirstOp\n"); |
bsalomon | 512be53 | 2015-09-10 10:42:55 -0700 | [diff] [blame] | 399 | } |
Brian Salomon | 42ad83a | 2016-12-20 16:14:45 -0500 | [diff] [blame] | 400 | GR_AUDIT_TRAIL_OP_RESULT_NEW(fAuditTrail, op); |
Brian Salomon | 54d212e | 2017-03-21 14:22:38 -0400 | [diff] [blame] | 401 | if (clip) { |
| 402 | clip = fClipAllocator.make<GrAppliedClip>(std::move(*clip)); |
Robert Phillips | c84c030 | 2017-05-08 15:35:11 -0400 | [diff] [blame] | 403 | SkDEBUGCODE(fNumClips++;) |
Brian Salomon | 54d212e | 2017-03-21 14:22:38 -0400 | [diff] [blame] | 404 | } |
Brian Salomon | d25f5bc | 2018-08-08 11:25:17 -0400 | [diff] [blame] | 405 | if (firstChainableIdx >= 0) { |
Brian Salomon | 764e546 | 2018-08-21 12:07:00 -0400 | [diff] [blame] | 406 | // If we chain this op it will draw in the slot of the head of the chain. We have to check |
| 407 | // that the new op's bounds don't intersect any of the other ops between firstChainableIdx |
| 408 | // and the head of that op's chain. We only need to test against chain heads as elements of |
| 409 | // a chain always draw in their chain head's slot. |
| 410 | const GrOp* chainHead = fRecordedOps.fromBack(firstChainableIdx).fOp->chainHead(); |
| 411 | int idx = firstChainableIdx; |
| 412 | bool chain = true; |
| 413 | while (fRecordedOps.fromBack(idx).fOp.get() != chainHead) { |
| 414 | // If idx is not in the same chain then we have to check against its bounds as we will |
| 415 | // draw before it (when chainHead draws). |
| 416 | const GrOp* testOp = fRecordedOps.fromBack(idx).fOp.get(); |
| 417 | if (testOp->isChainHead() && !can_reorder(testOp->bounds(), op->bounds())) { |
| 418 | GrOP_INFO("\t\tBackward: Intersects with (%s, opID: %u). Cannot chain.\n", |
| 419 | testOp->name(), testOp->uniqueID()); |
| 420 | chain = false; |
| 421 | break; |
| 422 | } |
| 423 | ++idx; |
| 424 | // We must encounter the chain head before running off the beginning of the list. |
| 425 | SkASSERT(idx < fRecordedOps.count()); |
| 426 | } |
| 427 | if (chain) { |
| 428 | GrOp* prevOp = fRecordedOps.fromBack(firstChainableIdx).fOp.get(); |
| 429 | GrOP_INFO("\t\t\tBackward: Chained to (%s, opID: %u)\n", prevOp->name(), |
| 430 | prevOp->uniqueID()); |
| 431 | prevOp->setNextInChain(op.get()); |
| 432 | } |
Brian Salomon | d25f5bc | 2018-08-08 11:25:17 -0400 | [diff] [blame] | 433 | } |
Robert Phillips | bb581ce | 2017-05-29 15:05:15 -0400 | [diff] [blame] | 434 | fRecordedOps.emplace_back(std::move(op), clip, dstProxy); |
Chris Dalton | f104fec | 2018-05-22 16:17:48 -0600 | [diff] [blame] | 435 | return this->uniqueID(); |
bsalomon | 512be53 | 2015-09-10 10:42:55 -0700 | [diff] [blame] | 436 | } |
| 437 | |
Robert Phillips | ee68365 | 2017-04-26 11:53:10 -0400 | [diff] [blame] | 438 | void GrRenderTargetOpList::forwardCombine(const GrCaps& caps) { |
Robert Phillips | f5442bb | 2017-04-17 14:18:34 -0400 | [diff] [blame] | 439 | SkASSERT(!this->isClosed()); |
| 440 | |
Robert Phillips | 48567ac | 2017-06-01 08:46:00 -0400 | [diff] [blame] | 441 | GrOP_INFO("opList: %d ForwardCombine %d ops:\n", this->uniqueID(), fRecordedOps.count()); |
| 442 | |
Brian Salomon | 337432d | 2017-03-21 17:36:10 -0400 | [diff] [blame] | 443 | for (int i = 0; i < fRecordedOps.count() - 1; ++i) { |
Brian Salomon | 1e41f4a | 2016-12-07 15:05:04 -0500 | [diff] [blame] | 444 | GrOp* op = fRecordedOps[i].fOp.get(); |
Robert Phillips | 318c419 | 2017-05-17 09:36:38 -0400 | [diff] [blame] | 445 | |
Robert Phillips | 8185f59 | 2017-04-26 08:31:08 -0400 | [diff] [blame] | 446 | int maxCandidateIdx = SkTMin(i + kMaxOpLookahead, fRecordedOps.count() - 1); |
bsalomon | aecc018 | 2016-03-07 11:50:44 -0800 | [diff] [blame] | 447 | int j = i + 1; |
Brian Salomon | d25f5bc | 2018-08-08 11:25:17 -0400 | [diff] [blame] | 448 | int firstChainableIdx = -1; |
bsalomon | aecc018 | 2016-03-07 11:50:44 -0800 | [diff] [blame] | 449 | while (true) { |
Brian Salomon | 69868af | 2016-12-22 15:42:51 -0500 | [diff] [blame] | 450 | const RecordedOp& candidate = fRecordedOps[j]; |
Brian Salomon | d25f5bc | 2018-08-08 11:25:17 -0400 | [diff] [blame] | 451 | auto combineResult = |
| 452 | this->combineIfPossible(fRecordedOps[i], candidate.fOp.get(), |
| 453 | candidate.fAppliedClip, &candidate.fDstProxy, caps); |
| 454 | switch (combineResult) { |
| 455 | case GrOp::CombineResult::kMayChain: |
| 456 | if (firstChainableIdx < 0 && !fRecordedOps[i].fOp->isChained() && |
| 457 | !fRecordedOps[j].fOp->isChained()) { |
| 458 | GrOP_INFO("\t\tForward: Can chain with (%s, opID: %u)\n", |
| 459 | candidate.fOp->name(), candidate.fOp->uniqueID()); |
| 460 | firstChainableIdx = j; |
| 461 | } |
| 462 | break; |
| 463 | case GrOp::CombineResult::kMerged: |
| 464 | GrOP_INFO("\t\t%d: (%s opID: %u) -> Combining with (%s, opID: %u)\n", i, |
| 465 | op->name(), op->uniqueID(), candidate.fOp->name(), |
| 466 | candidate.fOp->uniqueID()); |
| 467 | GR_AUDIT_TRAIL_OPS_RESULT_COMBINED(fAuditTrail, op, candidate.fOp.get()); |
| 468 | fOpMemoryPool->release(std::move(fRecordedOps[j].fOp)); |
| 469 | fRecordedOps[j].fOp = std::move(fRecordedOps[i].fOp); |
| 470 | break; |
| 471 | case GrOp::CombineResult::kCannotCombine: |
| 472 | break; |
| 473 | } |
| 474 | if (!fRecordedOps[i].fOp) { |
bsalomon | aecc018 | 2016-03-07 11:50:44 -0800 | [diff] [blame] | 475 | break; |
| 476 | } |
Robert Phillips | c84c030 | 2017-05-08 15:35:11 -0400 | [diff] [blame] | 477 | // Stop traversing if we would cause a painter's order violation. |
Brian Salomon | 764e546 | 2018-08-21 12:07:00 -0400 | [diff] [blame] | 478 | if (candidate.fOp->isChainHead() && |
| 479 | !can_reorder(candidate.fOp->bounds(), op->bounds())) { |
Robert Phillips | 48567ac | 2017-06-01 08:46:00 -0400 | [diff] [blame] | 480 | GrOP_INFO("\t\t%d: (%s opID: %u) -> Intersects with (%s, opID: %u)\n", |
| 481 | i, op->name(), op->uniqueID(), |
| 482 | candidate.fOp->name(), candidate.fOp->uniqueID()); |
bsalomon | aecc018 | 2016-03-07 11:50:44 -0800 | [diff] [blame] | 483 | break; |
| 484 | } |
| 485 | ++j; |
| 486 | if (j > maxCandidateIdx) { |
Brian Salomon | d25f5bc | 2018-08-08 11:25:17 -0400 | [diff] [blame] | 487 | if (firstChainableIdx >= 0) { |
Brian Salomon | 764e546 | 2018-08-21 12:07:00 -0400 | [diff] [blame] | 488 | GrOp* nextOp = fRecordedOps[firstChainableIdx].fOp.get(); |
| 489 | GrOP_INFO("\t\t\tForward: Chained to (%s, opID: %u)\n", nextOp->name(), |
| 490 | nextOp->uniqueID()); |
Brian Salomon | d25f5bc | 2018-08-08 11:25:17 -0400 | [diff] [blame] | 491 | // We have to chain i before firstChainableIdx in order to preserve their |
| 492 | // relative order as they may overlap. |
Brian Salomon | 764e546 | 2018-08-21 12:07:00 -0400 | [diff] [blame] | 493 | fRecordedOps[i].fOp->setNextInChain(nextOp); |
Brian Salomon | d25f5bc | 2018-08-08 11:25:17 -0400 | [diff] [blame] | 494 | // However we want to draw them *after* any ops that occur between them. So move |
| 495 | // the head of the new chain to the later slot as we only execute chain heads. |
| 496 | std::swap(fRecordedOps[i].fOp, fRecordedOps[firstChainableIdx].fOp); |
| 497 | } else { |
| 498 | GrOP_INFO("\t\t%d: (%s opID: %u) -> Reached max lookahead or end of array\n", i, |
| 499 | op->name(), op->uniqueID()); |
| 500 | } |
bsalomon | aecc018 | 2016-03-07 11:50:44 -0800 | [diff] [blame] | 501 | break; |
| 502 | } |
| 503 | } |
| 504 | } |
| 505 | } |
| 506 | |