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 <new>
9
10#include "include/core/SkPoint.h"
11#include "include/core/SkPoint3.h"
12#include "include/private/GrRecordingContext.h"
13#include "include/private/SkFloatingPoint.h"
14#include "include/private/SkTo.h"
15#include "src/core/SkMathPriv.h"
16#include "src/core/SkMatrixPriv.h"
17#include "src/core/SkRectPriv.h"
18#include "src/gpu/GrAppliedClip.h"
19#include "src/gpu/GrCaps.h"
20#include "src/gpu/GrDrawOpTest.h"
21#include "src/gpu/GrGeometryProcessor.h"
22#include "src/gpu/GrGpu.h"
23#include "src/gpu/GrMemoryPool.h"
24#include "src/gpu/GrOpFlushState.h"
25#include "src/gpu/GrRecordingContextPriv.h"
26#include "src/gpu/GrResourceProvider.h"
27#include "src/gpu/GrResourceProviderPriv.h"
28#include "src/gpu/GrShaderCaps.h"
29#include "src/gpu/GrTexture.h"
30#include "src/gpu/GrTexturePriv.h"
31#include "src/gpu/GrTextureProxy.h"
32#include "src/gpu/SkGr.h"
33#include "src/gpu/effects/generated/GrClampFragmentProcessor.h"
34#include "src/gpu/geometry/GrQuad.h"
35#include "src/gpu/geometry/GrQuadBuffer.h"
36#include "src/gpu/geometry/GrQuadUtils.h"
37#include "src/gpu/glsl/GrGLSLVarying.h"
38#include "src/gpu/ops/GrFillRectOp.h"
39#include "src/gpu/ops/GrMeshDrawOp.h"
40#include "src/gpu/ops/GrQuadPerEdgeAA.h"
41#include "src/gpu/ops/GrSimpleMeshDrawOpHelper.h"
42#include "src/gpu/ops/GrTextureOp.h"
43
44namespace {
45
46using Domain = GrQuadPerEdgeAA::Domain;
47using VertexSpec = GrQuadPerEdgeAA::VertexSpec;
48using ColorType = GrQuadPerEdgeAA::ColorType;
49
50// Extracts lengths of vertical and horizontal edges of axis-aligned quad. "width" is the edge
51// between v0 and v2 (or v1 and v3), "height" is the edge between v0 and v1 (or v2 and v3).
52static SkSize axis_aligned_quad_size(const GrQuad& quad) {
53 SkASSERT(quad.quadType() == GrQuad::Type::kAxisAligned);
54 // Simplification of regular edge length equation, since it's axis aligned and can avoid sqrt
55 float dw = sk_float_abs(quad.x(2) - quad.x(0)) + sk_float_abs(quad.y(2) - quad.y(0));
56 float dh = sk_float_abs(quad.x(1) - quad.x(0)) + sk_float_abs(quad.y(1) - quad.y(0));
57 return {dw, dh};
58}
59
60static bool filter_has_effect(const GrQuad& srcQuad, const GrQuad& dstQuad) {
61 // If not axis-aligned in src or dst, then always say it has an effect
62 if (srcQuad.quadType() != GrQuad::Type::kAxisAligned ||
63 dstQuad.quadType() != GrQuad::Type::kAxisAligned) {
64 return true;
65 }
66
67 SkRect srcRect;
68 SkRect dstRect;
69 if (srcQuad.asRect(&srcRect) && dstQuad.asRect(&dstRect)) {
70 // Disable filtering when there is no scaling (width and height are the same), and the
71 // top-left corners have the same fraction (so src and dst snap to the pixel grid
72 // identically).
73 SkASSERT(srcRect.isSorted());
74 return srcRect.width() != dstRect.width() || srcRect.height() != dstRect.height() ||
75 SkScalarFraction(srcRect.fLeft) != SkScalarFraction(dstRect.fLeft) ||
76 SkScalarFraction(srcRect.fTop) != SkScalarFraction(dstRect.fTop);
77 } else {
78 // Although the quads are axis-aligned, the local coordinate system is transformed such
79 // that fractionally-aligned sample centers will not align with the device coordinate system
80 // So disable filtering when edges are the same length and both srcQuad and dstQuad
81 // 0th vertex is integer aligned.
82 if (SkScalarIsInt(srcQuad.x(0)) && SkScalarIsInt(srcQuad.y(0)) &&
83 SkScalarIsInt(dstQuad.x(0)) && SkScalarIsInt(dstQuad.y(0))) {
84 // Extract edge lengths
85 SkSize srcSize = axis_aligned_quad_size(srcQuad);
86 SkSize dstSize = axis_aligned_quad_size(dstQuad);
87 return srcSize.fWidth != dstSize.fWidth || srcSize.fHeight != dstSize.fHeight;
88 } else {
89 return true;
90 }
91 }
92}
93
94// Describes function for normalizing src coords: [x * iw, y * ih + yOffset] can represent
95// regular and rectangular textures, w/ or w/o origin correction.
96struct NormalizationParams {
97 float fIW; // 1 / width of texture, or 1.0 for texture rectangles
98 float fIH; // 1 / height of texture, or 1.0 for tex rects, X -1 if bottom-left origin
99 float fYOffset; // 0 for top-left origin, height of [normalized] tex if bottom-left
100};
101static NormalizationParams proxy_normalization_params(const GrSurfaceProxy* proxy,
102 GrSurfaceOrigin origin) {
103 // Whether or not the proxy is instantiated, this is the size its texture will be, so we can
104 // normalize the src coordinates up front.
105 SkISize dimensions = proxy->backingStoreDimensions();
106 float iw, ih, h;
107 if (proxy->backendFormat().textureType() == GrTextureType::kRectangle) {
108 iw = ih = 1.f;
109 h = dimensions.height();
110 } else {
111 iw = 1.f / dimensions.width();
112 ih = 1.f / dimensions.height();
113 h = 1.f;
114 }
115
116 if (origin == kBottomLeft_GrSurfaceOrigin) {
117 return {iw, -ih, h};
118 } else {
119 return {iw, ih, 0.0f};
120 }
121}
122
123static SkRect inset_domain_for_bilerp(const NormalizationParams& params, const SkRect& domainRect) {
124 // Normalized pixel size is also equal to iw and ih, so the insets for bilerp are just
125 // in those units and can be applied safely after normalization. However, if the domain is
126 // smaller than a texel, it should clamp to the center of that axis.
127 float dw = domainRect.width() < params.fIW ? domainRect.width() : params.fIW;
128 float dh = domainRect.height() < params.fIH ? domainRect.height() : params.fIH;
129 return domainRect.makeInset(0.5f * dw, 0.5f * dh);
130}
131
132// Normalize the domain. If 'domainRect' is null, it is assumed no domain constraint is desired,
133// so a sufficiently large rect is returned even if the quad ends up batched with an op that uses
134// domains overall.
135static SkRect normalize_domain(GrSamplerState::Filter filter,
136 const NormalizationParams& params,
137 const SkRect* domainRect) {
138 static constexpr SkRect kLargeRect = {-100000, -100000, 1000000, 1000000};
139 if (!domainRect) {
140 // Either the quad has no domain constraint and is batched with a domain constrained op
141 // (in which case we want a domain that doesn't restrict normalized tex coords), or the
142 // entire op doesn't use the domain, in which case the returned value is ignored.
143 return kLargeRect;
144 }
145
146 auto ltrb = skvx::Vec<4, float>::Load(domainRect);
147 // Normalize and offset
148 ltrb = mad(ltrb, {params.fIW, params.fIH, params.fIW, params.fIH},
149 {0.f, params.fYOffset, 0.f, params.fYOffset});
150 if (params.fIH < 0.f) {
151 // Flip top and bottom to keep the rect sorted when loaded back to SkRect.
152 ltrb = skvx::shuffle<0, 3, 2, 1>(ltrb);
153 }
154
155 SkRect out;
156 ltrb.store(&out);
157 return out;
158}
159
160// Normalizes logical src coords and corrects for origin
161static void normalize_src_quad(const NormalizationParams& params,
162 GrQuad* srcQuad) {
163 // The src quad should not have any perspective
164 SkASSERT(!srcQuad->hasPerspective());
165 skvx::Vec<4, float> xs = srcQuad->x4f() * params.fIW;
166 skvx::Vec<4, float> ys = mad(srcQuad->y4f(), params.fIH, params.fYOffset);
167 xs.store(srcQuad->xs());
168 ys.store(srcQuad->ys());
169}
170
171// Count the number of proxy runs in the entry set. This usually is already computed by
172// SkGpuDevice, but when the BatchLengthLimiter chops the set up it must determine a new proxy count
173// for each split.
174static int proxy_run_count(const GrRenderTargetContext::TextureSetEntry set[], int count) {
175 int actualProxyRunCount = 0;
176 const GrSurfaceProxy* lastProxy = nullptr;
177 for (int i = 0; i < count; ++i) {
178 if (set[i].fProxyView.proxy() != lastProxy) {
179 actualProxyRunCount++;
180 lastProxy = set[i].fProxyView.proxy();
181 }
182 }
183 return actualProxyRunCount;
184}
185
186/**
187 * Op that implements GrTextureOp::Make. It draws textured quads. Each quad can modulate against a
188 * the texture by color. The blend with the destination is always src-over. The edges are non-AA.
189 */
190class TextureOp final : public GrMeshDrawOp {
191public:
192 static std::unique_ptr<GrDrawOp> Make(GrRecordingContext* context,
193 GrSurfaceProxyView proxyView,
194 sk_sp<GrColorSpaceXform> textureXform,
195 GrSamplerState::Filter filter,
196 const SkPMColor4f& color,
197 GrTextureOp::Saturate saturate,
198 GrAAType aaType,
199 DrawQuad* quad,
200 const SkRect* domain) {
201 GrOpMemoryPool* pool = context->priv().opMemoryPool();
202 return pool->allocate<TextureOp>(std::move(proxyView), std::move(textureXform), filter,
203 color, saturate, aaType, quad, domain);
204 }
205
206 static std::unique_ptr<GrDrawOp> Make(GrRecordingContext* context,
207 GrRenderTargetContext::TextureSetEntry set[],
208 int cnt,
209 int proxyRunCnt,
210 GrSamplerState::Filter filter,
211 GrTextureOp::Saturate saturate,
212 GrAAType aaType,
213 SkCanvas::SrcRectConstraint constraint,
214 const SkMatrix& viewMatrix,
215 sk_sp<GrColorSpaceXform> textureColorSpaceXform) {
216 // Allocate size based on proxyRunCnt, since that determines number of ViewCountPairs.
217 SkASSERT(proxyRunCnt <= cnt);
218
219 size_t size = sizeof(TextureOp) + sizeof(ViewCountPair) * (proxyRunCnt - 1);
220 GrOpMemoryPool* pool = context->priv().opMemoryPool();
221 void* mem = pool->allocate(size);
222 return std::unique_ptr<GrDrawOp>(
223 new (mem) TextureOp(set, cnt, proxyRunCnt, filter, saturate, aaType, constraint,
224 viewMatrix, std::move(textureColorSpaceXform)));
225 }
226
227 ~TextureOp() override {
228 for (unsigned p = 1; p < fMetadata.fProxyCount; ++p) {
229 fViewCountPairs[p].~ViewCountPair();
230 }
231 }
232
233 const char* name() const override { return "TextureOp"; }
234
235 void visitProxies(const VisitProxyFunc& func) const override {
236 bool mipped = (GrSamplerState::Filter::kMipMap == fMetadata.filter());
237 for (unsigned p = 0; p < fMetadata.fProxyCount; ++p) {
238 func(fViewCountPairs[p].fProxy.get(), GrMipMapped(mipped));
239 }
240 if (fDesc && fDesc->fProgramInfo) {
241 fDesc->fProgramInfo->visitFPProxies(func);
242 }
243 }
244
245#ifdef SK_DEBUG
246 SkString dumpInfo() const override {
247 SkString str;
248 str.appendf("# draws: %d\n", fQuads.count());
249 auto iter = fQuads.iterator();
250 for (unsigned p = 0; p < fMetadata.fProxyCount; ++p) {
251 str.appendf("Proxy ID: %d, Filter: %d\n",
252 fViewCountPairs[p].fProxy->uniqueID().asUInt(),
253 static_cast<int>(fMetadata.fFilter));
254 int i = 0;
255 while(i < fViewCountPairs[p].fQuadCnt && iter.next()) {
256 const GrQuad* quad = iter.deviceQuad();
257 GrQuad uv = iter.isLocalValid() ? *(iter.localQuad()) : GrQuad();
258 const ColorDomainAndAA& info = iter.metadata();
259 str.appendf(
260 "%d: Color: 0x%08x, Domain(%d): [L: %.2f, T: %.2f, R: %.2f, B: %.2f]\n"
261 " UVs [(%.2f, %.2f), (%.2f, %.2f), (%.2f, %.2f), (%.2f, %.2f)]\n"
262 " Quad [(%.2f, %.2f), (%.2f, %.2f), (%.2f, %.2f), (%.2f, %.2f)]\n",
263 i, info.fColor.toBytes_RGBA(), fMetadata.fDomain, info.fDomainRect.fLeft,
264 info.fDomainRect.fTop, info.fDomainRect.fRight, info.fDomainRect.fBottom,
265 quad->point(0).fX, quad->point(0).fY, quad->point(1).fX, quad->point(1).fY,
266 quad->point(2).fX, quad->point(2).fY, quad->point(3).fX, quad->point(3).fY,
267 uv.point(0).fX, uv.point(0).fY, uv.point(1).fX, uv.point(1).fY,
268 uv.point(2).fX, uv.point(2).fY, uv.point(3).fX, uv.point(3).fY);
269
270 i++;
271 }
272 }
273 str += INHERITED::dumpInfo();
274 return str;
275 }
276
277 static void ValidateResourceLimits() {
278 // The op implementation has an upper bound on the number of quads that it can represent.
279 // However, the resource manager imposes its own limit on the number of quads, which should
280 // always be lower than the numerical limit this op can hold.
281 using CountStorage = decltype(Metadata::fTotalQuadCount);
282 CountStorage maxQuadCount = std::numeric_limits<CountStorage>::max();
283 // GrResourceProvider::Max...() is typed as int, so don't compare across signed/unsigned.
284 int resourceLimit = SkTo<int>(maxQuadCount);
285 SkASSERT(GrResourceProvider::MaxNumAAQuads() <= resourceLimit &&
286 GrResourceProvider::MaxNumNonAAQuads() <= resourceLimit);
287 }
288#endif
289
290 GrProcessorSet::Analysis finalize(
291 const GrCaps& caps, const GrAppliedClip*, bool hasMixedSampledCoverage,
292 GrClampType clampType) override {
293 SkASSERT(fMetadata.colorType() == ColorType::kNone);
294 auto iter = fQuads.metadata();
295 while(iter.next()) {
296 auto colorType = GrQuadPerEdgeAA::MinColorType(iter->fColor);
297 fMetadata.fColorType = std::max(fMetadata.fColorType, static_cast<uint16_t>(colorType));
298 }
299 return GrProcessorSet::EmptySetAnalysis();
300 }
301
302 FixedFunctionFlags fixedFunctionFlags() const override {
303 return fMetadata.aaType() == GrAAType::kMSAA ? FixedFunctionFlags::kUsesHWAA
304 : FixedFunctionFlags::kNone;
305 }
306
307 DEFINE_OP_CLASS_ID
308
309private:
310 friend class ::GrOpMemoryPool;
311
312 struct ColorDomainAndAA {
313 ColorDomainAndAA(const SkPMColor4f& color, const SkRect& domainRect, GrQuadAAFlags aaFlags)
314 : fColor(color)
315 , fDomainRect(domainRect)
316 , fAAFlags(static_cast<uint16_t>(aaFlags)) {
317 SkASSERT(fAAFlags == static_cast<uint16_t>(aaFlags));
318 }
319
320 SkPMColor4f fColor;
321 // If the op doesn't use domains, this is ignored. If the op uses domains and the specific
322 // entry does not, this rect will equal kLargeRect, so it automatically has no effect.
323 SkRect fDomainRect;
324 unsigned fAAFlags : 4;
325
326 GrQuadAAFlags aaFlags() const { return static_cast<GrQuadAAFlags>(fAAFlags); }
327 };
328
329 struct ViewCountPair {
330 // Normally this would be a GrSurfaceProxyView, but GrTextureOp applies the GrOrigin right
331 // away so it doesn't need to be stored, and all ViewCountPairs in an op have the same
332 // swizzle so that is stored in the op metadata.
333 sk_sp<GrSurfaceProxy> fProxy;
334 int fQuadCnt;
335 };
336
337 // TextureOp and ViewCountPair are 8 byte aligned. This is packed into 8 bytes to minimally
338 // increase the size of the op; increasing the op size can have a surprising impact on
339 // performance (since texture ops are one of the most commonly used in an app).
340 struct Metadata {
341 // AAType must be filled after initialization; ColorType is determined in finalize()
342 Metadata(const GrSwizzle& swizzle, GrSamplerState::Filter filter,
343 GrQuadPerEdgeAA::Domain domain, GrTextureOp::Saturate saturate)
344 : fSwizzle(swizzle)
345 , fProxyCount(1)
346 , fTotalQuadCount(1)
347 , fFilter(static_cast<uint16_t>(filter))
348 , fAAType(static_cast<uint16_t>(GrAAType::kNone))
349 , fColorType(static_cast<uint16_t>(ColorType::kNone))
350 , fDomain(static_cast<uint16_t>(domain))
351 , fSaturate(static_cast<uint16_t>(saturate)) {}
352
353 GrSwizzle fSwizzle; // sizeof(GrSwizzle) == uint16_t
354 uint16_t fProxyCount;
355 // This will be >= fProxyCount, since a proxy may be drawn multiple times
356 uint16_t fTotalQuadCount;
357
358 // These must be based on uint16_t to help MSVC's pack bitfields optimally
359 uint16_t fFilter : 2; // GrSamplerState::Filter
360 uint16_t fAAType : 2; // GrAAType
361 uint16_t fColorType : 2; // GrQuadPerEdgeAA::ColorType
362 uint16_t fDomain : 1; // bool
363 uint16_t fSaturate : 1; // bool
364 uint16_t fUnused : 8; // # of bits left before Metadata exceeds 8 bytes
365
366 GrSamplerState::Filter filter() const {
367 return static_cast<GrSamplerState::Filter>(fFilter);
368 }
369 GrAAType aaType() const { return static_cast<GrAAType>(fAAType); }
370 ColorType colorType() const { return static_cast<ColorType>(fColorType); }
371 Domain domain() const { return static_cast<Domain>(fDomain); }
372 GrTextureOp::Saturate saturate() const {
373 return static_cast<GrTextureOp::Saturate>(fSaturate);
374 }
375
376 static_assert(GrSamplerState::kFilterCount <= 4);
377 static_assert(kGrAATypeCount <= 4);
378 static_assert(GrQuadPerEdgeAA::kColorTypeCount <= 4);
379 };
380 static_assert(sizeof(Metadata) == 8);
381
382 // This descriptor is used to store the draw info we decide on during on(Pre)PrepareDraws. We
383 // store the data in a separate struct in order to minimize the size of the TextureOp.
384 // Historically, increasing the TextureOp's size has caused surprising perf regressions, but we
385 // may want to re-evaluate whether this is still necessary.
386 //
387 // In the onPrePrepareDraws case it is allocated in the creation-time opData arena, and
388 // allocatePrePreparedVertices is also called.
389 //
390 // In the onPrepareDraws case this descriptor is allocated in the flush-time arena (i.e., as
391 // part of the flushState).
392 struct Desc {
393 VertexSpec fVertexSpec;
394 int fNumProxies = 0;
395 int fNumTotalQuads = 0;
396
397 // This member variable is only used by 'onPrePrepareDraws'.
398 char* fPrePreparedVertices = nullptr;
399
400 GrProgramInfo* fProgramInfo = nullptr;
401
402 sk_sp<const GrBuffer> fIndexBuffer;
403 sk_sp<const GrBuffer> fVertexBuffer;
404 int fBaseVertex;
405
406 // How big should 'fVertices' be to hold all the vertex data?
407 size_t totalSizeInBytes() const {
408 return this->totalNumVertices() * fVertexSpec.vertexSize();
409 }
410
411 int totalNumVertices() const {
412 return fNumTotalQuads * fVertexSpec.verticesPerQuad();
413 }
414
415 void allocatePrePreparedVertices(SkArenaAlloc* arena) {
416 fPrePreparedVertices = arena->makeArrayDefault<char>(this->totalSizeInBytes());
417 }
418
419 };
420
421 // If domainRect is not null it will be used to apply a strict src rect-style constraint.
422 TextureOp(GrSurfaceProxyView proxyView,
423 sk_sp<GrColorSpaceXform> textureColorSpaceXform,
424 GrSamplerState::Filter filter,
425 const SkPMColor4f& color,
426 GrTextureOp::Saturate saturate,
427 GrAAType aaType,
428 DrawQuad* quad,
429 const SkRect* domainRect)
430 : INHERITED(ClassID())
431 , fQuads(1, true /* includes locals */)
432 , fTextureColorSpaceXform(std::move(textureColorSpaceXform))
433 , fDesc(nullptr)
434 , fMetadata(proxyView.swizzle(), filter, Domain(!!domainRect), saturate) {
435
436 // Clean up disparities between the overall aa type and edge configuration and apply
437 // optimizations based on the rect and matrix when appropriate
438 GrQuadUtils::ResolveAAType(aaType, quad->fEdgeFlags, quad->fDevice,
439 &aaType, &quad->fEdgeFlags);
440 fMetadata.fAAType = static_cast<uint16_t>(aaType);
441
442 // We expect our caller to have already caught this optimization.
443 SkASSERT(!domainRect ||
444 !domainRect->contains(proxyView.proxy()->backingStoreBoundsRect()));
445
446 // We may have had a strict constraint with nearest filter solely due to possible AA bloat.
447 // If we don't have (or determined we don't need) coverage AA then we can skip using a
448 // domain.
449 if (domainRect && filter == GrSamplerState::Filter::kNearest &&
450 aaType != GrAAType::kCoverage) {
451 domainRect = nullptr;
452 fMetadata.fDomain = static_cast<uint16_t>(Domain::kNo);
453 }
454
455 // Normalize src coordinates and the domain (if set)
456 NormalizationParams params = proxy_normalization_params(proxyView.proxy(),
457 proxyView.origin());
458 normalize_src_quad(params, &quad->fLocal);
459 SkRect domain = normalize_domain(filter, params, domainRect);
460
461 // Set bounds before clipping so we don't have to worry about unioning the bounds of
462 // the two potential quads (GrQuad::bounds() is perspective-safe).
463 this->setBounds(quad->fDevice.bounds(), HasAABloat(aaType == GrAAType::kCoverage),
464 IsHairline::kNo);
465
466 int quadCount = this->appendQuad(quad, color, domain);
467 fViewCountPairs[0] = {proxyView.detachProxy(), quadCount};
468 }
469
470 TextureOp(GrRenderTargetContext::TextureSetEntry set[],
471 int cnt,
472 int proxyRunCnt,
473 GrSamplerState::Filter filter,
474 GrTextureOp::Saturate saturate,
475 GrAAType aaType,
476 SkCanvas::SrcRectConstraint constraint,
477 const SkMatrix& viewMatrix,
478 sk_sp<GrColorSpaceXform> textureColorSpaceXform)
479 : INHERITED(ClassID())
480 , fQuads(cnt, true /* includes locals */)
481 , fTextureColorSpaceXform(std::move(textureColorSpaceXform))
482 , fDesc(nullptr)
483 , fMetadata(set[0].fProxyView.swizzle(), GrSamplerState::Filter::kNearest,
484 Domain::kNo, saturate) {
485 // Update counts to reflect the batch op
486 fMetadata.fProxyCount = SkToUInt(proxyRunCnt);
487 fMetadata.fTotalQuadCount = SkToUInt(cnt);
488
489 SkRect bounds = SkRectPriv::MakeLargestInverted();
490
491 GrAAType netAAType = GrAAType::kNone; // aa type maximally compatible with all dst rects
492 Domain netDomain = Domain::kNo;
493 GrSamplerState::Filter netFilter = GrSamplerState::Filter::kNearest;
494
495 const GrSurfaceProxy* curProxy = nullptr;
496
497 // 'q' is the index in 'set' and fQuadBuffer; 'p' is the index in fViewCountPairs and only
498 // increases when set[q]'s proxy changes.
499 int p = 0;
500 for (int q = 0; q < cnt; ++q) {
501 if (q == 0) {
502 // We do not placement new the first ViewCountPair since that one is allocated and
503 // initialized as part of the GrTextureOp creation.
504 fViewCountPairs[0].fProxy = set[0].fProxyView.detachProxy();
505 fViewCountPairs[0].fQuadCnt = 0;
506 curProxy = fViewCountPairs[0].fProxy.get();
507 } else if (set[q].fProxyView.proxy() != curProxy) {
508 // We must placement new the ViewCountPairs here so that the sk_sps in the
509 // GrSurfaceProxyView get initialized properly.
510 new(&fViewCountPairs[++p])ViewCountPair({set[q].fProxyView.detachProxy(), 0});
511
512 curProxy = fViewCountPairs[p].fProxy.get();
513 SkASSERT(GrTextureProxy::ProxiesAreCompatibleAsDynamicState(
514 curProxy, fViewCountPairs[0].fProxy.get()));
515 SkASSERT(fMetadata.fSwizzle == set[q].fProxyView.swizzle());
516 } // else another quad referencing the same proxy
517
518 SkMatrix ctm = viewMatrix;
519 if (set[q].fPreViewMatrix) {
520 ctm.preConcat(*set[q].fPreViewMatrix);
521 }
522
523 // Use dstRect/srcRect unless dstClip is provided, in which case derive new source
524 // coordinates by mapping dstClipQuad by the dstRect to srcRect transform.
525 DrawQuad quad;
526 if (set[q].fDstClipQuad) {
527 quad.fDevice = GrQuad::MakeFromSkQuad(set[q].fDstClipQuad, ctm);
528
529 SkPoint srcPts[4];
530 GrMapRectPoints(set[q].fDstRect, set[q].fSrcRect, set[q].fDstClipQuad, srcPts, 4);
531 quad.fLocal = GrQuad::MakeFromSkQuad(srcPts, SkMatrix::I());
532 } else {
533 quad.fDevice = GrQuad::MakeFromRect(set[q].fDstRect, ctm);
534 quad.fLocal = GrQuad(set[q].fSrcRect);
535 }
536
537 if (netFilter != filter && filter_has_effect(quad.fLocal, quad.fDevice)) {
538 // The only way netFilter != filter is if bilerp is requested and we haven't yet
539 // found a quad that requires bilerp (so net is still nearest).
540 SkASSERT(netFilter == GrSamplerState::Filter::kNearest &&
541 filter == GrSamplerState::Filter::kBilerp);
542 netFilter = GrSamplerState::Filter::kBilerp;
543 }
544
545 // Normalize the src quads and apply origin
546 NormalizationParams proxyParams = proxy_normalization_params(
547 curProxy, set[q].fProxyView.origin());
548 normalize_src_quad(proxyParams, &quad.fLocal);
549
550 // Update overall bounds of the op as the union of all quads
551 bounds.joinPossiblyEmptyRect(quad.fDevice.bounds());
552
553 // Determine the AA type for the quad, then merge with net AA type
554 GrAAType aaForQuad;
555 GrQuadUtils::ResolveAAType(aaType, set[q].fAAFlags, quad.fDevice,
556 &aaForQuad, &quad.fEdgeFlags);
557 // Resolve sets aaForQuad to aaType or None, there is never a change between aa methods
558 SkASSERT(aaForQuad == GrAAType::kNone || aaForQuad == aaType);
559 if (netAAType == GrAAType::kNone && aaForQuad != GrAAType::kNone) {
560 netAAType = aaType;
561 }
562
563 // Calculate metadata for the entry
564 const SkRect* domainForQuad = nullptr;
565 if (constraint == SkCanvas::kStrict_SrcRectConstraint) {
566 // Check (briefly) if the strict constraint is needed for this set entry
567 if (!set[q].fSrcRect.contains(curProxy->backingStoreBoundsRect()) &&
568 (filter == GrSamplerState::Filter::kBilerp ||
569 aaForQuad == GrAAType::kCoverage)) {
570 // Can't rely on hardware clamping and the draw will access outer texels
571 // for AA and/or bilerp. Unlike filter quality, this op still has per-quad
572 // control over AA so that can check aaForQuad, not netAAType.
573 netDomain = Domain::kYes;
574 domainForQuad = &set[q].fSrcRect;
575 }
576 }
577 // This domain may represent a no-op, otherwise it will have the origin and dimensions
578 // of the texture applied to it. Insetting for bilinear filtering is deferred until
579 // on[Pre]Prepare so that the overall filter can be lazily determined.
580 SkRect domain = normalize_domain(filter, proxyParams, domainForQuad);
581
582 // Always append a quad (or 2 if perspective clipped), it just may refer back to a prior
583 // ViewCountPair (this frequently happens when Chrome draws 9-patches).
584 float alpha = SkTPin(set[q].fAlpha, 0.f, 1.f);
585 fViewCountPairs[p].fQuadCnt += this->appendQuad(
586 &quad, {alpha, alpha, alpha, alpha}, domain);
587 }
588 // The # of proxy switches should match what was provided (+1 because we incremented p
589 // when a new proxy was encountered).
590 SkASSERT((p + 1) == fMetadata.fProxyCount);
591 SkASSERT(fQuads.count() == fMetadata.fTotalQuadCount);
592
593 fMetadata.fAAType = static_cast<uint16_t>(netAAType);
594 fMetadata.fFilter = static_cast<uint16_t>(netFilter);
595 fMetadata.fDomain = static_cast<uint16_t>(netDomain);
596
597 this->setBounds(bounds, HasAABloat(netAAType == GrAAType::kCoverage), IsHairline::kNo);
598 }
599
600 int appendQuad(DrawQuad* quad, const SkPMColor4f& color, const SkRect& domain) {
601 DrawQuad extra;
602 // Only clip when there's anti-aliasing. When non-aa, the GPU clips just fine and there's
603 // no inset/outset math that requires w > 0.
604 int quadCount = quad->fEdgeFlags != GrQuadAAFlags::kNone ?
605 GrQuadUtils::ClipToW0(quad, &extra) : 1;
606 if (quadCount == 0) {
607 // We can't discard the op at this point, but disable AA flags so it won't go through
608 // inset/outset processing
609 quad->fEdgeFlags = GrQuadAAFlags::kNone;
610 quadCount = 1;
611 }
612 fQuads.append(quad->fDevice, {color, domain, quad->fEdgeFlags}, &quad->fLocal);
613 if (quadCount > 1) {
614 fQuads.append(extra.fDevice, {color, domain, extra.fEdgeFlags}, &extra.fLocal);
615 fMetadata.fTotalQuadCount++;
616 }
617 return quadCount;
618 }
619
620 GrProgramInfo* programInfo() override {
621 // Although this Op implements its own onPrePrepareDraws it calls GrMeshDrawOps' version so
622 // this entry point will be called.
623 return (fDesc) ? fDesc->fProgramInfo : nullptr;
624 }
625
626 void onCreateProgramInfo(const GrCaps* caps,
627 SkArenaAlloc* arena,
628 const GrSurfaceProxyView* writeView,
629 GrAppliedClip&& appliedClip,
630 const GrXferProcessor::DstProxyView& dstProxyView) override {
631 SkASSERT(fDesc);
632
633 GrGeometryProcessor* gp;
634
635 {
636 const GrBackendFormat& backendFormat =
637 fViewCountPairs[0].fProxy->backendFormat();
638
639 GrSamplerState samplerState = GrSamplerState(GrSamplerState::WrapMode::kClamp,
640 fMetadata.filter());
641
642 gp = GrQuadPerEdgeAA::MakeTexturedProcessor(
643 arena, fDesc->fVertexSpec, *caps->shaderCaps(), backendFormat, samplerState,
644 fMetadata.fSwizzle, std::move(fTextureColorSpaceXform), fMetadata.saturate());
645
646 SkASSERT(fDesc->fVertexSpec.vertexSize() == gp->vertexStride());
647 }
648
649 auto pipelineFlags = (GrAAType::kMSAA == fMetadata.aaType()) ?
650 GrPipeline::InputFlags::kHWAntialias : GrPipeline::InputFlags::kNone;
651
652 fDesc->fProgramInfo = GrSimpleMeshDrawOpHelper::CreateProgramInfo(
653 caps, arena, writeView, std::move(appliedClip), dstProxyView, gp,
654 GrProcessorSet::MakeEmptySet(), fDesc->fVertexSpec.primitiveType(),
655 pipelineFlags);
656 }
657
658 void onPrePrepareDraws(GrRecordingContext* context,
659 const GrSurfaceProxyView* writeView,
660 GrAppliedClip* clip,
661 const GrXferProcessor::DstProxyView& dstProxyView) override {
662 TRACE_EVENT0("skia.gpu", TRACE_FUNC);
663
664 SkDEBUGCODE(this->validate();)
665 SkASSERT(!fDesc);
666
667 SkArenaAlloc* arena = context->priv().recordTimeAllocator();
668
669 fDesc = arena->make<Desc>();
670 this->characterize(fDesc);
671 fDesc->allocatePrePreparedVertices(arena);
672 FillInVertices(*context->priv().caps(), this, fDesc, fDesc->fPrePreparedVertices);
673
674 // This will call onCreateProgramInfo and register the created program with the DDL.
675 this->INHERITED::onPrePrepareDraws(context, writeView, clip, dstProxyView);
676 }
677
678 static void FillInVertices(const GrCaps& caps, TextureOp* texOp, Desc* desc, char* vertexData) {
679 SkASSERT(vertexData);
680
681 int totQuadsSeen = 0;
682 SkDEBUGCODE(int totVerticesSeen = 0;)
683 SkDEBUGCODE(const size_t vertexSize = desc->fVertexSpec.vertexSize());
684
685 GrQuadPerEdgeAA::Tessellator tessellator(desc->fVertexSpec, vertexData);
686 for (const auto& op : ChainRange<TextureOp>(texOp)) {
687 auto iter = op.fQuads.iterator();
688 for (unsigned p = 0; p < op.fMetadata.fProxyCount; ++p) {
689 const int quadCnt = op.fViewCountPairs[p].fQuadCnt;
690 SkDEBUGCODE(int meshVertexCnt = quadCnt * desc->fVertexSpec.verticesPerQuad());
691
692 // Can just use top-left for origin here since we only need the dimensions to
693 // determine the texel size for insetting.
694 NormalizationParams params = proxy_normalization_params(
695 op.fViewCountPairs[p].fProxy.get(), kTopLeft_GrSurfaceOrigin);
696
697 bool inset = texOp->fMetadata.filter() != GrSamplerState::Filter::kNearest;
698
699 for (int i = 0; i < quadCnt && iter.next(); ++i) {
700 SkASSERT(iter.isLocalValid());
701 const ColorDomainAndAA& info = iter.metadata();
702
703 tessellator.append(iter.deviceQuad(), iter.localQuad(), info.fColor,
704 inset ? inset_domain_for_bilerp(params, info.fDomainRect)
705 : info.fDomainRect,
706 info.aaFlags());
707 }
708
709 SkASSERT((totVerticesSeen + meshVertexCnt) * vertexSize
710 == (size_t)(tessellator.vertices() - vertexData));
711
712 totQuadsSeen += quadCnt;
713 SkDEBUGCODE(totVerticesSeen += meshVertexCnt);
714 SkASSERT(totQuadsSeen * desc->fVertexSpec.verticesPerQuad() == totVerticesSeen);
715 }
716
717 // If quad counts per proxy were calculated correctly, the entire iterator
718 // should have been consumed.
719 SkASSERT(!iter.next());
720 }
721
722 SkASSERT(desc->totalSizeInBytes() == (size_t)(tessellator.vertices() - vertexData));
723 SkASSERT(totQuadsSeen == desc->fNumTotalQuads);
724 SkASSERT(totVerticesSeen == desc->totalNumVertices());
725 }
726
727#ifdef SK_DEBUG
728 void validate() const override {
729 // NOTE: Since this is debug-only code, we use the virtual asTextureProxy()
730 auto textureType = fViewCountPairs[0].fProxy->asTextureProxy()->textureType();
731 GrAAType aaType = fMetadata.aaType();
732
733 int quadCount = 0;
734 for (const auto& op : ChainRange<TextureOp>(this)) {
735 SkASSERT(op.fMetadata.fSwizzle == fMetadata.fSwizzle);
736
737 for (unsigned p = 0; p < op.fMetadata.fProxyCount; ++p) {
738 auto* proxy = op.fViewCountPairs[p].fProxy->asTextureProxy();
739 quadCount += op.fViewCountPairs[p].fQuadCnt;
740 SkASSERT(proxy);
741 SkASSERT(proxy->textureType() == textureType);
742 }
743
744 // Each individual op must be a single aaType. kCoverage and kNone ops can chain
745 // together but kMSAA ones do not.
746 if (aaType == GrAAType::kCoverage || aaType == GrAAType::kNone) {
747 SkASSERT(op.fMetadata.aaType() == GrAAType::kCoverage ||
748 op.fMetadata.aaType() == GrAAType::kNone);
749 } else {
750 SkASSERT(aaType == GrAAType::kMSAA && op.fMetadata.aaType() == GrAAType::kMSAA);
751 }
752 }
753
754 SkASSERT(quadCount == this->numChainedQuads());
755 }
756#endif
757
758#if GR_TEST_UTILS
759 int numQuads() const final { return this->totNumQuads(); }
760#endif
761
762 void characterize(Desc* desc) const {
763 GrQuad::Type quadType = GrQuad::Type::kAxisAligned;
764 ColorType colorType = ColorType::kNone;
765 GrQuad::Type srcQuadType = GrQuad::Type::kAxisAligned;
766 Domain domain = Domain::kNo;
767 GrAAType overallAAType = fMetadata.aaType();
768
769 desc->fNumProxies = 0;
770 desc->fNumTotalQuads = 0;
771 int maxQuadsPerMesh = 0;
772
773 for (const auto& op : ChainRange<TextureOp>(this)) {
774 if (op.fQuads.deviceQuadType() > quadType) {
775 quadType = op.fQuads.deviceQuadType();
776 }
777 if (op.fQuads.localQuadType() > srcQuadType) {
778 srcQuadType = op.fQuads.localQuadType();
779 }
780 if (op.fMetadata.domain() == Domain::kYes) {
781 domain = Domain::kYes;
782 }
783 colorType = std::max(colorType, op.fMetadata.colorType());
784 desc->fNumProxies += op.fMetadata.fProxyCount;
785
786 for (unsigned p = 0; p < op.fMetadata.fProxyCount; ++p) {
787 maxQuadsPerMesh = std::max(op.fViewCountPairs[p].fQuadCnt, maxQuadsPerMesh);
788 }
789 desc->fNumTotalQuads += op.totNumQuads();
790
791 if (op.fMetadata.aaType() == GrAAType::kCoverage) {
792 overallAAType = GrAAType::kCoverage;
793 }
794 }
795
796 SkASSERT(desc->fNumTotalQuads == this->numChainedQuads());
797
798 SkASSERT(!CombinedQuadCountWillOverflow(overallAAType, false, desc->fNumTotalQuads));
799
800 auto indexBufferOption = GrQuadPerEdgeAA::CalcIndexBufferOption(overallAAType,
801 maxQuadsPerMesh);
802
803 desc->fVertexSpec = VertexSpec(quadType, colorType, srcQuadType, /* hasLocal */ true,
804 domain, overallAAType, /* alpha as coverage */ true,
805 indexBufferOption);
806
807 SkASSERT(desc->fNumTotalQuads <= GrQuadPerEdgeAA::QuadLimit(indexBufferOption));
808 }
809
810 int totNumQuads() const {
811#ifdef SK_DEBUG
812 int tmp = 0;
813 for (unsigned p = 0; p < fMetadata.fProxyCount; ++p) {
814 tmp += fViewCountPairs[p].fQuadCnt;
815 }
816 SkASSERT(tmp == fMetadata.fTotalQuadCount);
817#endif
818
819 return fMetadata.fTotalQuadCount;
820 }
821
822 int numChainedQuads() const {
823 int numChainedQuads = this->totNumQuads();
824
825 for (const GrOp* tmp = this->prevInChain(); tmp; tmp = tmp->prevInChain()) {
826 numChainedQuads += ((const TextureOp*)tmp)->totNumQuads();
827 }
828
829 for (const GrOp* tmp = this->nextInChain(); tmp; tmp = tmp->nextInChain()) {
830 numChainedQuads += ((const TextureOp*)tmp)->totNumQuads();
831 }
832
833 return numChainedQuads;
834 }
835
836 // onPrePrepareDraws may or may not have been called at this point
837 void onPrepareDraws(Target* target) override {
838 TRACE_EVENT0("skia.gpu", TRACE_FUNC);
839
840 SkDEBUGCODE(this->validate();)
841
842 SkASSERT(!fDesc || fDesc->fPrePreparedVertices);
843
844 if (!fDesc) {
845 SkArenaAlloc* arena = target->allocator();
846 fDesc = arena->make<Desc>();
847 this->characterize(fDesc);
848 SkASSERT(!fDesc->fPrePreparedVertices);
849 }
850
851 size_t vertexSize = fDesc->fVertexSpec.vertexSize();
852
853 void* vdata = target->makeVertexSpace(vertexSize, fDesc->totalNumVertices(),
854 &fDesc->fVertexBuffer, &fDesc->fBaseVertex);
855 if (!vdata) {
856 SkDebugf("Could not allocate vertices\n");
857 return;
858 }
859
860 if (fDesc->fVertexSpec.needsIndexBuffer()) {
861 fDesc->fIndexBuffer = GrQuadPerEdgeAA::GetIndexBuffer(
862 target, fDesc->fVertexSpec.indexBufferOption());
863 if (!fDesc->fIndexBuffer) {
864 SkDebugf("Could not allocate indices\n");
865 return;
866 }
867 }
868
869 if (fDesc->fPrePreparedVertices) {
870 memcpy(vdata, fDesc->fPrePreparedVertices, fDesc->totalSizeInBytes());
871 } else {
872 FillInVertices(target->caps(), this, fDesc, (char*) vdata);
873 }
874 }
875
876 void onExecute(GrOpFlushState* flushState, const SkRect& chainBounds) override {
877 if (!fDesc->fVertexBuffer) {
878 return;
879 }
880
881 if (fDesc->fVertexSpec.needsIndexBuffer() && !fDesc->fIndexBuffer) {
882 return;
883 }
884
885 if (!fDesc->fProgramInfo) {
886 this->createProgramInfo(flushState);
887 SkASSERT(fDesc->fProgramInfo);
888 }
889
890 flushState->bindPipelineAndScissorClip(*fDesc->fProgramInfo, chainBounds);
891 flushState->bindBuffers(fDesc->fIndexBuffer.get(), nullptr, fDesc->fVertexBuffer.get());
892
893 int totQuadsSeen = 0;
894 SkDEBUGCODE(int numDraws = 0;)
895 for (const auto& op : ChainRange<TextureOp>(this)) {
896 for (unsigned p = 0; p < op.fMetadata.fProxyCount; ++p) {
897 const int quadCnt = op.fViewCountPairs[p].fQuadCnt;
898 SkASSERT(numDraws < fDesc->fNumProxies);
899 flushState->bindTextures(fDesc->fProgramInfo->primProc(),
900 *op.fViewCountPairs[p].fProxy,
901 fDesc->fProgramInfo->pipeline());
902 GrQuadPerEdgeAA::IssueDraw(flushState->caps(), flushState->opsRenderPass(),
903 fDesc->fVertexSpec, totQuadsSeen, quadCnt,
904 fDesc->totalNumVertices(), fDesc->fBaseVertex);
905 totQuadsSeen += quadCnt;
906 SkDEBUGCODE(++numDraws;)
907 }
908 }
909
910 SkASSERT(totQuadsSeen == fDesc->fNumTotalQuads);
911 SkASSERT(numDraws == fDesc->fNumProxies);
912 }
913
914 CombineResult onCombineIfPossible(GrOp* t, GrRecordingContext::Arenas*,
915 const GrCaps& caps) override {
916 TRACE_EVENT0("skia.gpu", TRACE_FUNC);
917 const auto* that = t->cast<TextureOp>();
918
919 if (fDesc || that->fDesc) {
920 // This should never happen (since only DDL recorded ops should be prePrepared)
921 // but, in any case, we should never combine ops that that been prePrepared
922 return CombineResult::kCannotCombine;
923 }
924
925 if (fMetadata.domain() != that->fMetadata.domain()) {
926 // It is technically possible to combine operations across domain modes, but performance
927 // testing suggests it's better to make more draw calls where some take advantage of
928 // the more optimal shader path without coordinate clamping.
929 return CombineResult::kCannotCombine;
930 }
931 if (!GrColorSpaceXform::Equals(fTextureColorSpaceXform.get(),
932 that->fTextureColorSpaceXform.get())) {
933 return CombineResult::kCannotCombine;
934 }
935
936 bool upgradeToCoverageAAOnMerge = false;
937 if (fMetadata.aaType() != that->fMetadata.aaType()) {
938 if (!CanUpgradeAAOnMerge(fMetadata.aaType(), that->fMetadata.aaType())) {
939 return CombineResult::kCannotCombine;
940 }
941 upgradeToCoverageAAOnMerge = true;
942 }
943
944 if (CombinedQuadCountWillOverflow(fMetadata.aaType(), upgradeToCoverageAAOnMerge,
945 this->numChainedQuads() + that->numChainedQuads())) {
946 return CombineResult::kCannotCombine;
947 }
948
949 if (fMetadata.saturate() != that->fMetadata.saturate()) {
950 return CombineResult::kCannotCombine;
951 }
952 if (fMetadata.filter() != that->fMetadata.filter()) {
953 return CombineResult::kCannotCombine;
954 }
955 if (fMetadata.fSwizzle != that->fMetadata.fSwizzle) {
956 return CombineResult::kCannotCombine;
957 }
958 const auto* thisProxy = fViewCountPairs[0].fProxy.get();
959 const auto* thatProxy = that->fViewCountPairs[0].fProxy.get();
960 if (fMetadata.fProxyCount > 1 || that->fMetadata.fProxyCount > 1 ||
961 thisProxy != thatProxy) {
962 // We can't merge across different proxies. Check if 'this' can be chained with 'that'.
963 if (GrTextureProxy::ProxiesAreCompatibleAsDynamicState(thisProxy, thatProxy) &&
964 caps.dynamicStateArrayGeometryProcessorTextureSupport()) {
965 return CombineResult::kMayChain;
966 }
967 return CombineResult::kCannotCombine;
968 }
969
970 fMetadata.fDomain |= that->fMetadata.fDomain;
971 fMetadata.fColorType = std::max(fMetadata.fColorType, that->fMetadata.fColorType);
972 if (upgradeToCoverageAAOnMerge) {
973 fMetadata.fAAType = static_cast<uint16_t>(GrAAType::kCoverage);
974 }
975
976 // Concatenate quad lists together
977 fQuads.concat(that->fQuads);
978 fViewCountPairs[0].fQuadCnt += that->fQuads.count();
979 fMetadata.fTotalQuadCount += that->fQuads.count();
980
981 return CombineResult::kMerged;
982 }
983
984 GrQuadBuffer<ColorDomainAndAA> fQuads;
985 sk_sp<GrColorSpaceXform> fTextureColorSpaceXform;
986 // Most state of TextureOp is packed into these two field to minimize the op's size.
987 // Historically, increasing the size of TextureOp has caused surprising perf regressions, so
988 // consider/measure changes with care.
989 Desc* fDesc;
990 Metadata fMetadata;
991
992 // This field must go last. When allocating this op, we will allocate extra space to hold
993 // additional ViewCountPairs immediately after the op's allocation so we can treat this
994 // as an fProxyCnt-length array.
995 ViewCountPair fViewCountPairs[1];
996
997 typedef GrMeshDrawOp INHERITED;
998};
999
1000} // anonymous namespace
1001
1002#if GR_TEST_UTILS
1003uint32_t GrTextureOp::ClassID() {
1004 return TextureOp::ClassID();
1005}
1006#endif
1007
1008std::unique_ptr<GrDrawOp> GrTextureOp::Make(GrRecordingContext* context,
1009 GrSurfaceProxyView proxyView,
1010 SkAlphaType alphaType,
1011 sk_sp<GrColorSpaceXform> textureXform,
1012 GrSamplerState::Filter filter,
1013 const SkPMColor4f& color,
1014 Saturate saturate,
1015 SkBlendMode blendMode,
1016 GrAAType aaType,
1017 DrawQuad* quad,
1018 const SkRect* domain) {
1019 // Apply optimizations that are valid whether or not using GrTextureOp or GrFillRectOp
1020 if (domain && domain->contains(proxyView.proxy()->backingStoreBoundsRect())) {
1021 // No need for a shader-based domain if hardware clamping achieves the same effect
1022 domain = nullptr;
1023 }
1024
1025 if (filter != GrSamplerState::Filter::kNearest &&
1026 !filter_has_effect(quad->fLocal, quad->fDevice)) {
1027 filter = GrSamplerState::Filter::kNearest;
1028 }
1029
1030 if (blendMode == SkBlendMode::kSrcOver) {
1031 return TextureOp::Make(context, std::move(proxyView), std::move(textureXform), filter,
1032 color, saturate, aaType, std::move(quad), domain);
1033 } else {
1034 // Emulate complex blending using GrFillRectOp
1035 GrPaint paint;
1036 paint.setColor4f(color);
1037 paint.setXPFactory(SkBlendMode_AsXPFactory(blendMode));
1038
1039 std::unique_ptr<GrFragmentProcessor> fp;
1040 if (domain) {
1041 const auto& caps = *context->priv().caps();
1042 SkRect localRect;
1043 if (quad->fLocal.asRect(&localRect)) {
1044 fp = GrTextureEffect::MakeSubset(std::move(proxyView), alphaType, SkMatrix::I(), filter,
1045 *domain, localRect, caps);
1046 } else {
1047 fp = GrTextureEffect::MakeSubset(std::move(proxyView), alphaType, SkMatrix::I(), filter,
1048 *domain, caps);
1049 }
1050 } else {
1051 fp = GrTextureEffect::Make(std::move(proxyView), alphaType, SkMatrix::I(), filter);
1052 }
1053 fp = GrColorSpaceXformEffect::Make(std::move(fp), std::move(textureXform));
1054 paint.addColorFragmentProcessor(std::move(fp));
1055 if (saturate == GrTextureOp::Saturate::kYes) {
1056 paint.addColorFragmentProcessor(GrClampFragmentProcessor::Make(false));
1057 }
1058
1059 return GrFillRectOp::Make(context, std::move(paint), aaType, quad);
1060 }
1061}
1062
1063// A helper class that assists in breaking up bulk API quad draws into manageable chunks.
1064class GrTextureOp::BatchSizeLimiter {
1065public:
1066 BatchSizeLimiter(GrRenderTargetContext* rtc,
1067 const GrClip& clip,
1068 GrRecordingContext* context,
1069 int numEntries,
1070 GrSamplerState::Filter filter,
1071 GrTextureOp::Saturate saturate,
1072 SkCanvas::SrcRectConstraint constraint,
1073 const SkMatrix& viewMatrix,
1074 sk_sp<GrColorSpaceXform> textureColorSpaceXform)
1075 : fRTC(rtc)
1076 , fClip(clip)
1077 , fContext(context)
1078 , fFilter(filter)
1079 , fSaturate(saturate)
1080 , fConstraint(constraint)
1081 , fViewMatrix(viewMatrix)
1082 , fTextureColorSpaceXform(textureColorSpaceXform)
1083 , fNumLeft(numEntries) {
1084 }
1085
1086 void createOp(GrRenderTargetContext::TextureSetEntry set[],
1087 int clumpSize,
1088 GrAAType aaType) {
1089 int clumpProxyCount = proxy_run_count(&set[fNumClumped], clumpSize);
1090 std::unique_ptr<GrDrawOp> op = TextureOp::Make(fContext, &set[fNumClumped], clumpSize,
1091 clumpProxyCount, fFilter, fSaturate, aaType,
1092 fConstraint, fViewMatrix,
1093 fTextureColorSpaceXform);
1094 fRTC->addDrawOp(fClip, std::move(op));
1095
1096 fNumLeft -= clumpSize;
1097 fNumClumped += clumpSize;
1098 }
1099
1100 int numLeft() const { return fNumLeft; }
1101 int baseIndex() const { return fNumClumped; }
1102
1103private:
1104 GrRenderTargetContext* fRTC;
1105 const GrClip& fClip;
1106 GrRecordingContext* fContext;
1107 GrSamplerState::Filter fFilter;
1108 GrTextureOp::Saturate fSaturate;
1109 SkCanvas::SrcRectConstraint fConstraint;
1110 const SkMatrix& fViewMatrix;
1111 sk_sp<GrColorSpaceXform> fTextureColorSpaceXform;
1112
1113 int fNumLeft;
1114 int fNumClumped = 0; // also the offset for the start of the next clump
1115};
1116
1117// Greedily clump quad draws together until the index buffer limit is exceeded.
1118void GrTextureOp::AddTextureSetOps(GrRenderTargetContext* rtc,
1119 const GrClip& clip,
1120 GrRecordingContext* context,
1121 GrRenderTargetContext::TextureSetEntry set[],
1122 int cnt,
1123 int proxyRunCnt,
1124 GrSamplerState::Filter filter,
1125 Saturate saturate,
1126 SkBlendMode blendMode,
1127 GrAAType aaType,
1128 SkCanvas::SrcRectConstraint constraint,
1129 const SkMatrix& viewMatrix,
1130 sk_sp<GrColorSpaceXform> textureColorSpaceXform) {
1131 // Ensure that the index buffer limits are lower than the proxy and quad count limits of
1132 // the op's metadata so we don't need to worry about overflow.
1133 SkDEBUGCODE(TextureOp::ValidateResourceLimits();)
1134 SkASSERT(proxy_run_count(set, cnt) == proxyRunCnt);
1135
1136 // First check if we can support batches as a single op
1137 if (blendMode != SkBlendMode::kSrcOver ||
1138 !context->priv().caps()->dynamicStateArrayGeometryProcessorTextureSupport()) {
1139 // Append each entry as its own op; these may still be GrTextureOps if the blend mode is
1140 // src-over but the backend doesn't support dynamic state changes. Otherwise Make()
1141 // automatically creates the appropriate GrFillRectOp to emulate GrTextureOp.
1142 SkMatrix ctm;
1143 for (int i = 0; i < cnt; ++i) {
1144 float alpha = set[i].fAlpha;
1145 ctm = viewMatrix;
1146 if (set[i].fPreViewMatrix) {
1147 ctm.preConcat(*set[i].fPreViewMatrix);
1148 }
1149
1150 DrawQuad quad;
1151 quad.fEdgeFlags = set[i].fAAFlags;
1152 if (set[i].fDstClipQuad) {
1153 quad.fDevice = GrQuad::MakeFromSkQuad(set[i].fDstClipQuad, ctm);
1154
1155 SkPoint srcPts[4];
1156 GrMapRectPoints(set[i].fDstRect, set[i].fSrcRect, set[i].fDstClipQuad, srcPts, 4);
1157 quad.fLocal = GrQuad::MakeFromSkQuad(srcPts, SkMatrix::I());
1158 } else {
1159 quad.fDevice = GrQuad::MakeFromRect(set[i].fDstRect, ctm);
1160 quad.fLocal = GrQuad(set[i].fSrcRect);
1161 }
1162
1163 const SkRect* domain = constraint == SkCanvas::kStrict_SrcRectConstraint
1164 ? &set[i].fSrcRect : nullptr;
1165
1166 auto op = Make(context, set[i].fProxyView, set[i].fSrcAlphaType, textureColorSpaceXform,
1167 filter, {alpha, alpha, alpha, alpha}, saturate, blendMode, aaType,
1168 &quad, domain);
1169 rtc->addDrawOp(clip, std::move(op));
1170 }
1171 return;
1172 }
1173
1174 // Second check if we can always just make a single op and avoid the extra iteration
1175 // needed to clump things together.
1176 if (cnt <= std::min(GrResourceProvider::MaxNumNonAAQuads(),
1177 GrResourceProvider::MaxNumAAQuads())) {
1178 auto op = TextureOp::Make(context, set, cnt, proxyRunCnt, filter, saturate, aaType,
1179 constraint, viewMatrix, std::move(textureColorSpaceXform));
1180 rtc->addDrawOp(clip, std::move(op));
1181 return;
1182 }
1183
1184 BatchSizeLimiter state(rtc, clip, context, cnt, filter, saturate, constraint, viewMatrix,
1185 std::move(textureColorSpaceXform));
1186
1187 // kNone and kMSAA never get altered
1188 if (aaType == GrAAType::kNone || aaType == GrAAType::kMSAA) {
1189 // Clump these into series of MaxNumNonAAQuads-sized GrTextureOps
1190 while (state.numLeft() > 0) {
1191 int clumpSize = std::min(state.numLeft(), GrResourceProvider::MaxNumNonAAQuads());
1192
1193 state.createOp(set, clumpSize, aaType);
1194 }
1195 } else {
1196 // kCoverage can be downgraded to kNone. Note that the following is conservative. kCoverage
1197 // can also get downgraded to kNone if all the quads are on integer coordinates and
1198 // axis-aligned.
1199 SkASSERT(aaType == GrAAType::kCoverage);
1200
1201 while (state.numLeft() > 0) {
1202 GrAAType runningAA = GrAAType::kNone;
1203 bool clumped = false;
1204
1205 for (int i = 0; i < state.numLeft(); ++i) {
1206 int absIndex = state.baseIndex() + i;
1207
1208 if (set[absIndex].fAAFlags != GrQuadAAFlags::kNone) {
1209
1210 if (i >= GrResourceProvider::MaxNumAAQuads()) {
1211 // Here we either need to boost the AA type to kCoverage, but doing so with
1212 // all the accumulated quads would overflow, or we have a set of AA quads
1213 // that has just gotten too large. In either case, calve off the existing
1214 // quads as their own TextureOp.
1215 state.createOp(
1216 set,
1217 runningAA == GrAAType::kNone ? i : GrResourceProvider::MaxNumAAQuads(),
1218 runningAA); // maybe downgrading AA here
1219 clumped = true;
1220 break;
1221 }
1222
1223 runningAA = GrAAType::kCoverage;
1224 } else if (runningAA == GrAAType::kNone) {
1225
1226 if (i >= GrResourceProvider::MaxNumNonAAQuads()) {
1227 // Here we've found a consistent batch of non-AA quads that has gotten too
1228 // large. Calve it off as its own GrTextureOp.
1229 state.createOp(set, GrResourceProvider::MaxNumNonAAQuads(),
1230 GrAAType::kNone); // definitely downgrading AA here
1231 clumped = true;
1232 break;
1233 }
1234 }
1235 }
1236
1237 if (!clumped) {
1238 // We ran through the above loop w/o hitting a limit. Spit out this last clump of
1239 // quads and call it a day.
1240 state.createOp(set, state.numLeft(), runningAA); // maybe downgrading AA here
1241 }
1242 }
1243 }
1244}
1245
1246#if GR_TEST_UTILS
1247#include "include/private/GrRecordingContext.h"
1248#include "src/gpu/GrProxyProvider.h"
1249#include "src/gpu/GrRecordingContextPriv.h"
1250
1251GR_DRAW_OP_TEST_DEFINE(TextureOp) {
1252 SkISize dims;
1253 dims.fHeight = random->nextULessThan(90) + 10;
1254 dims.fWidth = random->nextULessThan(90) + 10;
1255 auto origin = random->nextBool() ? kTopLeft_GrSurfaceOrigin : kBottomLeft_GrSurfaceOrigin;
1256 GrMipMapped mipMapped = random->nextBool() ? GrMipMapped::kYes : GrMipMapped::kNo;
1257 SkBackingFit fit = SkBackingFit::kExact;
1258 if (mipMapped == GrMipMapped::kNo) {
1259 fit = random->nextBool() ? SkBackingFit::kApprox : SkBackingFit::kExact;
1260 }
1261 const GrBackendFormat format =
1262 context->priv().caps()->getDefaultBackendFormat(GrColorType::kRGBA_8888,
1263 GrRenderable::kNo);
1264 GrProxyProvider* proxyProvider = context->priv().proxyProvider();
1265 sk_sp<GrTextureProxy> proxy = proxyProvider->createProxy(
1266 format, dims, GrRenderable::kNo, 1, mipMapped, fit, SkBudgeted::kNo, GrProtected::kNo,
1267 GrInternalSurfaceFlags::kNone);
1268
1269 SkRect rect = GrTest::TestRect(random);
1270 SkRect srcRect;
1271 srcRect.fLeft = random->nextRangeScalar(0.f, proxy->width() / 2.f);
1272 srcRect.fRight = random->nextRangeScalar(0.f, proxy->width()) + proxy->width() / 2.f;
1273 srcRect.fTop = random->nextRangeScalar(0.f, proxy->height() / 2.f);
1274 srcRect.fBottom = random->nextRangeScalar(0.f, proxy->height()) + proxy->height() / 2.f;
1275 SkMatrix viewMatrix = GrTest::TestMatrixPreservesRightAngles(random);
1276 SkPMColor4f color = SkPMColor4f::FromBytes_RGBA(SkColorToPremulGrColor(random->nextU()));
1277 GrSamplerState::Filter filter = (GrSamplerState::Filter)random->nextULessThan(
1278 static_cast<uint32_t>(GrSamplerState::Filter::kMipMap) + 1);
1279 while (mipMapped == GrMipMapped::kNo && filter == GrSamplerState::Filter::kMipMap) {
1280 filter = (GrSamplerState::Filter)random->nextULessThan(
1281 static_cast<uint32_t>(GrSamplerState::Filter::kMipMap) + 1);
1282 }
1283 auto texXform = GrTest::TestColorXform(random);
1284 GrAAType aaType = GrAAType::kNone;
1285 if (random->nextBool()) {
1286 aaType = (numSamples > 1) ? GrAAType::kMSAA : GrAAType::kCoverage;
1287 }
1288 GrQuadAAFlags aaFlags = GrQuadAAFlags::kNone;
1289 aaFlags |= random->nextBool() ? GrQuadAAFlags::kLeft : GrQuadAAFlags::kNone;
1290 aaFlags |= random->nextBool() ? GrQuadAAFlags::kTop : GrQuadAAFlags::kNone;
1291 aaFlags |= random->nextBool() ? GrQuadAAFlags::kRight : GrQuadAAFlags::kNone;
1292 aaFlags |= random->nextBool() ? GrQuadAAFlags::kBottom : GrQuadAAFlags::kNone;
1293 bool useDomain = random->nextBool();
1294 auto saturate = random->nextBool() ? GrTextureOp::Saturate::kYes : GrTextureOp::Saturate::kNo;
1295 GrSurfaceProxyView proxyView(
1296 std::move(proxy), origin,
1297 context->priv().caps()->getReadSwizzle(format, GrColorType::kRGBA_8888));
1298 auto alphaType = static_cast<SkAlphaType>(
1299 random->nextRangeU(kUnknown_SkAlphaType + 1, kLastEnum_SkAlphaType));
1300
1301 DrawQuad quad = {GrQuad::MakeFromRect(rect, viewMatrix), GrQuad(srcRect), aaFlags};
1302 return GrTextureOp::Make(context, std::move(proxyView), alphaType, std::move(texXform), filter,
1303 color, saturate, SkBlendMode::kSrcOver, aaType,
1304 &quad, useDomain ? &srcRect : nullptr);
1305}
1306
1307#endif
1308