Brian Salomon | 3416969 | 2017-08-28 15:32:01 -0400 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2017 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. |
| 6 | */ |
| 7 | |
| 8 | #include "GrTextureOp.h" |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 9 | #include <new> |
Brian Salomon | 3416969 | 2017-08-28 15:32:01 -0400 | [diff] [blame] | 10 | #include "GrAppliedClip.h" |
Brian Salomon | 336ce7b | 2017-09-08 08:23:58 -0400 | [diff] [blame] | 11 | #include "GrCaps.h" |
Robert Phillips | 7c525e6 | 2018-06-12 10:11:12 -0400 | [diff] [blame] | 12 | #include "GrContext.h" |
| 13 | #include "GrContextPriv.h" |
Brian Salomon | 3416969 | 2017-08-28 15:32:01 -0400 | [diff] [blame] | 14 | #include "GrDrawOpTest.h" |
| 15 | #include "GrGeometryProcessor.h" |
Greg Daniel | 7a82edf | 2018-12-04 10:54:34 -0500 | [diff] [blame^] | 16 | #include "GrGpu.h" |
Robert Phillips | 7c525e6 | 2018-06-12 10:11:12 -0400 | [diff] [blame] | 17 | #include "GrMemoryPool.h" |
Brian Salomon | 3416969 | 2017-08-28 15:32:01 -0400 | [diff] [blame] | 18 | #include "GrMeshDrawOp.h" |
| 19 | #include "GrOpFlushState.h" |
| 20 | #include "GrQuad.h" |
Michael Ludwig | 460eb5e | 2018-10-29 11:09:29 -0400 | [diff] [blame] | 21 | #include "GrQuadPerEdgeAA.h" |
Brian Salomon | 3416969 | 2017-08-28 15:32:01 -0400 | [diff] [blame] | 22 | #include "GrResourceProvider.h" |
Greg Daniel | 7a82edf | 2018-12-04 10:54:34 -0500 | [diff] [blame^] | 23 | #include "GrResourceProviderPriv.h" |
Brian Salomon | 3416969 | 2017-08-28 15:32:01 -0400 | [diff] [blame] | 24 | #include "GrShaderCaps.h" |
| 25 | #include "GrTexture.h" |
Brian Salomon | 336ce7b | 2017-09-08 08:23:58 -0400 | [diff] [blame] | 26 | #include "GrTexturePriv.h" |
Brian Salomon | 3416969 | 2017-08-28 15:32:01 -0400 | [diff] [blame] | 27 | #include "GrTextureProxy.h" |
| 28 | #include "SkGr.h" |
Brian Salomon | 336ce7b | 2017-09-08 08:23:58 -0400 | [diff] [blame] | 29 | #include "SkMathPriv.h" |
Brian Salomon | a33b67c | 2018-05-17 10:42:14 -0400 | [diff] [blame] | 30 | #include "SkMatrixPriv.h" |
Brian Salomon | b5ef1f9 | 2018-01-11 11:46:21 -0500 | [diff] [blame] | 31 | #include "SkPoint.h" |
| 32 | #include "SkPoint3.h" |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 33 | #include "SkRectPriv.h" |
Hal Canary | c640d0d | 2018-06-13 09:59:02 -0400 | [diff] [blame] | 34 | #include "SkTo.h" |
Brian Salomon | 3416969 | 2017-08-28 15:32:01 -0400 | [diff] [blame] | 35 | #include "glsl/GrGLSLVarying.h" |
| 36 | |
| 37 | namespace { |
| 38 | |
Michael Ludwig | 460eb5e | 2018-10-29 11:09:29 -0400 | [diff] [blame] | 39 | using Domain = GrQuadPerEdgeAA::Domain; |
Michael Ludwig | c182b94 | 2018-11-16 10:27:51 -0500 | [diff] [blame] | 40 | using VertexSpec = GrQuadPerEdgeAA::VertexSpec; |
Brian Osman | 3d139a4 | 2018-11-19 10:42:10 -0500 | [diff] [blame] | 41 | using ColorType = GrQuadPerEdgeAA::ColorType; |
Brian Salomon | b80ffee | 2018-05-23 16:39:39 -0400 | [diff] [blame] | 42 | |
Brian Salomon | 0087c83 | 2018-10-15 14:48:20 -0400 | [diff] [blame] | 43 | static bool filter_has_effect_for_rect_stays_rect(const GrPerspQuad& quad, const SkRect& srcRect) { |
Michael Ludwig | c182b94 | 2018-11-16 10:27:51 -0500 | [diff] [blame] | 44 | SkASSERT(quad.quadType() == GrQuadType::kRect); |
Brian Salomon | 0087c83 | 2018-10-15 14:48:20 -0400 | [diff] [blame] | 45 | float ql = quad.x(0); |
| 46 | float qt = quad.y(0); |
| 47 | float qr = quad.x(3); |
| 48 | float qb = quad.y(3); |
| 49 | // Disable filtering when there is no scaling of the src rect and the src rect and dst rect |
| 50 | // align fractionally. If we allow inverted src rects this logic needs to consider that. |
| 51 | SkASSERT(srcRect.isSorted()); |
| 52 | return (qr - ql) != srcRect.width() || (qb - qt) != srcRect.height() || |
| 53 | SkScalarFraction(ql) != SkScalarFraction(srcRect.fLeft) || |
| 54 | SkScalarFraction(qt) != SkScalarFraction(srcRect.fTop); |
| 55 | } |
| 56 | |
Michael Ludwig | 460eb5e | 2018-10-29 11:09:29 -0400 | [diff] [blame] | 57 | static SkRect compute_domain(Domain domain, GrSamplerState::Filter filter, |
| 58 | GrSurfaceOrigin origin, const SkRect& srcRect, float iw, float ih) { |
| 59 | static constexpr SkRect kLargeRect = {-2, -2, 2, 2}; |
| 60 | if (domain == Domain::kNo) { |
| 61 | // Either the quad has no domain constraint and is batched with a domain constrained op |
| 62 | // (in which case we want a domain that doesn't restrict normalized tex coords), or the |
| 63 | // entire op doesn't use the domain, in which case the returned value is ignored. |
| 64 | return kLargeRect; |
| 65 | } |
| 66 | |
| 67 | auto ltrb = Sk4f::Load(&srcRect); |
| 68 | if (filter == GrSamplerState::Filter::kBilerp) { |
| 69 | auto rblt = SkNx_shuffle<2, 3, 0, 1>(ltrb); |
| 70 | auto whwh = (rblt - ltrb).abs(); |
| 71 | auto c = (rblt + ltrb) * 0.5f; |
| 72 | static const Sk4f kOffsets = {0.5f, 0.5f, -0.5f, -0.5f}; |
| 73 | ltrb = (whwh < 1.f).thenElse(c, ltrb + kOffsets); |
| 74 | } |
| 75 | ltrb *= Sk4f(iw, ih, iw, ih); |
| 76 | if (origin == kBottomLeft_GrSurfaceOrigin) { |
| 77 | static const Sk4f kMul = {1.f, -1.f, 1.f, -1.f}; |
| 78 | static const Sk4f kAdd = {0.f, 1.f, 0.f, 1.f}; |
| 79 | ltrb = SkNx_shuffle<0, 3, 2, 1>(kMul * ltrb + kAdd); |
| 80 | } |
| 81 | |
| 82 | SkRect domainRect; |
| 83 | ltrb.store(&domainRect); |
| 84 | return domainRect; |
| 85 | } |
| 86 | |
| 87 | static GrPerspQuad compute_src_quad(GrSurfaceOrigin origin, const SkRect& srcRect, |
| 88 | float iw, float ih) { |
| 89 | // Convert the pixel-space src rectangle into normalized texture coordinates |
| 90 | SkRect texRect = { |
| 91 | iw * srcRect.fLeft, |
| 92 | ih * srcRect.fTop, |
| 93 | iw * srcRect.fRight, |
| 94 | ih * srcRect.fBottom |
| 95 | }; |
| 96 | if (origin == kBottomLeft_GrSurfaceOrigin) { |
| 97 | texRect.fTop = 1.f - texRect.fTop; |
| 98 | texRect.fBottom = 1.f - texRect.fBottom; |
| 99 | } |
| 100 | return GrPerspQuad(texRect, SkMatrix::I()); |
| 101 | } |
| 102 | |
Brian Salomon | 3416969 | 2017-08-28 15:32:01 -0400 | [diff] [blame] | 103 | /** |
| 104 | * Op that implements GrTextureOp::Make. It draws textured quads. Each quad can modulate against a |
| 105 | * the texture by color. The blend with the destination is always src-over. The edges are non-AA. |
| 106 | */ |
| 107 | class TextureOp final : public GrMeshDrawOp { |
| 108 | public: |
Robert Phillips | 7c525e6 | 2018-06-12 10:11:12 -0400 | [diff] [blame] | 109 | static std::unique_ptr<GrDrawOp> Make(GrContext* context, |
| 110 | sk_sp<GrTextureProxy> proxy, |
| 111 | GrSamplerState::Filter filter, |
Brian Osman | 3d139a4 | 2018-11-19 10:42:10 -0500 | [diff] [blame] | 112 | const SkPMColor4f& color, |
Robert Phillips | 7c525e6 | 2018-06-12 10:11:12 -0400 | [diff] [blame] | 113 | const SkRect& srcRect, |
| 114 | const SkRect& dstRect, |
| 115 | GrAAType aaType, |
Brian Salomon | 2213ee9 | 2018-10-02 10:44:21 -0400 | [diff] [blame] | 116 | GrQuadAAFlags aaFlags, |
Robert Phillips | 7c525e6 | 2018-06-12 10:11:12 -0400 | [diff] [blame] | 117 | SkCanvas::SrcRectConstraint constraint, |
Brian Osman | 2b23c4b | 2018-06-01 12:25:08 -0400 | [diff] [blame] | 118 | const SkMatrix& viewMatrix, |
Brian Osman | 3d139a4 | 2018-11-19 10:42:10 -0500 | [diff] [blame] | 119 | sk_sp<GrColorSpaceXform> textureColorSpaceXform) { |
Robert Phillips | c994a93 | 2018-06-19 13:09:54 -0400 | [diff] [blame] | 120 | GrOpMemoryPool* pool = context->contextPriv().opMemoryPool(); |
| 121 | |
Brian Salomon | 2213ee9 | 2018-10-02 10:44:21 -0400 | [diff] [blame] | 122 | return pool->allocate<TextureOp>( |
| 123 | std::move(proxy), filter, color, srcRect, dstRect, aaType, aaFlags, constraint, |
Brian Osman | 3d139a4 | 2018-11-19 10:42:10 -0500 | [diff] [blame] | 124 | viewMatrix, std::move(textureColorSpaceXform)); |
Brian Salomon | 3416969 | 2017-08-28 15:32:01 -0400 | [diff] [blame] | 125 | } |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 126 | static std::unique_ptr<GrDrawOp> Make(GrContext* context, |
| 127 | const GrRenderTargetContext::TextureSetEntry set[], |
Brian Salomon | d003d22 | 2018-11-26 13:25:05 -0500 | [diff] [blame] | 128 | int cnt, GrSamplerState::Filter filter, GrAAType aaType, |
| 129 | const SkMatrix& viewMatrix, |
Brian Osman | 3d139a4 | 2018-11-19 10:42:10 -0500 | [diff] [blame] | 130 | sk_sp<GrColorSpaceXform> textureColorSpaceXform) { |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 131 | size_t size = sizeof(TextureOp) + sizeof(Proxy) * (cnt - 1); |
| 132 | GrOpMemoryPool* pool = context->contextPriv().opMemoryPool(); |
| 133 | void* mem = pool->allocate(size); |
Brian Salomon | d003d22 | 2018-11-26 13:25:05 -0500 | [diff] [blame] | 134 | return std::unique_ptr<GrDrawOp>(new (mem) TextureOp(set, cnt, filter, aaType, viewMatrix, |
| 135 | std::move(textureColorSpaceXform))); |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 136 | } |
Brian Salomon | 3416969 | 2017-08-28 15:32:01 -0400 | [diff] [blame] | 137 | |
Brian Salomon | 336ce7b | 2017-09-08 08:23:58 -0400 | [diff] [blame] | 138 | ~TextureOp() override { |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 139 | for (unsigned p = 0; p < fProxyCnt; ++p) { |
| 140 | if (fFinalized) { |
| 141 | fProxies[p].fProxy->completedRead(); |
| 142 | } else { |
| 143 | fProxies[p].fProxy->unref(); |
| 144 | } |
Brian Salomon | 336ce7b | 2017-09-08 08:23:58 -0400 | [diff] [blame] | 145 | } |
| 146 | } |
Brian Salomon | 3416969 | 2017-08-28 15:32:01 -0400 | [diff] [blame] | 147 | |
| 148 | const char* name() const override { return "TextureOp"; } |
| 149 | |
Brian Salomon | 7d94bb5 | 2018-10-12 14:37:19 -0400 | [diff] [blame] | 150 | void visitProxies(const VisitProxyFunc& func, VisitorType visitor) const override { |
| 151 | if (visitor == VisitorType::kAllocatorGather && fCanSkipAllocatorGather) { |
| 152 | return; |
| 153 | } |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 154 | for (unsigned p = 0; p < fProxyCnt; ++p) { |
| 155 | func(fProxies[p].fProxy); |
| 156 | } |
| 157 | } |
Robert Phillips | b493eeb | 2017-09-13 13:10:52 -0400 | [diff] [blame] | 158 | |
Brian Osman | 9a390ac | 2018-11-12 09:47:48 -0500 | [diff] [blame] | 159 | #ifdef SK_DEBUG |
Brian Salomon | 3416969 | 2017-08-28 15:32:01 -0400 | [diff] [blame] | 160 | SkString dumpInfo() const override { |
| 161 | SkString str; |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 162 | str.appendf("# draws: %d\n", fQuads.count()); |
| 163 | int q = 0; |
| 164 | for (unsigned p = 0; p < fProxyCnt; ++p) { |
| 165 | str.appendf("Proxy ID: %d, Filter: %d\n", fProxies[p].fProxy->uniqueID().asUInt(), |
| 166 | static_cast<int>(fFilter)); |
| 167 | for (int i = 0; i < fProxies[p].fQuadCnt; ++i, ++q) { |
| 168 | const Quad& quad = fQuads[q]; |
| 169 | str.appendf( |
| 170 | "%d: Color: 0x%08x, TexRect [L: %.2f, T: %.2f, R: %.2f, B: %.2f] " |
| 171 | "Quad [(%.2f, %.2f), (%.2f, %.2f), (%.2f, %.2f), (%.2f, %.2f)]\n", |
Brian Osman | 3d139a4 | 2018-11-19 10:42:10 -0500 | [diff] [blame] | 172 | i, quad.color().toBytes_RGBA(), quad.srcRect().fLeft, quad.srcRect().fTop, |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 173 | quad.srcRect().fRight, quad.srcRect().fBottom, quad.quad().point(0).fX, |
| 174 | quad.quad().point(0).fY, quad.quad().point(1).fX, quad.quad().point(1).fY, |
| 175 | quad.quad().point(2).fX, quad.quad().point(2).fY, quad.quad().point(3).fX, |
| 176 | quad.quad().point(3).fY); |
| 177 | } |
Brian Salomon | 3416969 | 2017-08-28 15:32:01 -0400 | [diff] [blame] | 178 | } |
| 179 | str += INHERITED::dumpInfo(); |
| 180 | return str; |
| 181 | } |
Brian Osman | 9a390ac | 2018-11-12 09:47:48 -0500 | [diff] [blame] | 182 | #endif |
Brian Salomon | 3416969 | 2017-08-28 15:32:01 -0400 | [diff] [blame] | 183 | |
Brian Osman | 532b3f9 | 2018-07-11 10:02:07 -0400 | [diff] [blame] | 184 | RequiresDstTexture finalize(const GrCaps& caps, const GrAppliedClip* clip) override { |
Brian Salomon | 3416969 | 2017-08-28 15:32:01 -0400 | [diff] [blame] | 185 | SkASSERT(!fFinalized); |
| 186 | fFinalized = true; |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 187 | for (unsigned p = 0; p < fProxyCnt; ++p) { |
| 188 | fProxies[p].fProxy->addPendingRead(); |
| 189 | fProxies[p].fProxy->unref(); |
| 190 | } |
Brian Salomon | 3416969 | 2017-08-28 15:32:01 -0400 | [diff] [blame] | 191 | return RequiresDstTexture::kNo; |
| 192 | } |
| 193 | |
Brian Salomon | 485b8c6 | 2018-01-12 15:11:06 -0500 | [diff] [blame] | 194 | FixedFunctionFlags fixedFunctionFlags() const override { |
| 195 | return this->aaType() == GrAAType::kMSAA ? FixedFunctionFlags::kUsesHWAA |
| 196 | : FixedFunctionFlags::kNone; |
| 197 | } |
Brian Salomon | 3416969 | 2017-08-28 15:32:01 -0400 | [diff] [blame] | 198 | |
| 199 | DEFINE_OP_CLASS_ID |
| 200 | |
| 201 | private: |
Robert Phillips | 7c525e6 | 2018-06-12 10:11:12 -0400 | [diff] [blame] | 202 | friend class ::GrOpMemoryPool; |
Brian Salomon | 762d5e7 | 2017-12-01 10:25:08 -0500 | [diff] [blame] | 203 | |
Brian Osman | 3d139a4 | 2018-11-19 10:42:10 -0500 | [diff] [blame] | 204 | TextureOp(sk_sp<GrTextureProxy> proxy, GrSamplerState::Filter filter, const SkPMColor4f& color, |
Brian Salomon | 2213ee9 | 2018-10-02 10:44:21 -0400 | [diff] [blame] | 205 | const SkRect& srcRect, const SkRect& dstRect, GrAAType aaType, GrQuadAAFlags aaFlags, |
Brian Salomon | b80ffee | 2018-05-23 16:39:39 -0400 | [diff] [blame] | 206 | SkCanvas::SrcRectConstraint constraint, const SkMatrix& viewMatrix, |
Brian Osman | 3d139a4 | 2018-11-19 10:42:10 -0500 | [diff] [blame] | 207 | sk_sp<GrColorSpaceXform> textureColorSpaceXform) |
Brian Salomon | 3416969 | 2017-08-28 15:32:01 -0400 | [diff] [blame] | 208 | : INHERITED(ClassID()) |
Brian Osman | 3ebd354 | 2018-07-30 14:36:53 -0400 | [diff] [blame] | 209 | , fTextureColorSpaceXform(std::move(textureColorSpaceXform)) |
Brian Salomon | 0087c83 | 2018-10-15 14:48:20 -0400 | [diff] [blame] | 210 | , fFilter(static_cast<unsigned>(filter)) |
Brian Osman | 2b23c4b | 2018-06-01 12:25:08 -0400 | [diff] [blame] | 211 | , fFinalized(0) { |
Michael Ludwig | 6bee776 | 2018-10-19 09:50:36 -0400 | [diff] [blame] | 212 | GrQuadType quadType = GrQuadTypeForTransformedRect(viewMatrix); |
Brian Salomon | 594b64c | 2018-05-29 12:47:57 -0400 | [diff] [blame] | 213 | auto quad = GrPerspQuad(dstRect, viewMatrix); |
Michael Ludwig | 6bee776 | 2018-10-19 09:50:36 -0400 | [diff] [blame] | 214 | |
| 215 | // Clean up disparities between the overall aa type and edge configuration and apply |
| 216 | // optimizations based on the rect and matrix when appropriate |
| 217 | GrResolveAATypeForQuad(aaType, aaFlags, quad, quadType, &aaType, &aaFlags); |
| 218 | fAAType = static_cast<unsigned>(aaType); |
| 219 | |
Michael Ludwig | f995c05 | 2018-11-26 15:24:29 -0500 | [diff] [blame] | 220 | fQuadType = static_cast<unsigned>(quadType); |
Brian Salomon | f170904 | 2018-10-03 11:57:00 -0400 | [diff] [blame] | 221 | // We expect our caller to have already caught this optimization. |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 222 | SkASSERT(!srcRect.contains(proxy->getWorstCaseBoundsRect()) || |
Brian Salomon | f170904 | 2018-10-03 11:57:00 -0400 | [diff] [blame] | 223 | constraint == SkCanvas::kFast_SrcRectConstraint); |
Michael Ludwig | c182b94 | 2018-11-16 10:27:51 -0500 | [diff] [blame] | 224 | if (quadType == GrQuadType::kRect) { |
Michael Ludwig | 6bee776 | 2018-10-19 09:50:36 -0400 | [diff] [blame] | 225 | // Disable filtering if possible (note AA optimizations for rects are automatically |
| 226 | // handled above in GrResolveAATypeForQuad). |
Brian Salomon | 0087c83 | 2018-10-15 14:48:20 -0400 | [diff] [blame] | 227 | if (this->filter() != GrSamplerState::Filter::kNearest && |
| 228 | !filter_has_effect_for_rect_stays_rect(quad, srcRect)) { |
| 229 | fFilter = static_cast<unsigned>(GrSamplerState::Filter::kNearest); |
Brian Salomon | 594b64c | 2018-05-29 12:47:57 -0400 | [diff] [blame] | 230 | } |
| 231 | } |
Brian Salomon | f09abc5 | 2018-10-03 15:59:04 -0400 | [diff] [blame] | 232 | // We may have had a strict constraint with nearest filter solely due to possible AA bloat. |
| 233 | // If we don't have (or determined we don't need) coverage AA then we can skip using a |
| 234 | // domain. |
| 235 | if (constraint == SkCanvas::kStrict_SrcRectConstraint && |
Brian Salomon | 0087c83 | 2018-10-15 14:48:20 -0400 | [diff] [blame] | 236 | this->filter() == GrSamplerState::Filter::kNearest && |
Michael Ludwig | 6bee776 | 2018-10-19 09:50:36 -0400 | [diff] [blame] | 237 | aaType != GrAAType::kCoverage) { |
Brian Salomon | f09abc5 | 2018-10-03 15:59:04 -0400 | [diff] [blame] | 238 | constraint = SkCanvas::kFast_SrcRectConstraint; |
| 239 | } |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 240 | const auto& draw = fQuads.emplace_back(srcRect, quad, aaFlags, constraint, color); |
| 241 | fProxyCnt = 1; |
| 242 | fProxies[0] = {proxy.release(), 1}; |
Brian Salomon | 0087c83 | 2018-10-15 14:48:20 -0400 | [diff] [blame] | 243 | auto bounds = quad.bounds(); |
Michael Ludwig | 6bee776 | 2018-10-19 09:50:36 -0400 | [diff] [blame] | 244 | this->setBounds(bounds, HasAABloat(aaType == GrAAType::kCoverage), IsZeroArea::kNo); |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 245 | fDomain = static_cast<unsigned>(draw.domain()); |
Brian Osman | 3d139a4 | 2018-11-19 10:42:10 -0500 | [diff] [blame] | 246 | fWideColor = !SkPMColor4fFitsInBytes(color); |
Brian Salomon | 7d94bb5 | 2018-10-12 14:37:19 -0400 | [diff] [blame] | 247 | fCanSkipAllocatorGather = |
| 248 | static_cast<unsigned>(fProxies[0].fProxy->canSkipResourceAllocator()); |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 249 | } |
| 250 | TextureOp(const GrRenderTargetContext::TextureSetEntry set[], int cnt, |
Brian Salomon | d003d22 | 2018-11-26 13:25:05 -0500 | [diff] [blame] | 251 | GrSamplerState::Filter filter, GrAAType aaType, const SkMatrix& viewMatrix, |
| 252 | sk_sp<GrColorSpaceXform> textureColorSpaceXform) |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 253 | : INHERITED(ClassID()) |
| 254 | , fTextureColorSpaceXform(std::move(textureColorSpaceXform)) |
Brian Salomon | 0087c83 | 2018-10-15 14:48:20 -0400 | [diff] [blame] | 255 | , fFilter(static_cast<unsigned>(filter)) |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 256 | , fFinalized(0) { |
| 257 | fQuads.reserve(cnt); |
| 258 | fProxyCnt = SkToUInt(cnt); |
| 259 | SkRect bounds = SkRectPriv::MakeLargestInverted(); |
Michael Ludwig | 6bee776 | 2018-10-19 09:50:36 -0400 | [diff] [blame] | 260 | GrAAType overallAAType = GrAAType::kNone; // aa type maximally compatible with all dst rects |
Brian Salomon | 0087c83 | 2018-10-15 14:48:20 -0400 | [diff] [blame] | 261 | bool mustFilter = false; |
Brian Salomon | 7d94bb5 | 2018-10-12 14:37:19 -0400 | [diff] [blame] | 262 | fCanSkipAllocatorGather = static_cast<unsigned>(true); |
Michael Ludwig | 6bee776 | 2018-10-19 09:50:36 -0400 | [diff] [blame] | 263 | // All dst rects are transformed by the same view matrix, so their quad types are identical |
| 264 | GrQuadType quadType = GrQuadTypeForTransformedRect(viewMatrix); |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 265 | for (unsigned p = 0; p < fProxyCnt; ++p) { |
| 266 | fProxies[p].fProxy = SkRef(set[p].fProxy.get()); |
| 267 | fProxies[p].fQuadCnt = 1; |
| 268 | SkASSERT(fProxies[p].fProxy->textureType() == fProxies[0].fProxy->textureType()); |
| 269 | SkASSERT(fProxies[p].fProxy->config() == fProxies[0].fProxy->config()); |
Brian Salomon | 7d94bb5 | 2018-10-12 14:37:19 -0400 | [diff] [blame] | 270 | if (!fProxies[p].fProxy->canSkipResourceAllocator()) { |
| 271 | fCanSkipAllocatorGather = static_cast<unsigned>(false); |
| 272 | } |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 273 | auto quad = GrPerspQuad(set[p].fDstRect, viewMatrix); |
| 274 | bounds.joinPossiblyEmptyRect(quad.bounds()); |
Michael Ludwig | 6bee776 | 2018-10-19 09:50:36 -0400 | [diff] [blame] | 275 | GrQuadAAFlags aaFlags; |
| 276 | // Don't update the overall aaType, might be inappropriate for some of the quads |
| 277 | GrAAType aaForQuad; |
| 278 | GrResolveAATypeForQuad(aaType, set[p].fAAFlags, quad, quadType, &aaForQuad, &aaFlags); |
| 279 | // Resolve sets aaForQuad to aaType or None, there is never a change between aa methods |
| 280 | SkASSERT(aaForQuad == GrAAType::kNone || aaForQuad == aaType); |
| 281 | if (overallAAType == GrAAType::kNone && aaForQuad != GrAAType::kNone) { |
| 282 | overallAAType = aaType; |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 283 | } |
Brian Salomon | 0087c83 | 2018-10-15 14:48:20 -0400 | [diff] [blame] | 284 | if (!mustFilter && this->filter() != GrSamplerState::Filter::kNearest) { |
Michael Ludwig | c182b94 | 2018-11-16 10:27:51 -0500 | [diff] [blame] | 285 | mustFilter = quadType != GrQuadType::kRect || |
Brian Salomon | 0087c83 | 2018-10-15 14:48:20 -0400 | [diff] [blame] | 286 | filter_has_effect_for_rect_stays_rect(quad, set[p].fSrcRect); |
| 287 | } |
Brian Salomon | d003d22 | 2018-11-26 13:25:05 -0500 | [diff] [blame] | 288 | float alpha = SkTPin(set[p].fAlpha, 0.f, 1.f); |
| 289 | SkPMColor4f color{alpha, alpha, alpha, alpha}; |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 290 | fQuads.emplace_back(set[p].fSrcRect, quad, aaFlags, SkCanvas::kFast_SrcRectConstraint, |
| 291 | color); |
| 292 | } |
Michael Ludwig | 6bee776 | 2018-10-19 09:50:36 -0400 | [diff] [blame] | 293 | fAAType = static_cast<unsigned>(overallAAType); |
Brian Salomon | 0087c83 | 2018-10-15 14:48:20 -0400 | [diff] [blame] | 294 | if (!mustFilter) { |
| 295 | fFilter = static_cast<unsigned>(GrSamplerState::Filter::kNearest); |
| 296 | } |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 297 | this->setBounds(bounds, HasAABloat(this->aaType() == GrAAType::kCoverage), IsZeroArea::kNo); |
Michael Ludwig | f995c05 | 2018-11-26 15:24:29 -0500 | [diff] [blame] | 298 | fQuadType = static_cast<unsigned>(quadType); |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 299 | fDomain = static_cast<unsigned>(false); |
Brian Salomon | 574d616 | 2018-11-19 16:57:25 -0500 | [diff] [blame] | 300 | fWideColor = static_cast<unsigned>(false); |
Brian Salomon | 3416969 | 2017-08-28 15:32:01 -0400 | [diff] [blame] | 301 | } |
| 302 | |
Brian Salomon | 574d616 | 2018-11-19 16:57:25 -0500 | [diff] [blame] | 303 | void tess(void* v, const VertexSpec& spec, const GrTextureProxy* proxy, int start, |
| 304 | int cnt) const { |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 305 | TRACE_EVENT0("skia", TRACE_FUNC); |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 306 | auto origin = proxy->origin(); |
| 307 | const auto* texture = proxy->peekTexture(); |
Brian Salomon | 7eae3e0 | 2018-08-07 14:02:38 +0000 | [diff] [blame] | 308 | float iw = 1.f / texture->width(); |
| 309 | float ih = 1.f / texture->height(); |
| 310 | |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 311 | for (int i = start; i < start + cnt; ++i) { |
| 312 | const auto q = fQuads[i]; |
Michael Ludwig | 460eb5e | 2018-10-29 11:09:29 -0400 | [diff] [blame] | 313 | GrPerspQuad srcQuad = compute_src_quad(origin, q.srcRect(), iw, ih); |
| 314 | SkRect domain = compute_domain(q.domain(), this->filter(), origin, q.srcRect(), iw, ih); |
Michael Ludwig | c182b94 | 2018-11-16 10:27:51 -0500 | [diff] [blame] | 315 | v = GrQuadPerEdgeAA::Tessellate(v, spec, q.quad(), q.color(), srcQuad, domain, |
| 316 | q.aaFlags()); |
Brian Salomon | 17031a7 | 2018-05-22 14:14:07 -0400 | [diff] [blame] | 317 | } |
| 318 | } |
| 319 | |
Brian Salomon | 3416969 | 2017-08-28 15:32:01 -0400 | [diff] [blame] | 320 | void onPrepareDraws(Target* target) override { |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 321 | TRACE_EVENT0("skia", TRACE_FUNC); |
Michael Ludwig | f995c05 | 2018-11-26 15:24:29 -0500 | [diff] [blame] | 322 | GrQuadType quadType = GrQuadType::kRect; |
Brian Salomon | f723264 | 2018-09-19 08:58:08 -0400 | [diff] [blame] | 323 | Domain domain = Domain::kNo; |
Brian Osman | 3d139a4 | 2018-11-19 10:42:10 -0500 | [diff] [blame] | 324 | bool wideColor = false; |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 325 | int numProxies = 0; |
Brian Salomon | 4b8178f | 2018-10-12 13:18:27 -0400 | [diff] [blame] | 326 | int numTotalQuads = 0; |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 327 | auto textureType = fProxies[0].fProxy->textureType(); |
| 328 | auto config = fProxies[0].fProxy->config(); |
Brian Salomon | ae7d770 | 2018-10-14 15:05:45 -0400 | [diff] [blame] | 329 | GrAAType aaType = this->aaType(); |
Brian Salomon | f723264 | 2018-09-19 08:58:08 -0400 | [diff] [blame] | 330 | for (const auto& op : ChainRange<TextureOp>(this)) { |
Michael Ludwig | f995c05 | 2018-11-26 15:24:29 -0500 | [diff] [blame] | 331 | if (op.quadType() > quadType) { |
| 332 | quadType = op.quadType(); |
| 333 | } |
Brian Salomon | f723264 | 2018-09-19 08:58:08 -0400 | [diff] [blame] | 334 | if (op.fDomain) { |
| 335 | domain = Domain::kYes; |
| 336 | } |
Brian Osman | 3d139a4 | 2018-11-19 10:42:10 -0500 | [diff] [blame] | 337 | wideColor |= op.fWideColor; |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 338 | numProxies += op.fProxyCnt; |
| 339 | for (unsigned p = 0; p < op.fProxyCnt; ++p) { |
Brian Salomon | 4b8178f | 2018-10-12 13:18:27 -0400 | [diff] [blame] | 340 | numTotalQuads += op.fProxies[p].fQuadCnt; |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 341 | auto* proxy = op.fProxies[p].fProxy; |
| 342 | if (!proxy->instantiate(target->resourceProvider())) { |
| 343 | return; |
| 344 | } |
| 345 | SkASSERT(proxy->config() == config); |
| 346 | SkASSERT(proxy->textureType() == textureType); |
Brian Salomon | f723264 | 2018-09-19 08:58:08 -0400 | [diff] [blame] | 347 | } |
Brian Salomon | ae7d770 | 2018-10-14 15:05:45 -0400 | [diff] [blame] | 348 | if (op.aaType() == GrAAType::kCoverage) { |
| 349 | SkASSERT(aaType == GrAAType::kCoverage || aaType == GrAAType::kNone); |
| 350 | aaType = GrAAType::kCoverage; |
| 351 | } |
Brian Salomon | 3416969 | 2017-08-28 15:32:01 -0400 | [diff] [blame] | 352 | } |
Brian Salomon | 336ce7b | 2017-09-08 08:23:58 -0400 | [diff] [blame] | 353 | |
Michael Ludwig | f995c05 | 2018-11-26 15:24:29 -0500 | [diff] [blame] | 354 | VertexSpec vertexSpec(quadType, wideColor ? ColorType::kHalf : ColorType::kByte, |
| 355 | GrQuadType::kRect, /* hasLocal */ true, domain, aaType); |
Michael Ludwig | c182b94 | 2018-11-16 10:27:51 -0500 | [diff] [blame] | 356 | |
Greg Daniel | 7a82edf | 2018-12-04 10:54:34 -0500 | [diff] [blame^] | 357 | GrSamplerState samplerState = GrSamplerState(GrSamplerState::WrapMode::kClamp, |
| 358 | this->filter()); |
| 359 | GrGpu* gpu = target->resourceProvider()->priv().gpu(); |
| 360 | uint32_t extraSamplerKey = gpu->getExtraSamplerKeyForProgram( |
| 361 | samplerState, fProxies[0].fProxy->backendFormat()); |
| 362 | |
Michael Ludwig | 467994d | 2018-12-03 14:58:31 +0000 | [diff] [blame] | 363 | sk_sp<GrGeometryProcessor> gp = GrQuadPerEdgeAA::MakeTexturedProcessor( |
| 364 | vertexSpec, *target->caps().shaderCaps(), |
Greg Daniel | 7a82edf | 2018-12-04 10:54:34 -0500 | [diff] [blame^] | 365 | textureType, config, samplerState, extraSamplerKey, |
| 366 | std::move(fTextureColorSpaceXform)); |
| 367 | |
Brian Salomon | 3416969 | 2017-08-28 15:32:01 -0400 | [diff] [blame] | 368 | GrPipeline::InitArgs args; |
| 369 | args.fProxy = target->proxy(); |
| 370 | args.fCaps = &target->caps(); |
| 371 | args.fResourceProvider = target->resourceProvider(); |
Brian Salomon | 485b8c6 | 2018-01-12 15:11:06 -0500 | [diff] [blame] | 372 | args.fFlags = 0; |
Brian Salomon | ae7d770 | 2018-10-14 15:05:45 -0400 | [diff] [blame] | 373 | if (aaType == GrAAType::kMSAA) { |
Brian Salomon | 485b8c6 | 2018-01-12 15:11:06 -0500 | [diff] [blame] | 374 | args.fFlags |= GrPipeline::kHWAntialias_Flag; |
| 375 | } |
| 376 | |
Brian Salomon | 4934890 | 2018-06-26 09:12:38 -0400 | [diff] [blame] | 377 | auto clip = target->detachAppliedClip(); |
Brian Salomon | f723264 | 2018-09-19 08:58:08 -0400 | [diff] [blame] | 378 | // We'll use a dynamic state array for the GP textures when there are multiple ops. |
| 379 | // Otherwise, we use fixed dynamic state to specify the single op's proxy. |
| 380 | GrPipeline::DynamicStateArrays* dynamicStateArrays = nullptr; |
| 381 | GrPipeline::FixedDynamicState* fixedDynamicState; |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 382 | if (numProxies > 1) { |
| 383 | dynamicStateArrays = target->allocDynamicStateArrays(numProxies, 1, false); |
Brian Salomon | f723264 | 2018-09-19 08:58:08 -0400 | [diff] [blame] | 384 | fixedDynamicState = target->allocFixedDynamicState(clip.scissorState().rect(), 0); |
| 385 | } else { |
| 386 | fixedDynamicState = target->allocFixedDynamicState(clip.scissorState().rect(), 1); |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 387 | fixedDynamicState->fPrimitiveProcessorTextures[0] = fProxies[0].fProxy; |
Brian Salomon | f723264 | 2018-09-19 08:58:08 -0400 | [diff] [blame] | 388 | } |
Brian Salomon | 4934890 | 2018-06-26 09:12:38 -0400 | [diff] [blame] | 389 | const auto* pipeline = |
| 390 | target->allocPipeline(args, GrProcessorSet::MakeEmptySet(), std::move(clip)); |
Brian Salomon | 92be2f7 | 2018-06-19 14:33:47 -0400 | [diff] [blame] | 391 | |
Michael Ludwig | c182b94 | 2018-11-16 10:27:51 -0500 | [diff] [blame] | 392 | size_t vertexSize = gp->vertexStride(); |
Brian Salomon | 92be2f7 | 2018-06-19 14:33:47 -0400 | [diff] [blame] | 393 | |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 394 | GrMesh* meshes = target->allocMeshes(numProxies); |
Brian Salomon | 4b8178f | 2018-10-12 13:18:27 -0400 | [diff] [blame] | 395 | const GrBuffer* vbuffer; |
| 396 | int vertexOffsetInBuffer = 0; |
| 397 | int numQuadVerticesLeft = numTotalQuads * 4; |
| 398 | int numAllocatedVertices = 0; |
| 399 | void* vdata = nullptr; |
| 400 | |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 401 | int m = 0; |
Brian Salomon | f723264 | 2018-09-19 08:58:08 -0400 | [diff] [blame] | 402 | for (const auto& op : ChainRange<TextureOp>(this)) { |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 403 | int q = 0; |
| 404 | for (unsigned p = 0; p < op.fProxyCnt; ++p) { |
| 405 | int quadCnt = op.fProxies[p].fQuadCnt; |
| 406 | auto* proxy = op.fProxies[p].fProxy; |
Brian Salomon | 4b8178f | 2018-10-12 13:18:27 -0400 | [diff] [blame] | 407 | int meshVertexCnt = quadCnt * 4; |
| 408 | if (numAllocatedVertices < meshVertexCnt) { |
| 409 | vdata = target->makeVertexSpaceAtLeast( |
| 410 | vertexSize, meshVertexCnt, numQuadVerticesLeft, &vbuffer, |
| 411 | &vertexOffsetInBuffer, &numAllocatedVertices); |
| 412 | SkASSERT(numAllocatedVertices <= numQuadVerticesLeft); |
| 413 | if (!vdata) { |
| 414 | SkDebugf("Could not allocate vertices\n"); |
| 415 | return; |
| 416 | } |
Brian Salomon | f723264 | 2018-09-19 08:58:08 -0400 | [diff] [blame] | 417 | } |
Brian Salomon | 4b8178f | 2018-10-12 13:18:27 -0400 | [diff] [blame] | 418 | SkASSERT(numAllocatedVertices >= meshVertexCnt); |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 419 | |
Michael Ludwig | c182b94 | 2018-11-16 10:27:51 -0500 | [diff] [blame] | 420 | op.tess(vdata, vertexSpec, proxy, q, quadCnt); |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 421 | |
| 422 | if (quadCnt > 1) { |
| 423 | meshes[m].setPrimitiveType(GrPrimitiveType::kTriangles); |
| 424 | sk_sp<const GrBuffer> ibuffer = |
| 425 | target->resourceProvider()->refQuadIndexBuffer(); |
| 426 | if (!ibuffer) { |
| 427 | SkDebugf("Could not allocate quad indices\n"); |
| 428 | return; |
| 429 | } |
| 430 | meshes[m].setIndexedPatterned(ibuffer.get(), 6, 4, quadCnt, |
| 431 | GrResourceProvider::QuadCountOfQuadBuffer()); |
| 432 | } else { |
| 433 | meshes[m].setPrimitiveType(GrPrimitiveType::kTriangleStrip); |
| 434 | meshes[m].setNonIndexedNonInstanced(4); |
| 435 | } |
Brian Salomon | 4b8178f | 2018-10-12 13:18:27 -0400 | [diff] [blame] | 436 | meshes[m].setVertexData(vbuffer, vertexOffsetInBuffer); |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 437 | if (dynamicStateArrays) { |
| 438 | dynamicStateArrays->fPrimitiveProcessorTextures[m] = proxy; |
| 439 | } |
| 440 | ++m; |
Brian Salomon | 4b8178f | 2018-10-12 13:18:27 -0400 | [diff] [blame] | 441 | numAllocatedVertices -= meshVertexCnt; |
| 442 | numQuadVerticesLeft -= meshVertexCnt; |
| 443 | vertexOffsetInBuffer += meshVertexCnt; |
| 444 | vdata = reinterpret_cast<char*>(vdata) + vertexSize * meshVertexCnt; |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 445 | q += quadCnt; |
Brian Salomon | f723264 | 2018-09-19 08:58:08 -0400 | [diff] [blame] | 446 | } |
Brian Salomon | 3416969 | 2017-08-28 15:32:01 -0400 | [diff] [blame] | 447 | } |
Brian Salomon | 4b8178f | 2018-10-12 13:18:27 -0400 | [diff] [blame] | 448 | SkASSERT(!numQuadVerticesLeft); |
| 449 | SkASSERT(!numAllocatedVertices); |
Brian Salomon | f723264 | 2018-09-19 08:58:08 -0400 | [diff] [blame] | 450 | target->draw(std::move(gp), pipeline, fixedDynamicState, dynamicStateArrays, meshes, |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 451 | numProxies); |
Brian Salomon | 3416969 | 2017-08-28 15:32:01 -0400 | [diff] [blame] | 452 | } |
| 453 | |
Brian Salomon | f723264 | 2018-09-19 08:58:08 -0400 | [diff] [blame] | 454 | CombineResult onCombineIfPossible(GrOp* t, const GrCaps& caps) override { |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 455 | TRACE_EVENT0("skia", TRACE_FUNC); |
Brian Salomon | 3416969 | 2017-08-28 15:32:01 -0400 | [diff] [blame] | 456 | const auto* that = t->cast<TextureOp>(); |
Brian Osman | 3ebd354 | 2018-07-30 14:36:53 -0400 | [diff] [blame] | 457 | if (!GrColorSpaceXform::Equals(fTextureColorSpaceXform.get(), |
| 458 | that->fTextureColorSpaceXform.get())) { |
Brian Salomon | 7eae3e0 | 2018-08-07 14:02:38 +0000 | [diff] [blame] | 459 | return CombineResult::kCannotCombine; |
Brian Osman | 3ebd354 | 2018-07-30 14:36:53 -0400 | [diff] [blame] | 460 | } |
Brian Salomon | ae7d770 | 2018-10-14 15:05:45 -0400 | [diff] [blame] | 461 | bool upgradeToCoverageAAOnMerge = false; |
Brian Salomon | 485b8c6 | 2018-01-12 15:11:06 -0500 | [diff] [blame] | 462 | if (this->aaType() != that->aaType()) { |
Brian Salomon | ae7d770 | 2018-10-14 15:05:45 -0400 | [diff] [blame] | 463 | if (!((this->aaType() == GrAAType::kCoverage && that->aaType() == GrAAType::kNone) || |
| 464 | (that->aaType() == GrAAType::kCoverage && this->aaType() == GrAAType::kNone))) { |
| 465 | return CombineResult::kCannotCombine; |
| 466 | } |
| 467 | upgradeToCoverageAAOnMerge = true; |
Brian Salomon | b5ef1f9 | 2018-01-11 11:46:21 -0500 | [diff] [blame] | 468 | } |
Brian Salomon | f723264 | 2018-09-19 08:58:08 -0400 | [diff] [blame] | 469 | if (fFilter != that->fFilter) { |
| 470 | return CombineResult::kCannotCombine; |
| 471 | } |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 472 | auto thisProxy = fProxies[0].fProxy; |
| 473 | auto thatProxy = that->fProxies[0].fProxy; |
| 474 | if (fProxyCnt > 1 || that->fProxyCnt > 1 || |
Brian Salomon | 588cec7 | 2018-11-14 13:56:37 -0500 | [diff] [blame] | 475 | thisProxy->uniqueID() != thatProxy->uniqueID()) { |
| 476 | // We can't merge across different proxies. Check if 'this' can be chained with 'that'. |
Greg Daniel | 45723ac | 2018-11-30 10:12:43 -0500 | [diff] [blame] | 477 | if (GrTextureProxy::ProxiesAreCompatibleAsDynamicState(thisProxy, thatProxy) && |
Brian Salomon | f723264 | 2018-09-19 08:58:08 -0400 | [diff] [blame] | 478 | caps.dynamicStateArrayGeometryProcessorTextureSupport()) { |
| 479 | return CombineResult::kMayChain; |
| 480 | } |
Brian Salomon | 7eae3e0 | 2018-08-07 14:02:38 +0000 | [diff] [blame] | 481 | return CombineResult::kCannotCombine; |
Brian Salomon | 336ce7b | 2017-09-08 08:23:58 -0400 | [diff] [blame] | 482 | } |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 483 | fProxies[0].fQuadCnt += that->fQuads.count(); |
| 484 | fQuads.push_back_n(that->fQuads.count(), that->fQuads.begin()); |
Michael Ludwig | f995c05 | 2018-11-26 15:24:29 -0500 | [diff] [blame] | 485 | if (that->fQuadType > fQuadType) { |
| 486 | fQuadType = that->fQuadType; |
| 487 | } |
Brian Salomon | b80ffee | 2018-05-23 16:39:39 -0400 | [diff] [blame] | 488 | fDomain |= that->fDomain; |
Brian Osman | 3d139a4 | 2018-11-19 10:42:10 -0500 | [diff] [blame] | 489 | fWideColor |= that->fWideColor; |
Brian Salomon | ae7d770 | 2018-10-14 15:05:45 -0400 | [diff] [blame] | 490 | if (upgradeToCoverageAAOnMerge) { |
| 491 | fAAType = static_cast<unsigned>(GrAAType::kCoverage); |
| 492 | } |
Brian Salomon | 7eae3e0 | 2018-08-07 14:02:38 +0000 | [diff] [blame] | 493 | return CombineResult::kMerged; |
Brian Salomon | 3416969 | 2017-08-28 15:32:01 -0400 | [diff] [blame] | 494 | } |
| 495 | |
Brian Salomon | 485b8c6 | 2018-01-12 15:11:06 -0500 | [diff] [blame] | 496 | GrAAType aaType() const { return static_cast<GrAAType>(fAAType); } |
Brian Salomon | 0087c83 | 2018-10-15 14:48:20 -0400 | [diff] [blame] | 497 | GrSamplerState::Filter filter() const { return static_cast<GrSamplerState::Filter>(fFilter); } |
Michael Ludwig | f995c05 | 2018-11-26 15:24:29 -0500 | [diff] [blame] | 498 | GrQuadType quadType() const { return static_cast<GrQuadType>(fQuadType); } |
Brian Salomon | b5ef1f9 | 2018-01-11 11:46:21 -0500 | [diff] [blame] | 499 | |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 500 | class Quad { |
Brian Salomon | b80ffee | 2018-05-23 16:39:39 -0400 | [diff] [blame] | 501 | public: |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 502 | Quad(const SkRect& srcRect, const GrPerspQuad& quad, GrQuadAAFlags aaFlags, |
Brian Osman | 3d139a4 | 2018-11-19 10:42:10 -0500 | [diff] [blame] | 503 | SkCanvas::SrcRectConstraint constraint, const SkPMColor4f& color) |
Brian Salomon | b80ffee | 2018-05-23 16:39:39 -0400 | [diff] [blame] | 504 | : fSrcRect(srcRect) |
Brian Salomon | b80ffee | 2018-05-23 16:39:39 -0400 | [diff] [blame] | 505 | , fQuad(quad) |
Brian Salomon | 7eae3e0 | 2018-08-07 14:02:38 +0000 | [diff] [blame] | 506 | , fColor(color) |
Brian Salomon | 2213ee9 | 2018-10-02 10:44:21 -0400 | [diff] [blame] | 507 | , fHasDomain(constraint == SkCanvas::kStrict_SrcRectConstraint) |
| 508 | , fAAFlags(static_cast<unsigned>(aaFlags)) { |
| 509 | SkASSERT(fAAFlags == static_cast<unsigned>(aaFlags)); |
| 510 | } |
Brian Salomon | b80ffee | 2018-05-23 16:39:39 -0400 | [diff] [blame] | 511 | const GrPerspQuad& quad() const { return fQuad; } |
Brian Salomon | b80ffee | 2018-05-23 16:39:39 -0400 | [diff] [blame] | 512 | const SkRect& srcRect() const { return fSrcRect; } |
Brian Osman | 3d139a4 | 2018-11-19 10:42:10 -0500 | [diff] [blame] | 513 | SkPMColor4f color() const { return fColor; } |
Brian Salomon | b80ffee | 2018-05-23 16:39:39 -0400 | [diff] [blame] | 514 | Domain domain() const { return Domain(fHasDomain); } |
Brian Salomon | 2213ee9 | 2018-10-02 10:44:21 -0400 | [diff] [blame] | 515 | GrQuadAAFlags aaFlags() const { return static_cast<GrQuadAAFlags>(fAAFlags); } |
Brian Salomon | b80ffee | 2018-05-23 16:39:39 -0400 | [diff] [blame] | 516 | |
| 517 | private: |
Brian Salomon | 3416969 | 2017-08-28 15:32:01 -0400 | [diff] [blame] | 518 | SkRect fSrcRect; |
Brian Salomon | be3c1d2 | 2018-05-21 12:54:39 -0400 | [diff] [blame] | 519 | GrPerspQuad fQuad; |
Brian Osman | 3d139a4 | 2018-11-19 10:42:10 -0500 | [diff] [blame] | 520 | SkPMColor4f fColor; |
Brian Salomon | 2213ee9 | 2018-10-02 10:44:21 -0400 | [diff] [blame] | 521 | unsigned fHasDomain : 1; |
| 522 | unsigned fAAFlags : 4; |
Brian Salomon | 3416969 | 2017-08-28 15:32:01 -0400 | [diff] [blame] | 523 | }; |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 524 | struct Proxy { |
| 525 | GrTextureProxy* fProxy; |
| 526 | int fQuadCnt; |
| 527 | }; |
| 528 | SkSTArray<1, Quad, true> fQuads; |
Brian Osman | 3ebd354 | 2018-07-30 14:36:53 -0400 | [diff] [blame] | 529 | sk_sp<GrColorSpaceXform> fTextureColorSpaceXform; |
Brian Salomon | 0087c83 | 2018-10-15 14:48:20 -0400 | [diff] [blame] | 530 | unsigned fFilter : 2; |
Brian Salomon | 485b8c6 | 2018-01-12 15:11:06 -0500 | [diff] [blame] | 531 | unsigned fAAType : 2; |
Michael Ludwig | f995c05 | 2018-11-26 15:24:29 -0500 | [diff] [blame] | 532 | unsigned fQuadType : 2; // Device quad, src quad is always trivial |
Brian Salomon | b80ffee | 2018-05-23 16:39:39 -0400 | [diff] [blame] | 533 | unsigned fDomain : 1; |
Brian Osman | 3d139a4 | 2018-11-19 10:42:10 -0500 | [diff] [blame] | 534 | unsigned fWideColor : 1; |
Brian Salomon | 3416969 | 2017-08-28 15:32:01 -0400 | [diff] [blame] | 535 | // Used to track whether fProxy is ref'ed or has a pending IO after finalize() is called. |
Brian Salomon | b5ef1f9 | 2018-01-11 11:46:21 -0500 | [diff] [blame] | 536 | unsigned fFinalized : 1; |
Brian Salomon | 7d94bb5 | 2018-10-12 14:37:19 -0400 | [diff] [blame] | 537 | unsigned fCanSkipAllocatorGather : 1; |
Michael Ludwig | f995c05 | 2018-11-26 15:24:29 -0500 | [diff] [blame] | 538 | unsigned fProxyCnt : 32 - 10; |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 539 | Proxy fProxies[1]; |
Brian Salomon | 336ce7b | 2017-09-08 08:23:58 -0400 | [diff] [blame] | 540 | |
Michael Ludwig | f995c05 | 2018-11-26 15:24:29 -0500 | [diff] [blame] | 541 | static_assert(kGrQuadTypeCount <= 4, "GrQuadType does not fit in 2 bits"); |
| 542 | |
Brian Salomon | 3416969 | 2017-08-28 15:32:01 -0400 | [diff] [blame] | 543 | typedef GrMeshDrawOp INHERITED; |
| 544 | }; |
| 545 | |
| 546 | } // anonymous namespace |
| 547 | |
| 548 | namespace GrTextureOp { |
| 549 | |
Robert Phillips | 7c525e6 | 2018-06-12 10:11:12 -0400 | [diff] [blame] | 550 | std::unique_ptr<GrDrawOp> Make(GrContext* context, |
| 551 | sk_sp<GrTextureProxy> proxy, |
| 552 | GrSamplerState::Filter filter, |
Brian Osman | 3d139a4 | 2018-11-19 10:42:10 -0500 | [diff] [blame] | 553 | const SkPMColor4f& color, |
Robert Phillips | 7c525e6 | 2018-06-12 10:11:12 -0400 | [diff] [blame] | 554 | const SkRect& srcRect, |
| 555 | const SkRect& dstRect, |
| 556 | GrAAType aaType, |
Brian Salomon | 2213ee9 | 2018-10-02 10:44:21 -0400 | [diff] [blame] | 557 | GrQuadAAFlags aaFlags, |
Robert Phillips | 7c525e6 | 2018-06-12 10:11:12 -0400 | [diff] [blame] | 558 | SkCanvas::SrcRectConstraint constraint, |
| 559 | const SkMatrix& viewMatrix, |
Brian Osman | 3d139a4 | 2018-11-19 10:42:10 -0500 | [diff] [blame] | 560 | sk_sp<GrColorSpaceXform> textureColorSpaceXform) { |
Robert Phillips | 7c525e6 | 2018-06-12 10:11:12 -0400 | [diff] [blame] | 561 | return TextureOp::Make(context, std::move(proxy), filter, color, srcRect, dstRect, aaType, |
Brian Osman | 3d139a4 | 2018-11-19 10:42:10 -0500 | [diff] [blame] | 562 | aaFlags, constraint, viewMatrix, std::move(textureColorSpaceXform)); |
Brian Salomon | 3416969 | 2017-08-28 15:32:01 -0400 | [diff] [blame] | 563 | } |
| 564 | |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 565 | std::unique_ptr<GrDrawOp> Make(GrContext* context, |
| 566 | const GrRenderTargetContext::TextureSetEntry set[], |
| 567 | int cnt, |
| 568 | GrSamplerState::Filter filter, |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 569 | GrAAType aaType, |
| 570 | const SkMatrix& viewMatrix, |
Brian Osman | 3d139a4 | 2018-11-19 10:42:10 -0500 | [diff] [blame] | 571 | sk_sp<GrColorSpaceXform> textureColorSpaceXform) { |
Brian Salomon | d003d22 | 2018-11-26 13:25:05 -0500 | [diff] [blame] | 572 | return TextureOp::Make(context, set, cnt, filter, aaType, viewMatrix, |
Brian Osman | 3d139a4 | 2018-11-19 10:42:10 -0500 | [diff] [blame] | 573 | std::move(textureColorSpaceXform)); |
Brian Salomon | d7065e7 | 2018-10-12 11:42:02 -0400 | [diff] [blame] | 574 | } |
| 575 | |
Brian Salomon | 3416969 | 2017-08-28 15:32:01 -0400 | [diff] [blame] | 576 | } // namespace GrTextureOp |
| 577 | |
| 578 | #if GR_TEST_UTILS |
| 579 | #include "GrContext.h" |
Robert Phillips | 1afd4cd | 2018-01-08 13:40:32 -0500 | [diff] [blame] | 580 | #include "GrContextPriv.h" |
Robert Phillips | 0bd24dc | 2018-01-16 08:06:32 -0500 | [diff] [blame] | 581 | #include "GrProxyProvider.h" |
Brian Salomon | 3416969 | 2017-08-28 15:32:01 -0400 | [diff] [blame] | 582 | |
| 583 | GR_DRAW_OP_TEST_DEFINE(TextureOp) { |
| 584 | GrSurfaceDesc desc; |
| 585 | desc.fConfig = kRGBA_8888_GrPixelConfig; |
| 586 | desc.fHeight = random->nextULessThan(90) + 10; |
| 587 | desc.fWidth = random->nextULessThan(90) + 10; |
Brian Salomon | 2a4f983 | 2018-03-03 22:43:43 -0500 | [diff] [blame] | 588 | auto origin = random->nextBool() ? kTopLeft_GrSurfaceOrigin : kBottomLeft_GrSurfaceOrigin; |
Greg Daniel | 09c9400 | 2018-06-08 22:11:51 +0000 | [diff] [blame] | 589 | GrMipMapped mipMapped = random->nextBool() ? GrMipMapped::kYes : GrMipMapped::kNo; |
| 590 | SkBackingFit fit = SkBackingFit::kExact; |
| 591 | if (mipMapped == GrMipMapped::kNo) { |
| 592 | fit = random->nextBool() ? SkBackingFit::kApprox : SkBackingFit::kExact; |
| 593 | } |
Robert Phillips | 0bd24dc | 2018-01-16 08:06:32 -0500 | [diff] [blame] | 594 | |
Greg Daniel | 4065d45 | 2018-11-16 15:43:41 -0500 | [diff] [blame] | 595 | const GrBackendFormat format = |
| 596 | context->contextPriv().caps()->getBackendFormatFromColorType(kRGBA_8888_SkColorType); |
| 597 | |
Robert Phillips | 0bd24dc | 2018-01-16 08:06:32 -0500 | [diff] [blame] | 598 | GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider(); |
Greg Daniel | 4065d45 | 2018-11-16 15:43:41 -0500 | [diff] [blame] | 599 | sk_sp<GrTextureProxy> proxy = proxyProvider->createProxy(format, desc, origin, mipMapped, fit, |
Greg Daniel | 09c9400 | 2018-06-08 22:11:51 +0000 | [diff] [blame] | 600 | SkBudgeted::kNo, |
| 601 | GrInternalSurfaceFlags::kNone); |
Robert Phillips | 0bd24dc | 2018-01-16 08:06:32 -0500 | [diff] [blame] | 602 | |
Brian Salomon | 3416969 | 2017-08-28 15:32:01 -0400 | [diff] [blame] | 603 | SkRect rect = GrTest::TestRect(random); |
| 604 | SkRect srcRect; |
| 605 | srcRect.fLeft = random->nextRangeScalar(0.f, proxy->width() / 2.f); |
| 606 | srcRect.fRight = random->nextRangeScalar(0.f, proxy->width()) + proxy->width() / 2.f; |
| 607 | srcRect.fTop = random->nextRangeScalar(0.f, proxy->height() / 2.f); |
| 608 | srcRect.fBottom = random->nextRangeScalar(0.f, proxy->height()) + proxy->height() / 2.f; |
| 609 | SkMatrix viewMatrix = GrTest::TestMatrixPreservesRightAngles(random); |
Brian Osman | 3d139a4 | 2018-11-19 10:42:10 -0500 | [diff] [blame] | 610 | SkPMColor4f color = SkPMColor4f::FromBytes_RGBA(SkColorToPremulGrColor(random->nextU())); |
Brian Salomon | 2bbdcc4 | 2017-09-07 12:36:34 -0400 | [diff] [blame] | 611 | GrSamplerState::Filter filter = (GrSamplerState::Filter)random->nextULessThan( |
| 612 | static_cast<uint32_t>(GrSamplerState::Filter::kMipMap) + 1); |
Greg Daniel | 09c9400 | 2018-06-08 22:11:51 +0000 | [diff] [blame] | 613 | while (mipMapped == GrMipMapped::kNo && filter == GrSamplerState::Filter::kMipMap) { |
| 614 | filter = (GrSamplerState::Filter)random->nextULessThan( |
| 615 | static_cast<uint32_t>(GrSamplerState::Filter::kMipMap) + 1); |
| 616 | } |
Brian Osman | 3ebd354 | 2018-07-30 14:36:53 -0400 | [diff] [blame] | 617 | auto texXform = GrTest::TestColorXform(random); |
Brian Salomon | 485b8c6 | 2018-01-12 15:11:06 -0500 | [diff] [blame] | 618 | GrAAType aaType = GrAAType::kNone; |
| 619 | if (random->nextBool()) { |
| 620 | aaType = (fsaaType == GrFSAAType::kUnifiedMSAA) ? GrAAType::kMSAA : GrAAType::kCoverage; |
| 621 | } |
Brian Salomon | 2213ee9 | 2018-10-02 10:44:21 -0400 | [diff] [blame] | 622 | GrQuadAAFlags aaFlags = GrQuadAAFlags::kNone; |
| 623 | aaFlags |= random->nextBool() ? GrQuadAAFlags::kLeft : GrQuadAAFlags::kNone; |
| 624 | aaFlags |= random->nextBool() ? GrQuadAAFlags::kTop : GrQuadAAFlags::kNone; |
| 625 | aaFlags |= random->nextBool() ? GrQuadAAFlags::kRight : GrQuadAAFlags::kNone; |
| 626 | aaFlags |= random->nextBool() ? GrQuadAAFlags::kBottom : GrQuadAAFlags::kNone; |
Brian Salomon | b80ffee | 2018-05-23 16:39:39 -0400 | [diff] [blame] | 627 | auto constraint = random->nextBool() ? SkCanvas::kStrict_SrcRectConstraint |
| 628 | : SkCanvas::kFast_SrcRectConstraint; |
Robert Phillips | 7c525e6 | 2018-06-12 10:11:12 -0400 | [diff] [blame] | 629 | return GrTextureOp::Make(context, std::move(proxy), filter, color, srcRect, rect, aaType, |
Brian Osman | 3d139a4 | 2018-11-19 10:42:10 -0500 | [diff] [blame] | 630 | aaFlags, constraint, viewMatrix, std::move(texXform)); |
Brian Salomon | 3416969 | 2017-08-28 15:32:01 -0400 | [diff] [blame] | 631 | } |
| 632 | |
| 633 | #endif |