joshualitt | 9c80b5f | 2015-08-13 10:05:51 -0700 | [diff] [blame] | 1 | /* |
Brian Salomon | ac70f84 | 2017-05-08 10:43:33 -0400 | [diff] [blame] | 2 | * Copyright 2017 Google Inc. |
joshualitt | 9c80b5f | 2015-08-13 10:05:51 -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 | |
Brian Salomon | ac70f84 | 2017-05-08 10:43:33 -0400 | [diff] [blame] | 8 | #include "GrAppliedClip.h" |
joshualitt | 9c80b5f | 2015-08-13 10:05:51 -0700 | [diff] [blame] | 9 | #include "GrColor.h" |
| 10 | #include "GrDefaultGeoProcFactory.h" |
Brian Salomon | 1772663 | 2017-05-12 14:09:46 -0400 | [diff] [blame] | 11 | #include "GrDrawOpTest.h" |
Brian Salomon | dad2923 | 2016-12-01 16:40:24 -0500 | [diff] [blame] | 12 | #include "GrMeshDrawOp.h" |
Brian Salomon | 742e31d | 2016-12-07 17:06:19 -0500 | [diff] [blame] | 13 | #include "GrOpFlushState.h" |
joshualitt | 9c80b5f | 2015-08-13 10:05:51 -0700 | [diff] [blame] | 14 | #include "GrPrimitiveProcessor.h" |
joshualitt | ae5b2c6 | 2015-08-19 08:48:41 -0700 | [diff] [blame] | 15 | #include "GrQuad.h" |
Brian Salomon | baaf439 | 2017-06-15 09:59:23 -0400 | [diff] [blame] | 16 | #include "GrRectOpFactory.h" |
Brian Salomon | dad2923 | 2016-12-01 16:40:24 -0500 | [diff] [blame] | 17 | #include "GrResourceProvider.h" |
Brian Salomon | ac70f84 | 2017-05-08 10:43:33 -0400 | [diff] [blame] | 18 | #include "GrSimpleMeshDrawOpHelper.h" |
reed | a39667c | 2016-08-22 06:39:49 -0700 | [diff] [blame] | 19 | #include "SkMatrixPriv.h" |
| 20 | |
Brian Salomon | ac70f84 | 2017-05-08 10:43:33 -0400 | [diff] [blame] | 21 | static const int kVertsPerRect = 4; |
| 22 | static const int kIndicesPerRect = 6; |
joshualitt | 2244c27 | 2015-08-21 10:33:15 -0700 | [diff] [blame] | 23 | |
Brian Salomon | 53e4c3c | 2016-12-21 11:38:53 -0500 | [diff] [blame] | 24 | /** We always use per-vertex colors so that rects can be combined across color changes. Sometimes |
joshualitt | 2244c27 | 2015-08-21 10:33:15 -0700 | [diff] [blame] | 25 | we have explicit local coords and sometimes not. We *could* always provide explicit local |
| 26 | coords and just duplicate the positions when the caller hasn't provided a local coord rect, |
| 27 | but we haven't seen a use case which frequently switches between local rect and no local |
| 28 | rect draws. |
| 29 | |
| 30 | The vertex attrib order is always pos, color, [local coords]. |
| 31 | */ |
Ruiqi Mao | b609e6d | 2018-07-17 10:19:38 -0400 | [diff] [blame] | 32 | static sk_sp<GrGeometryProcessor> make_gp(const GrShaderCaps* shaderCaps) { |
robertphillips | 6abd1d1 | 2016-07-01 09:06:56 -0700 | [diff] [blame] | 33 | using namespace GrDefaultGeoProcFactory; |
Ruiqi Mao | b609e6d | 2018-07-17 10:19:38 -0400 | [diff] [blame] | 34 | return GrDefaultGeoProcFactory::Make(shaderCaps, |
| 35 | Color::kPremulGrColorAttribute_Type, |
| 36 | Coverage::kSolid_Type, |
| 37 | LocalCoords::kHasExplicit_Type, |
| 38 | SkMatrix::I()); |
robertphillips | 6abd1d1 | 2016-07-01 09:06:56 -0700 | [diff] [blame] | 39 | } |
| 40 | |
Ruiqi Mao | b609e6d | 2018-07-17 10:19:38 -0400 | [diff] [blame] | 41 | static sk_sp<GrGeometryProcessor> make_perspective_gp(const GrShaderCaps* shaderCaps, |
| 42 | const SkMatrix& viewMatrix, |
Brian Salomon | ac70f84 | 2017-05-08 10:43:33 -0400 | [diff] [blame] | 43 | bool hasExplicitLocalCoords, |
| 44 | const SkMatrix* localMatrix) { |
| 45 | SkASSERT(viewMatrix.hasPerspective() || (localMatrix && localMatrix->hasPerspective())); |
| 46 | |
| 47 | using namespace GrDefaultGeoProcFactory; |
| 48 | |
| 49 | // If we have perspective on the viewMatrix then we won't map on the CPU, nor will we map |
| 50 | // the local rect on the cpu (in case the localMatrix also has perspective). |
| 51 | // Otherwise, if we have a local rect, then we apply the localMatrix directly to the localRect |
| 52 | // to generate vertex local coords |
| 53 | if (viewMatrix.hasPerspective()) { |
| 54 | LocalCoords localCoords(hasExplicitLocalCoords ? LocalCoords::kHasExplicit_Type |
| 55 | : LocalCoords::kUsePosition_Type, |
| 56 | localMatrix); |
Ruiqi Mao | b609e6d | 2018-07-17 10:19:38 -0400 | [diff] [blame] | 57 | return GrDefaultGeoProcFactory::Make(shaderCaps, Color::kPremulGrColorAttribute_Type, |
Brian Salomon | ac70f84 | 2017-05-08 10:43:33 -0400 | [diff] [blame] | 58 | Coverage::kSolid_Type, localCoords, viewMatrix); |
| 59 | } else if (hasExplicitLocalCoords) { |
| 60 | LocalCoords localCoords(LocalCoords::kHasExplicit_Type, localMatrix); |
Ruiqi Mao | b609e6d | 2018-07-17 10:19:38 -0400 | [diff] [blame] | 61 | return GrDefaultGeoProcFactory::Make(shaderCaps, Color::kPremulGrColorAttribute_Type, |
Brian Salomon | ac70f84 | 2017-05-08 10:43:33 -0400 | [diff] [blame] | 62 | Coverage::kSolid_Type, localCoords, SkMatrix::I()); |
| 63 | } else { |
| 64 | LocalCoords localCoords(LocalCoords::kUsePosition_Type, localMatrix); |
Ruiqi Mao | b609e6d | 2018-07-17 10:19:38 -0400 | [diff] [blame] | 65 | return GrDefaultGeoProcFactory::MakeForDeviceSpace(shaderCaps, |
| 66 | Color::kPremulGrColorAttribute_Type, |
Brian Salomon | ac70f84 | 2017-05-08 10:43:33 -0400 | [diff] [blame] | 67 | Coverage::kSolid_Type, localCoords, |
| 68 | viewMatrix); |
| 69 | } |
| 70 | } |
| 71 | |
joshualitt | 2244c27 | 2015-08-21 10:33:15 -0700 | [diff] [blame] | 72 | static void tesselate(intptr_t vertices, |
| 73 | size_t vertexStride, |
| 74 | GrColor color, |
robertphillips | 6abd1d1 | 2016-07-01 09:06:56 -0700 | [diff] [blame] | 75 | const SkMatrix* viewMatrix, |
joshualitt | 2244c27 | 2015-08-21 10:33:15 -0700 | [diff] [blame] | 76 | const SkRect& rect, |
joshualitt | 8cce8f1 | 2015-08-26 06:23:39 -0700 | [diff] [blame] | 77 | const GrQuad* localQuad) { |
joshualitt | 2244c27 | 2015-08-21 10:33:15 -0700 | [diff] [blame] | 78 | SkPoint* positions = reinterpret_cast<SkPoint*>(vertices); |
| 79 | |
Brian Salomon | be3c1d2 | 2018-05-21 12:54:39 -0400 | [diff] [blame] | 80 | SkPointPriv::SetRectTriStrip(positions, rect, vertexStride); |
joshualitt | 2244c27 | 2015-08-21 10:33:15 -0700 | [diff] [blame] | 81 | |
robertphillips | 6abd1d1 | 2016-07-01 09:06:56 -0700 | [diff] [blame] | 82 | if (viewMatrix) { |
Brian Salomon | ac70f84 | 2017-05-08 10:43:33 -0400 | [diff] [blame] | 83 | SkMatrixPriv::MapPointsWithStride(*viewMatrix, positions, vertexStride, kVertsPerRect); |
joshualitt | 8cce8f1 | 2015-08-26 06:23:39 -0700 | [diff] [blame] | 84 | } |
| 85 | |
| 86 | // Setup local coords |
joshualitt | 2244c27 | 2015-08-21 10:33:15 -0700 | [diff] [blame] | 87 | // TODO we should only do this if local coords are being read |
joshualitt | 8cce8f1 | 2015-08-26 06:23:39 -0700 | [diff] [blame] | 88 | if (localQuad) { |
joshualitt | 2244c27 | 2015-08-21 10:33:15 -0700 | [diff] [blame] | 89 | static const int kLocalOffset = sizeof(SkPoint) + sizeof(GrColor); |
Brian Salomon | ac70f84 | 2017-05-08 10:43:33 -0400 | [diff] [blame] | 90 | for (int i = 0; i < kVertsPerRect; i++) { |
Brian Salomon | 6a63904 | 2016-12-14 11:08:17 -0500 | [diff] [blame] | 91 | SkPoint* coords = |
| 92 | reinterpret_cast<SkPoint*>(vertices + kLocalOffset + i * vertexStride); |
joshualitt | 8cce8f1 | 2015-08-26 06:23:39 -0700 | [diff] [blame] | 93 | *coords = localQuad->point(i); |
joshualitt | 2244c27 | 2015-08-21 10:33:15 -0700 | [diff] [blame] | 94 | } |
| 95 | } |
| 96 | |
| 97 | static const int kColorOffset = sizeof(SkPoint); |
| 98 | GrColor* vertColor = reinterpret_cast<GrColor*>(vertices + kColorOffset); |
| 99 | for (int j = 0; j < 4; ++j) { |
| 100 | *vertColor = color; |
Brian Salomon | 6a63904 | 2016-12-14 11:08:17 -0500 | [diff] [blame] | 101 | vertColor = (GrColor*)((intptr_t)vertColor + vertexStride); |
joshualitt | 2244c27 | 2015-08-21 10:33:15 -0700 | [diff] [blame] | 102 | } |
| 103 | } |
| 104 | |
Brian Salomon | ac70f84 | 2017-05-08 10:43:33 -0400 | [diff] [blame] | 105 | namespace { |
bsalomon | 08d1415 | 2016-06-30 12:45:18 -0700 | [diff] [blame] | 106 | |
Brian Salomon | ac70f84 | 2017-05-08 10:43:33 -0400 | [diff] [blame] | 107 | class NonAAFillRectOp final : public GrMeshDrawOp { |
| 108 | private: |
| 109 | using Helper = GrSimpleMeshDrawOpHelperWithStencil; |
| 110 | |
| 111 | public: |
Robert Phillips | 7c525e6 | 2018-06-12 10:11:12 -0400 | [diff] [blame] | 112 | static std::unique_ptr<GrDrawOp> Make(GrContext* context, |
| 113 | GrPaint&& paint, |
| 114 | const SkMatrix& viewMatrix, |
| 115 | const SkRect& rect, |
| 116 | const SkRect* localRect, |
| 117 | const SkMatrix* localMatrix, |
| 118 | GrAAType aaType, |
Brian Salomon | ac70f84 | 2017-05-08 10:43:33 -0400 | [diff] [blame] | 119 | const GrUserStencilSettings* stencilSettings) { |
| 120 | SkASSERT(GrAAType::kCoverage != aaType); |
Robert Phillips | 7c525e6 | 2018-06-12 10:11:12 -0400 | [diff] [blame] | 121 | return Helper::FactoryHelper<NonAAFillRectOp>(context, std::move(paint), viewMatrix, rect, |
| 122 | localRect, localMatrix, aaType, |
| 123 | stencilSettings); |
Brian Salomon | ac70f84 | 2017-05-08 10:43:33 -0400 | [diff] [blame] | 124 | } |
| 125 | |
| 126 | NonAAFillRectOp() = delete; |
| 127 | |
| 128 | NonAAFillRectOp(const Helper::MakeArgs& args, GrColor color, const SkMatrix& viewMatrix, |
| 129 | const SkRect& rect, const SkRect* localRect, const SkMatrix* localMatrix, |
| 130 | GrAAType aaType, const GrUserStencilSettings* stencilSettings) |
| 131 | : INHERITED(ClassID()), fHelper(args, aaType, stencilSettings) { |
Chris Dalton | 1d61635 | 2017-05-31 12:51:23 -0600 | [diff] [blame] | 132 | |
Brian Salomon | 6a63904 | 2016-12-14 11:08:17 -0500 | [diff] [blame] | 133 | SkASSERT(!viewMatrix.hasPerspective() && (!localMatrix || !localMatrix->hasPerspective())); |
bsalomon | 9d7f184 | 2016-07-01 08:01:36 -0700 | [diff] [blame] | 134 | RectInfo& info = fRects.push_back(); |
| 135 | info.fColor = color; |
| 136 | info.fViewMatrix = viewMatrix; |
| 137 | info.fRect = rect; |
| 138 | if (localRect && localMatrix) { |
Brian Salomon | a33b67c | 2018-05-17 10:42:14 -0400 | [diff] [blame] | 139 | info.fLocalQuad = GrQuad(*localRect, *localMatrix); |
bsalomon | 9d7f184 | 2016-07-01 08:01:36 -0700 | [diff] [blame] | 140 | } else if (localRect) { |
Brian Salomon | a33b67c | 2018-05-17 10:42:14 -0400 | [diff] [blame] | 141 | info.fLocalQuad = GrQuad(*localRect); |
bsalomon | 9d7f184 | 2016-07-01 08:01:36 -0700 | [diff] [blame] | 142 | } else if (localMatrix) { |
Brian Salomon | a33b67c | 2018-05-17 10:42:14 -0400 | [diff] [blame] | 143 | info.fLocalQuad = GrQuad(rect, *localMatrix); |
bsalomon | 9d7f184 | 2016-07-01 08:01:36 -0700 | [diff] [blame] | 144 | } else { |
Brian Salomon | a33b67c | 2018-05-17 10:42:14 -0400 | [diff] [blame] | 145 | info.fLocalQuad = GrQuad(rect); |
bsalomon | 9d7f184 | 2016-07-01 08:01:36 -0700 | [diff] [blame] | 146 | } |
bsalomon | 88cf17d | 2016-07-08 06:40:56 -0700 | [diff] [blame] | 147 | this->setTransformedBounds(fRects[0].fRect, viewMatrix, HasAABloat::kNo, IsZeroArea::kNo); |
bsalomon | 9d7f184 | 2016-07-01 08:01:36 -0700 | [diff] [blame] | 148 | } |
bsalomon | 08d1415 | 2016-06-30 12:45:18 -0700 | [diff] [blame] | 149 | |
Brian Salomon | 6a63904 | 2016-12-14 11:08:17 -0500 | [diff] [blame] | 150 | const char* name() const override { return "NonAAFillRectOp"; } |
bsalomon | 08d1415 | 2016-06-30 12:45:18 -0700 | [diff] [blame] | 151 | |
Robert Phillips | f1748f5 | 2017-09-14 14:11:24 -0400 | [diff] [blame] | 152 | void visitProxies(const VisitProxyFunc& func) const override { |
Robert Phillips | b493eeb | 2017-09-13 13:10:52 -0400 | [diff] [blame] | 153 | fHelper.visitProxies(func); |
| 154 | } |
| 155 | |
bsalomon | 08d1415 | 2016-06-30 12:45:18 -0700 | [diff] [blame] | 156 | SkString dumpInfo() const override { |
| 157 | SkString str; |
Brian Salomon | ac70f84 | 2017-05-08 10:43:33 -0400 | [diff] [blame] | 158 | str.append(GrMeshDrawOp::dumpInfo()); |
Brian Salomon | 53e4c3c | 2016-12-21 11:38:53 -0500 | [diff] [blame] | 159 | str.appendf("# combined: %d\n", fRects.count()); |
bsalomon | 9d7f184 | 2016-07-01 08:01:36 -0700 | [diff] [blame] | 160 | for (int i = 0; i < fRects.count(); ++i) { |
| 161 | const RectInfo& info = fRects[i]; |
Brian Salomon | 6a63904 | 2016-12-14 11:08:17 -0500 | [diff] [blame] | 162 | str.appendf("%d: Color: 0x%08x, Rect [L: %.2f, T: %.2f, R: %.2f, B: %.2f]\n", i, |
| 163 | info.fColor, info.fRect.fLeft, info.fRect.fTop, info.fRect.fRight, |
| 164 | info.fRect.fBottom); |
bsalomon | 08d1415 | 2016-06-30 12:45:18 -0700 | [diff] [blame] | 165 | } |
Brian Salomon | 82dfd3d | 2017-06-14 12:30:35 -0400 | [diff] [blame] | 166 | str += fHelper.dumpInfo(); |
| 167 | str += INHERITED::dumpInfo(); |
bsalomon | 08d1415 | 2016-06-30 12:45:18 -0700 | [diff] [blame] | 168 | return str; |
| 169 | } |
| 170 | |
Brian Osman | 532b3f9 | 2018-07-11 10:02:07 -0400 | [diff] [blame] | 171 | RequiresDstTexture finalize(const GrCaps& caps, const GrAppliedClip* clip) override { |
Brian Salomon | ac70f84 | 2017-05-08 10:43:33 -0400 | [diff] [blame] | 172 | GrColor* color = &fRects.front().fColor; |
Brian Osman | 532b3f9 | 2018-07-11 10:02:07 -0400 | [diff] [blame] | 173 | return fHelper.xpRequiresDstTexture(caps, clip, GrProcessorAnalysisCoverage::kNone, color); |
Brian Salomon | ac70f84 | 2017-05-08 10:43:33 -0400 | [diff] [blame] | 174 | } |
| 175 | |
| 176 | FixedFunctionFlags fixedFunctionFlags() const override { return fHelper.fixedFunctionFlags(); } |
| 177 | |
| 178 | DEFINE_OP_CLASS_ID |
| 179 | |
bsalomon | 08d1415 | 2016-06-30 12:45:18 -0700 | [diff] [blame] | 180 | private: |
Brian Salomon | 91326c3 | 2017-08-09 16:02:19 -0400 | [diff] [blame] | 181 | void onPrepareDraws(Target* target) override { |
Ruiqi Mao | b609e6d | 2018-07-17 10:19:38 -0400 | [diff] [blame] | 182 | sk_sp<GrGeometryProcessor> gp = make_gp(target->caps().shaderCaps()); |
bsalomon | 08d1415 | 2016-06-30 12:45:18 -0700 | [diff] [blame] | 183 | if (!gp) { |
| 184 | SkDebugf("Couldn't create GrGeometryProcessor\n"); |
| 185 | return; |
| 186 | } |
| 187 | |
Brian Salomon | 92be2f7 | 2018-06-19 14:33:47 -0400 | [diff] [blame] | 188 | static constexpr size_t kVertexStride = |
| 189 | sizeof(GrDefaultGeoProcFactory::PositionColorLocalCoordAttr); |
| 190 | SkASSERT(kVertexStride == gp->debugOnly_vertexStride()); |
| 191 | |
Brian Salomon | ac70f84 | 2017-05-08 10:43:33 -0400 | [diff] [blame] | 192 | int rectCount = fRects.count(); |
bsalomon | 08d1415 | 2016-06-30 12:45:18 -0700 | [diff] [blame] | 193 | |
Brian Salomon | d28a79d | 2017-10-16 13:01:07 -0400 | [diff] [blame] | 194 | sk_sp<const GrBuffer> indexBuffer = target->resourceProvider()->refQuadIndexBuffer(); |
Brian Salomon | 7eae3e0 | 2018-08-07 14:02:38 +0000 | [diff] [blame] | 195 | PatternHelper helper(target, GrPrimitiveType::kTriangles, kVertexStride, indexBuffer.get(), |
| 196 | kVertsPerRect, kIndicesPerRect, rectCount); |
| 197 | void* vertices = helper.vertices(); |
bsalomon | 08d1415 | 2016-06-30 12:45:18 -0700 | [diff] [blame] | 198 | if (!vertices || !indexBuffer) { |
| 199 | SkDebugf("Could not allocate vertices\n"); |
| 200 | return; |
| 201 | } |
| 202 | |
Brian Salomon | ac70f84 | 2017-05-08 10:43:33 -0400 | [diff] [blame] | 203 | for (int i = 0; i < rectCount; i++) { |
Brian Salomon | 6a63904 | 2016-12-14 11:08:17 -0500 | [diff] [blame] | 204 | intptr_t verts = |
Brian Salomon | 92be2f7 | 2018-06-19 14:33:47 -0400 | [diff] [blame] | 205 | reinterpret_cast<intptr_t>(vertices) + i * kVertsPerRect * kVertexStride; |
| 206 | tesselate(verts, kVertexStride, fRects[i].fColor, &fRects[i].fViewMatrix, |
bsalomon | 9d7f184 | 2016-07-01 08:01:36 -0700 | [diff] [blame] | 207 | fRects[i].fRect, &fRects[i].fLocalQuad); |
bsalomon | 08d1415 | 2016-06-30 12:45:18 -0700 | [diff] [blame] | 208 | } |
Brian Salomon | 4934890 | 2018-06-26 09:12:38 -0400 | [diff] [blame] | 209 | auto pipe = fHelper.makePipeline(target); |
Brian Salomon | 7eae3e0 | 2018-08-07 14:02:38 +0000 | [diff] [blame] | 210 | helper.recordDraw(target, std::move(gp), pipe.fPipeline, pipe.fFixedDynamicState); |
bsalomon | 08d1415 | 2016-06-30 12:45:18 -0700 | [diff] [blame] | 211 | } |
| 212 | |
Brian Salomon | 7eae3e0 | 2018-08-07 14:02:38 +0000 | [diff] [blame] | 213 | CombineResult onCombineIfPossible(GrOp* t, const GrCaps& caps) override { |
Brian Salomon | 6a63904 | 2016-12-14 11:08:17 -0500 | [diff] [blame] | 214 | NonAAFillRectOp* that = t->cast<NonAAFillRectOp>(); |
Brian Salomon | ac70f84 | 2017-05-08 10:43:33 -0400 | [diff] [blame] | 215 | if (!fHelper.isCompatible(that->fHelper, caps, this->bounds(), that->bounds())) { |
Brian Salomon | 7eae3e0 | 2018-08-07 14:02:38 +0000 | [diff] [blame] | 216 | return CombineResult::kCannotCombine; |
bsalomon | 08d1415 | 2016-06-30 12:45:18 -0700 | [diff] [blame] | 217 | } |
bsalomon | 9d7f184 | 2016-07-01 08:01:36 -0700 | [diff] [blame] | 218 | fRects.push_back_n(that->fRects.count(), that->fRects.begin()); |
bsalomon | 88cf17d | 2016-07-08 06:40:56 -0700 | [diff] [blame] | 219 | this->joinBounds(*that); |
Brian Salomon | 7eae3e0 | 2018-08-07 14:02:38 +0000 | [diff] [blame] | 220 | return CombineResult::kMerged; |
bsalomon | 08d1415 | 2016-06-30 12:45:18 -0700 | [diff] [blame] | 221 | } |
| 222 | |
bsalomon | 9d7f184 | 2016-07-01 08:01:36 -0700 | [diff] [blame] | 223 | struct RectInfo { |
| 224 | GrColor fColor; |
| 225 | SkMatrix fViewMatrix; |
| 226 | SkRect fRect; |
| 227 | GrQuad fLocalQuad; |
| 228 | }; |
| 229 | |
Brian Salomon | ac70f84 | 2017-05-08 10:43:33 -0400 | [diff] [blame] | 230 | Helper fHelper; |
bsalomon | 9d7f184 | 2016-07-01 08:01:36 -0700 | [diff] [blame] | 231 | SkSTArray<1, RectInfo, true> fRects; |
Brian Salomon | ac70f84 | 2017-05-08 10:43:33 -0400 | [diff] [blame] | 232 | typedef GrMeshDrawOp INHERITED; |
joshualitt | 2244c27 | 2015-08-21 10:33:15 -0700 | [diff] [blame] | 233 | }; |
| 234 | |
Brian Salomon | ac70f84 | 2017-05-08 10:43:33 -0400 | [diff] [blame] | 235 | // We handle perspective in the local matrix or viewmatrix with special ops. |
| 236 | class NonAAFillRectPerspectiveOp final : public GrMeshDrawOp { |
| 237 | private: |
| 238 | using Helper = GrSimpleMeshDrawOpHelperWithStencil; |
| 239 | |
| 240 | public: |
Robert Phillips | 7c525e6 | 2018-06-12 10:11:12 -0400 | [diff] [blame] | 241 | static std::unique_ptr<GrDrawOp> Make(GrContext* context, |
| 242 | GrPaint&& paint, |
| 243 | const SkMatrix& viewMatrix, |
| 244 | const SkRect& rect, |
| 245 | const SkRect* localRect, |
| 246 | const SkMatrix* localMatrix, |
| 247 | GrAAType aaType, |
Brian Salomon | ac70f84 | 2017-05-08 10:43:33 -0400 | [diff] [blame] | 248 | const GrUserStencilSettings* stencilSettings) { |
| 249 | SkASSERT(GrAAType::kCoverage != aaType); |
Robert Phillips | 7c525e6 | 2018-06-12 10:11:12 -0400 | [diff] [blame] | 250 | return Helper::FactoryHelper<NonAAFillRectPerspectiveOp>(context, std::move(paint), |
| 251 | viewMatrix, rect, |
Brian Salomon | ac70f84 | 2017-05-08 10:43:33 -0400 | [diff] [blame] | 252 | localRect, localMatrix, aaType, |
| 253 | stencilSettings); |
| 254 | } |
| 255 | |
| 256 | NonAAFillRectPerspectiveOp() = delete; |
| 257 | |
| 258 | NonAAFillRectPerspectiveOp(const Helper::MakeArgs& args, GrColor color, |
| 259 | const SkMatrix& viewMatrix, const SkRect& rect, |
| 260 | const SkRect* localRect, const SkMatrix* localMatrix, |
| 261 | GrAAType aaType, const GrUserStencilSettings* stencilSettings) |
| 262 | : INHERITED(ClassID()) |
| 263 | , fHelper(args, aaType, stencilSettings) |
| 264 | , fViewMatrix(viewMatrix) { |
| 265 | SkASSERT(viewMatrix.hasPerspective() || (localMatrix && localMatrix->hasPerspective())); |
| 266 | RectInfo& info = fRects.push_back(); |
| 267 | info.fColor = color; |
| 268 | info.fRect = rect; |
| 269 | fHasLocalRect = SkToBool(localRect); |
| 270 | fHasLocalMatrix = SkToBool(localMatrix); |
| 271 | if (fHasLocalMatrix) { |
| 272 | fLocalMatrix = *localMatrix; |
| 273 | } |
| 274 | if (fHasLocalRect) { |
| 275 | info.fLocalRect = *localRect; |
| 276 | } |
| 277 | this->setTransformedBounds(rect, viewMatrix, HasAABloat::kNo, IsZeroArea::kNo); |
| 278 | } |
| 279 | |
| 280 | const char* name() const override { return "NonAAFillRectPerspectiveOp"; } |
| 281 | |
Robert Phillips | f1748f5 | 2017-09-14 14:11:24 -0400 | [diff] [blame] | 282 | void visitProxies(const VisitProxyFunc& func) const override { |
Robert Phillips | b493eeb | 2017-09-13 13:10:52 -0400 | [diff] [blame] | 283 | fHelper.visitProxies(func); |
| 284 | } |
| 285 | |
Brian Salomon | ac70f84 | 2017-05-08 10:43:33 -0400 | [diff] [blame] | 286 | SkString dumpInfo() const override { |
| 287 | SkString str; |
| 288 | str.appendf("# combined: %d\n", fRects.count()); |
| 289 | for (int i = 0; i < fRects.count(); ++i) { |
Mike Klein | 1d74620 | 2018-01-25 17:32:51 -0500 | [diff] [blame] | 290 | const RectInfo& geo = fRects[i]; |
Brian Salomon | ac70f84 | 2017-05-08 10:43:33 -0400 | [diff] [blame] | 291 | str.appendf("%d: Color: 0x%08x, Rect [L: %.2f, T: %.2f, R: %.2f, B: %.2f]\n", i, |
| 292 | geo.fColor, geo.fRect.fLeft, geo.fRect.fTop, geo.fRect.fRight, |
| 293 | geo.fRect.fBottom); |
| 294 | } |
Brian Salomon | 82dfd3d | 2017-06-14 12:30:35 -0400 | [diff] [blame] | 295 | str += fHelper.dumpInfo(); |
| 296 | str += INHERITED::dumpInfo(); |
Brian Salomon | ac70f84 | 2017-05-08 10:43:33 -0400 | [diff] [blame] | 297 | return str; |
| 298 | } |
| 299 | |
Brian Osman | 532b3f9 | 2018-07-11 10:02:07 -0400 | [diff] [blame] | 300 | RequiresDstTexture finalize(const GrCaps& caps, const GrAppliedClip* clip) override { |
Brian Salomon | ac70f84 | 2017-05-08 10:43:33 -0400 | [diff] [blame] | 301 | GrColor* color = &fRects.front().fColor; |
Brian Osman | 532b3f9 | 2018-07-11 10:02:07 -0400 | [diff] [blame] | 302 | return fHelper.xpRequiresDstTexture(caps, clip, GrProcessorAnalysisCoverage::kNone, color); |
Brian Salomon | ac70f84 | 2017-05-08 10:43:33 -0400 | [diff] [blame] | 303 | } |
| 304 | |
| 305 | FixedFunctionFlags fixedFunctionFlags() const override { return fHelper.fixedFunctionFlags(); } |
| 306 | |
| 307 | DEFINE_OP_CLASS_ID |
| 308 | |
| 309 | private: |
Brian Salomon | 91326c3 | 2017-08-09 16:02:19 -0400 | [diff] [blame] | 310 | void onPrepareDraws(Target* target) override { |
Brian Salomon | ac70f84 | 2017-05-08 10:43:33 -0400 | [diff] [blame] | 311 | sk_sp<GrGeometryProcessor> gp = make_perspective_gp( |
Ruiqi Mao | b609e6d | 2018-07-17 10:19:38 -0400 | [diff] [blame] | 312 | target->caps().shaderCaps(), |
| 313 | fViewMatrix, |
| 314 | fHasLocalRect, |
| 315 | fHasLocalMatrix ? &fLocalMatrix : nullptr); |
Brian Salomon | ac70f84 | 2017-05-08 10:43:33 -0400 | [diff] [blame] | 316 | if (!gp) { |
| 317 | SkDebugf("Couldn't create GrGeometryProcessor\n"); |
| 318 | return; |
| 319 | } |
Brian Salomon | 92be2f7 | 2018-06-19 14:33:47 -0400 | [diff] [blame] | 320 | size_t vertexStride = fHasLocalRect |
| 321 | ? sizeof(GrDefaultGeoProcFactory::PositionColorLocalCoordAttr) |
| 322 | : sizeof(GrDefaultGeoProcFactory::PositionColorAttr); |
| 323 | SkASSERT(vertexStride == gp->debugOnly_vertexStride()); |
Brian Salomon | ac70f84 | 2017-05-08 10:43:33 -0400 | [diff] [blame] | 324 | |
Brian Salomon | ac70f84 | 2017-05-08 10:43:33 -0400 | [diff] [blame] | 325 | int rectCount = fRects.count(); |
| 326 | |
Brian Salomon | d28a79d | 2017-10-16 13:01:07 -0400 | [diff] [blame] | 327 | sk_sp<const GrBuffer> indexBuffer = target->resourceProvider()->refQuadIndexBuffer(); |
Brian Salomon | 7eae3e0 | 2018-08-07 14:02:38 +0000 | [diff] [blame] | 328 | PatternHelper helper(target, GrPrimitiveType::kTriangles, vertexStride, indexBuffer.get(), |
| 329 | kVertsPerRect, kIndicesPerRect, rectCount); |
| 330 | void* vertices = helper.vertices(); |
Brian Salomon | ac70f84 | 2017-05-08 10:43:33 -0400 | [diff] [blame] | 331 | if (!vertices || !indexBuffer) { |
| 332 | SkDebugf("Could not allocate vertices\n"); |
| 333 | return; |
| 334 | } |
| 335 | |
| 336 | for (int i = 0; i < rectCount; i++) { |
| 337 | const RectInfo& info = fRects[i]; |
| 338 | intptr_t verts = |
| 339 | reinterpret_cast<intptr_t>(vertices) + i * kVertsPerRect * vertexStride; |
| 340 | if (fHasLocalRect) { |
| 341 | GrQuad quad(info.fLocalRect); |
| 342 | tesselate(verts, vertexStride, info.fColor, nullptr, info.fRect, &quad); |
| 343 | } else { |
| 344 | tesselate(verts, vertexStride, info.fColor, nullptr, info.fRect, nullptr); |
| 345 | } |
| 346 | } |
Brian Salomon | 4934890 | 2018-06-26 09:12:38 -0400 | [diff] [blame] | 347 | auto pipe = fHelper.makePipeline(target); |
Brian Salomon | 7eae3e0 | 2018-08-07 14:02:38 +0000 | [diff] [blame] | 348 | helper.recordDraw(target, std::move(gp), pipe.fPipeline, pipe.fFixedDynamicState); |
Brian Salomon | ac70f84 | 2017-05-08 10:43:33 -0400 | [diff] [blame] | 349 | } |
| 350 | |
Brian Salomon | 7eae3e0 | 2018-08-07 14:02:38 +0000 | [diff] [blame] | 351 | CombineResult onCombineIfPossible(GrOp* t, const GrCaps& caps) override { |
Brian Salomon | ac70f84 | 2017-05-08 10:43:33 -0400 | [diff] [blame] | 352 | NonAAFillRectPerspectiveOp* that = t->cast<NonAAFillRectPerspectiveOp>(); |
| 353 | if (!fHelper.isCompatible(that->fHelper, caps, this->bounds(), that->bounds())) { |
Brian Salomon | 7eae3e0 | 2018-08-07 14:02:38 +0000 | [diff] [blame] | 354 | return CombineResult::kCannotCombine; |
Brian Salomon | ac70f84 | 2017-05-08 10:43:33 -0400 | [diff] [blame] | 355 | } |
| 356 | |
| 357 | // We could combine across perspective vm changes if we really wanted to. |
| 358 | if (!fViewMatrix.cheapEqualTo(that->fViewMatrix)) { |
Brian Salomon | 7eae3e0 | 2018-08-07 14:02:38 +0000 | [diff] [blame] | 359 | return CombineResult::kCannotCombine; |
Brian Salomon | ac70f84 | 2017-05-08 10:43:33 -0400 | [diff] [blame] | 360 | } |
| 361 | if (fHasLocalRect != that->fHasLocalRect) { |
Brian Salomon | 7eae3e0 | 2018-08-07 14:02:38 +0000 | [diff] [blame] | 362 | return CombineResult::kCannotCombine; |
Brian Salomon | ac70f84 | 2017-05-08 10:43:33 -0400 | [diff] [blame] | 363 | } |
| 364 | if (fHasLocalMatrix && !fLocalMatrix.cheapEqualTo(that->fLocalMatrix)) { |
Brian Salomon | 7eae3e0 | 2018-08-07 14:02:38 +0000 | [diff] [blame] | 365 | return CombineResult::kCannotCombine; |
Brian Salomon | ac70f84 | 2017-05-08 10:43:33 -0400 | [diff] [blame] | 366 | } |
| 367 | |
| 368 | fRects.push_back_n(that->fRects.count(), that->fRects.begin()); |
| 369 | this->joinBounds(*that); |
Brian Salomon | 7eae3e0 | 2018-08-07 14:02:38 +0000 | [diff] [blame] | 370 | return CombineResult::kMerged; |
Brian Salomon | ac70f84 | 2017-05-08 10:43:33 -0400 | [diff] [blame] | 371 | } |
| 372 | |
| 373 | struct RectInfo { |
| 374 | SkRect fRect; |
| 375 | GrColor fColor; |
| 376 | SkRect fLocalRect; |
| 377 | }; |
| 378 | |
| 379 | SkSTArray<1, RectInfo, true> fRects; |
| 380 | Helper fHelper; |
| 381 | bool fHasLocalMatrix; |
| 382 | bool fHasLocalRect; |
| 383 | SkMatrix fLocalMatrix; |
| 384 | SkMatrix fViewMatrix; |
| 385 | |
| 386 | typedef GrMeshDrawOp INHERITED; |
| 387 | }; |
| 388 | |
| 389 | } // anonymous namespace |
| 390 | |
Brian Salomon | baaf439 | 2017-06-15 09:59:23 -0400 | [diff] [blame] | 391 | namespace GrRectOpFactory { |
bsalomon | b8cbd20 | 2016-06-30 13:09:48 -0700 | [diff] [blame] | 392 | |
Robert Phillips | 7c525e6 | 2018-06-12 10:11:12 -0400 | [diff] [blame] | 393 | std::unique_ptr<GrDrawOp> MakeNonAAFill(GrContext* context, |
| 394 | GrPaint&& paint, |
| 395 | const SkMatrix& viewMatrix, |
| 396 | const SkRect& rect, |
| 397 | GrAAType aaType, |
Brian Salomon | baaf439 | 2017-06-15 09:59:23 -0400 | [diff] [blame] | 398 | const GrUserStencilSettings* stencilSettings) { |
| 399 | if (viewMatrix.hasPerspective()) { |
Robert Phillips | 7c525e6 | 2018-06-12 10:11:12 -0400 | [diff] [blame] | 400 | return NonAAFillRectPerspectiveOp::Make(context, std::move(paint), viewMatrix, rect, |
| 401 | nullptr, nullptr, aaType, stencilSettings); |
Brian Salomon | 1ec03f3 | 2017-06-14 09:49:26 -0400 | [diff] [blame] | 402 | } else { |
Robert Phillips | 7c525e6 | 2018-06-12 10:11:12 -0400 | [diff] [blame] | 403 | return NonAAFillRectOp::Make(context, std::move(paint), viewMatrix, rect, nullptr, nullptr, |
Brian Salomon | baaf439 | 2017-06-15 09:59:23 -0400 | [diff] [blame] | 404 | aaType, stencilSettings); |
| 405 | } |
| 406 | } |
| 407 | |
Robert Phillips | 7c525e6 | 2018-06-12 10:11:12 -0400 | [diff] [blame] | 408 | std::unique_ptr<GrDrawOp> MakeNonAAFillWithLocalMatrix( |
| 409 | GrContext* context, |
| 410 | GrPaint&& paint, |
| 411 | const SkMatrix& viewMatrix, |
| 412 | const SkMatrix& localMatrix, |
| 413 | const SkRect& rect, |
| 414 | GrAAType aaType, |
| 415 | const GrUserStencilSettings* stencilSettings) { |
| 416 | if (viewMatrix.hasPerspective() || localMatrix.hasPerspective()) { |
| 417 | return NonAAFillRectPerspectiveOp::Make(context, std::move(paint), viewMatrix, rect, |
| 418 | nullptr, &localMatrix, aaType, stencilSettings); |
| 419 | } else { |
| 420 | return NonAAFillRectOp::Make(context, std::move(paint), viewMatrix, rect, nullptr, |
| 421 | &localMatrix, aaType, stencilSettings); |
| 422 | } |
| 423 | } |
| 424 | |
| 425 | std::unique_ptr<GrDrawOp> MakeNonAAFillWithLocalRect(GrContext* context, |
| 426 | GrPaint&& paint, |
| 427 | const SkMatrix& viewMatrix, |
| 428 | const SkRect& rect, |
| 429 | const SkRect& localRect, |
Brian Salomon | baaf439 | 2017-06-15 09:59:23 -0400 | [diff] [blame] | 430 | GrAAType aaType) { |
| 431 | if (viewMatrix.hasPerspective()) { |
Robert Phillips | 7c525e6 | 2018-06-12 10:11:12 -0400 | [diff] [blame] | 432 | return NonAAFillRectPerspectiveOp::Make(context, std::move(paint), viewMatrix, rect, |
| 433 | &localRect, nullptr, aaType, nullptr); |
Brian Salomon | baaf439 | 2017-06-15 09:59:23 -0400 | [diff] [blame] | 434 | } else { |
Robert Phillips | 7c525e6 | 2018-06-12 10:11:12 -0400 | [diff] [blame] | 435 | return NonAAFillRectOp::Make(context, std::move(paint), viewMatrix, rect, &localRect, |
| 436 | nullptr, aaType, nullptr); |
Brian Salomon | baaf439 | 2017-06-15 09:59:23 -0400 | [diff] [blame] | 437 | } |
| 438 | } |
| 439 | |
| 440 | } // namespace GrRectOpFactory |
joshualitt | 9c80b5f | 2015-08-13 10:05:51 -0700 | [diff] [blame] | 441 | |
| 442 | /////////////////////////////////////////////////////////////////////////////////////////////////// |
Brian Salomon | 1772663 | 2017-05-12 14:09:46 -0400 | [diff] [blame] | 443 | |
Brian Salomon | 0c26a9d | 2017-07-06 10:09:38 -0400 | [diff] [blame] | 444 | #if GR_TEST_UTILS |
| 445 | |
Brian Salomon | 1772663 | 2017-05-12 14:09:46 -0400 | [diff] [blame] | 446 | GR_DRAW_OP_TEST_DEFINE(NonAAFillRectOp) { |
| 447 | SkRect rect = GrTest::TestRect(random); |
| 448 | SkRect localRect = GrTest::TestRect(random); |
| 449 | SkMatrix viewMatrix = GrTest::TestMatrixInvertible(random); |
| 450 | SkMatrix localMatrix = GrTest::TestMatrix(random); |
Brian Salomon | 1772663 | 2017-05-12 14:09:46 -0400 | [diff] [blame] | 451 | const GrUserStencilSettings* stencil = GrGetRandomStencil(random, context); |
| 452 | GrAAType aaType = GrAAType::kNone; |
| 453 | if (fsaaType == GrFSAAType::kUnifiedMSAA) { |
| 454 | aaType = random->nextBool() ? GrAAType::kMSAA : GrAAType::kNone; |
| 455 | } |
Brian Salomon | baaf439 | 2017-06-15 09:59:23 -0400 | [diff] [blame] | 456 | const SkRect* lr = random->nextBool() ? &localRect : nullptr; |
| 457 | const SkMatrix* lm = random->nextBool() ? &localMatrix : nullptr; |
| 458 | if (viewMatrix.hasPerspective() || (lm && lm->hasPerspective())) { |
Robert Phillips | 7c525e6 | 2018-06-12 10:11:12 -0400 | [diff] [blame] | 459 | return NonAAFillRectPerspectiveOp::Make(context, std::move(paint), viewMatrix, rect, |
| 460 | lr, lm, aaType, stencil); |
Brian Salomon | baaf439 | 2017-06-15 09:59:23 -0400 | [diff] [blame] | 461 | } else { |
Robert Phillips | 7c525e6 | 2018-06-12 10:11:12 -0400 | [diff] [blame] | 462 | return NonAAFillRectOp::Make(context, std::move(paint), viewMatrix, rect, |
| 463 | lr, lm, aaType, stencil); |
Brian Salomon | baaf439 | 2017-06-15 09:59:23 -0400 | [diff] [blame] | 464 | } |
Brian Salomon | 1772663 | 2017-05-12 14:09:46 -0400 | [diff] [blame] | 465 | } |
Brian Salomon | 0c26a9d | 2017-07-06 10:09:38 -0400 | [diff] [blame] | 466 | |
| 467 | #endif |