blob: 3b4c5da7328320e21151664c4d4176becd8c16be [file] [log] [blame]
joshualitt9c80b5f2015-08-13 10:05:51 -07001/*
2 * Copyright 2015 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
joshualittbcf33d52015-08-26 08:10:35 -07008#include "GrNonAAFillRectBatch.h"
joshualitt9c80b5f2015-08-13 10:05:51 -07009
bsalomon75398562015-08-17 12:55:38 -070010#include "GrBatchFlushState.h"
joshualitt9c80b5f2015-08-13 10:05:51 -070011#include "GrColor.h"
12#include "GrDefaultGeoProcFactory.h"
13#include "GrPrimitiveProcessor.h"
joshualitt2244c272015-08-21 10:33:15 -070014#include "GrResourceProvider.h"
15#include "GrTInstanceBatch.h"
joshualittae5b2c62015-08-19 08:48:41 -070016#include "GrQuad.h"
bsalomon16b99132015-08-13 14:55:50 -070017#include "GrVertexBatch.h"
joshualitt9c80b5f2015-08-13 10:05:51 -070018
joshualitt2244c272015-08-21 10:33:15 -070019// Common functions
joshualittbcf33d52015-08-26 08:10:35 -070020class NonAAFillRectBatchBase {
joshualitt2244c272015-08-21 10:33:15 -070021public:
22 static const int kVertsPerInstance = 4;
23 static const int kIndicesPerInstance = 6;
joshualitt87e47522015-08-20 07:22:42 -070024
joshualitt2244c272015-08-21 10:33:15 -070025 static void InitInvariantOutputCoverage(GrInitInvariantOutput* out) {
26 out->setKnownSingleComponent(0xff);
27 }
28
cdalton397536c2016-03-25 12:15:03 -070029 static const GrBuffer* GetIndexBuffer(GrResourceProvider* rp) {
joshualitt2244c272015-08-21 10:33:15 -070030 return rp->refQuadIndexBuffer();
31 }
32
33 template <typename Geometry>
34 static void SetBounds(const Geometry& geo, SkRect* outBounds) {
35 geo.fViewMatrix.mapRect(outBounds, geo.fRect);
36 }
joshualittaa37a962015-09-18 13:03:25 -070037
38 template <typename Geometry>
39 static void UpdateBoundsAfterAppend(const Geometry& geo, SkRect* outBounds) {
40 SkRect bounds = geo.fRect;
41 geo.fViewMatrix.mapRect(&bounds);
42 outBounds->join(bounds);
43 }
joshualitt2244c272015-08-21 10:33:15 -070044};
45
46/** We always use per-vertex colors so that rects can be batched across color changes. Sometimes
47 we have explicit local coords and sometimes not. We *could* always provide explicit local
48 coords and just duplicate the positions when the caller hasn't provided a local coord rect,
49 but we haven't seen a use case which frequently switches between local rect and no local
50 rect draws.
51
52 The vertex attrib order is always pos, color, [local coords].
53 */
bungeman06ca8ec2016-06-09 08:01:03 -070054static sk_sp<GrGeometryProcessor> make_gp(const SkMatrix& viewMatrix,
55 bool readsCoverage,
56 bool hasExplicitLocalCoords,
57 const SkMatrix* localMatrix) {
joshualitt2244c272015-08-21 10:33:15 -070058 using namespace GrDefaultGeoProcFactory;
59 Color color(Color::kAttribute_Type);
60 Coverage coverage(readsCoverage ? Coverage::kSolid_Type : Coverage::kNone_Type);
61
joshualitt8cce8f12015-08-26 06:23:39 -070062 // If we have perspective on the viewMatrix then we won't map on the CPU, nor will we map
63 // the local rect on the cpu (in case the localMatrix also has perspective).
64 // Otherwise, if we have a local rect, then we apply the localMatrix directly to the localRect
65 // to generate vertex local coords
66 if (viewMatrix.hasPerspective()) {
67 LocalCoords localCoords(hasExplicitLocalCoords ? LocalCoords::kHasExplicit_Type :
68 LocalCoords::kUsePosition_Type,
69 localMatrix);
bungeman06ca8ec2016-06-09 08:01:03 -070070 return GrDefaultGeoProcFactory::Make(color, coverage, localCoords, viewMatrix);
joshualitt8cce8f12015-08-26 06:23:39 -070071 } else if (hasExplicitLocalCoords) {
joshualitt2244c272015-08-21 10:33:15 -070072 LocalCoords localCoords(LocalCoords::kHasExplicit_Type);
bungeman06ca8ec2016-06-09 08:01:03 -070073 return GrDefaultGeoProcFactory::Make(color, coverage, localCoords, SkMatrix::I());
joshualitt2244c272015-08-21 10:33:15 -070074 } else {
75 LocalCoords localCoords(LocalCoords::kUsePosition_Type, localMatrix);
bungeman06ca8ec2016-06-09 08:01:03 -070076 return GrDefaultGeoProcFactory::MakeForDeviceSpace(color, coverage, localCoords,
77 viewMatrix);
joshualitt2244c272015-08-21 10:33:15 -070078 }
79}
80
81static void tesselate(intptr_t vertices,
82 size_t vertexStride,
83 GrColor color,
84 const SkMatrix& viewMatrix,
85 const SkRect& rect,
joshualitt8cce8f12015-08-26 06:23:39 -070086 const GrQuad* localQuad) {
joshualitt2244c272015-08-21 10:33:15 -070087 SkPoint* positions = reinterpret_cast<SkPoint*>(vertices);
88
89 positions->setRectFan(rect.fLeft, rect.fTop,
90 rect.fRight, rect.fBottom, vertexStride);
joshualitt2244c272015-08-21 10:33:15 -070091
joshualitt8cce8f12015-08-26 06:23:39 -070092 if (!viewMatrix.hasPerspective()) {
93 viewMatrix.mapPointsWithStride(positions, vertexStride,
joshualittbcf33d52015-08-26 08:10:35 -070094 NonAAFillRectBatchBase::kVertsPerInstance);
joshualitt8cce8f12015-08-26 06:23:39 -070095 }
96
97 // Setup local coords
joshualitt2244c272015-08-21 10:33:15 -070098 // TODO we should only do this if local coords are being read
joshualitt8cce8f12015-08-26 06:23:39 -070099 if (localQuad) {
joshualitt2244c272015-08-21 10:33:15 -0700100 static const int kLocalOffset = sizeof(SkPoint) + sizeof(GrColor);
joshualittbcf33d52015-08-26 08:10:35 -0700101 for (int i = 0; i < NonAAFillRectBatchBase::kVertsPerInstance; i++) {
joshualitt8cce8f12015-08-26 06:23:39 -0700102 SkPoint* coords = reinterpret_cast<SkPoint*>(vertices + kLocalOffset +
103 i * vertexStride);
104 *coords = localQuad->point(i);
joshualitt2244c272015-08-21 10:33:15 -0700105 }
106 }
107
108 static const int kColorOffset = sizeof(SkPoint);
109 GrColor* vertColor = reinterpret_cast<GrColor*>(vertices + kColorOffset);
110 for (int j = 0; j < 4; ++j) {
111 *vertColor = color;
112 vertColor = (GrColor*) ((intptr_t) vertColor + vertexStride);
113 }
114}
115
joshualittbcf33d52015-08-26 08:10:35 -0700116class NonAAFillRectBatchImp : public NonAAFillRectBatchBase {
joshualitt2244c272015-08-21 10:33:15 -0700117public:
118 struct Geometry {
119 SkMatrix fViewMatrix;
120 SkRect fRect;
joshualitt8cce8f12015-08-26 06:23:39 -0700121 GrQuad fLocalQuad;
joshualitt2244c272015-08-21 10:33:15 -0700122 GrColor fColor;
123 };
124
joshualittbcf33d52015-08-26 08:10:35 -0700125 static const char* Name() { return "NonAAFillRectBatch"; }
joshualitt2244c272015-08-21 10:33:15 -0700126
robertphillips783a4da2015-11-19 14:00:02 -0800127 static SkString DumpInfo(const Geometry& geo, int index) {
robertphillipse004bfc2015-11-16 09:06:59 -0800128 SkString str;
robertphillips783a4da2015-11-19 14:00:02 -0800129 str.appendf("%d: Color: 0x%08x, Rect [L: %.2f, T: %.2f, R: %.2f, B: %.2f]\n",
130 index,
robertphillipse004bfc2015-11-16 09:06:59 -0800131 geo.fColor,
132 geo.fRect.fLeft, geo.fRect.fTop, geo.fRect.fRight, geo.fRect.fBottom);
133 return str;
134 }
135
joshualitt2244c272015-08-21 10:33:15 -0700136 static bool CanCombine(const Geometry& mine, const Geometry& theirs,
ethannicholasff210322015-11-24 12:10:10 -0800137 const GrXPOverridesForBatch& overrides) {
joshualitt87e47522015-08-20 07:22:42 -0700138 return true;
139 }
140
bungeman06ca8ec2016-06-09 08:01:03 -0700141 static sk_sp<GrGeometryProcessor> MakeGP(const Geometry& geo,
142 const GrXPOverridesForBatch& overrides) {
143 sk_sp<GrGeometryProcessor> gp = make_gp(geo.fViewMatrix, overrides.readsCoverage(), true,
144 nullptr);
joshualitt87e47522015-08-20 07:22:42 -0700145
joshualitt2244c272015-08-21 10:33:15 -0700146 SkASSERT(gp->getVertexStride() ==
147 sizeof(GrDefaultGeoProcFactory::PositionColorLocalCoordAttr));
148 return gp;
joshualittae41b382015-08-19 06:54:08 -0700149 }
150
joshualitt2244c272015-08-21 10:33:15 -0700151 static void Tesselate(intptr_t vertices, size_t vertexStride, const Geometry& geo,
ethannicholasff210322015-11-24 12:10:10 -0800152 const GrXPOverridesForBatch& overrides) {
joshualitt8cce8f12015-08-26 06:23:39 -0700153 tesselate(vertices, vertexStride, geo.fColor, geo.fViewMatrix, geo.fRect, &geo.fLocalQuad);
joshualitt2244c272015-08-21 10:33:15 -0700154 }
155};
156
joshualitt8cce8f12015-08-26 06:23:39 -0700157// We handle perspective in the local matrix or viewmatrix with special batches
joshualittbcf33d52015-08-26 08:10:35 -0700158class NonAAFillRectBatchPerspectiveImp : public NonAAFillRectBatchBase {
joshualitt2244c272015-08-21 10:33:15 -0700159public:
160 struct Geometry {
161 SkMatrix fViewMatrix;
162 SkMatrix fLocalMatrix;
163 SkRect fRect;
164 SkRect fLocalRect;
joshualittae41b382015-08-19 06:54:08 -0700165 GrColor fColor;
joshualitt8cce8f12015-08-26 06:23:39 -0700166 bool fHasLocalMatrix;
167 bool fHasLocalRect;
joshualittae41b382015-08-19 06:54:08 -0700168 };
169
joshualittbcf33d52015-08-26 08:10:35 -0700170 static const char* Name() { return "NonAAFillRectBatchPerspective"; }
joshualitt2244c272015-08-21 10:33:15 -0700171
robertphillips783a4da2015-11-19 14:00:02 -0800172 static SkString DumpInfo(const Geometry& geo, int index) {
robertphillipse004bfc2015-11-16 09:06:59 -0800173 SkString str;
robertphillips783a4da2015-11-19 14:00:02 -0800174 str.appendf("%d: Color: 0x%08x, Rect [L: %.2f, T: %.2f, R: %.2f, B: %.2f]\n",
175 index,
robertphillipse004bfc2015-11-16 09:06:59 -0800176 geo.fColor,
177 geo.fRect.fLeft, geo.fRect.fTop, geo.fRect.fRight, geo.fRect.fBottom);
178 return str;
179 }
180
joshualitt2244c272015-08-21 10:33:15 -0700181 static bool CanCombine(const Geometry& mine, const Geometry& theirs,
ethannicholasff210322015-11-24 12:10:10 -0800182 const GrXPOverridesForBatch& overrides) {
joshualitt8cce8f12015-08-26 06:23:39 -0700183 // We could batch across perspective vm changes if we really wanted to
184 return mine.fViewMatrix.cheapEqualTo(theirs.fViewMatrix) &&
joshualitt2120b6f2015-09-18 12:56:41 -0700185 mine.fHasLocalRect == theirs.fHasLocalRect &&
joshualitt8cce8f12015-08-26 06:23:39 -0700186 (!mine.fHasLocalMatrix || mine.fLocalMatrix.cheapEqualTo(theirs.fLocalMatrix));
joshualitt2244c272015-08-21 10:33:15 -0700187 }
188
bungeman06ca8ec2016-06-09 08:01:03 -0700189 static sk_sp<GrGeometryProcessor> MakeGP(const Geometry& geo,
190 const GrXPOverridesForBatch& overrides) {
191 sk_sp<GrGeometryProcessor> gp = make_gp(geo.fViewMatrix, overrides.readsCoverage(),
192 geo.fHasLocalRect,
193 geo.fHasLocalMatrix ? &geo.fLocalMatrix
194 : nullptr);
joshualitt2244c272015-08-21 10:33:15 -0700195
joshualitt8cce8f12015-08-26 06:23:39 -0700196 SkASSERT(geo.fHasLocalRect ?
197 gp->getVertexStride() == sizeof(GrDefaultGeoProcFactory::PositionColorLocalCoordAttr) :
198 gp->getVertexStride() == sizeof(GrDefaultGeoProcFactory::PositionColorAttr));
joshualitt2244c272015-08-21 10:33:15 -0700199 return gp;
200 }
201
202 static void Tesselate(intptr_t vertices, size_t vertexStride, const Geometry& geo,
ethannicholasff210322015-11-24 12:10:10 -0800203 const GrXPOverridesForBatch& overrides) {
joshualitt8cce8f12015-08-26 06:23:39 -0700204 if (geo.fHasLocalRect) {
205 GrQuad quad(geo.fLocalRect);
206 tesselate(vertices, vertexStride, geo.fColor, geo.fViewMatrix, geo.fRect, &quad);
207 } else {
208 tesselate(vertices, vertexStride, geo.fColor, geo.fViewMatrix, geo.fRect, nullptr);
209 }
joshualitt2244c272015-08-21 10:33:15 -0700210 }
joshualittae41b382015-08-19 06:54:08 -0700211};
212
joshualittbcf33d52015-08-26 08:10:35 -0700213typedef GrTInstanceBatch<NonAAFillRectBatchImp> NonAAFillRectBatchSimple;
214typedef GrTInstanceBatch<NonAAFillRectBatchPerspectiveImp> NonAAFillRectBatchPerspective;
joshualitt2244c272015-08-21 10:33:15 -0700215
joshualittaa37a962015-09-18 13:03:25 -0700216inline static void append_to_batch(NonAAFillRectBatchSimple* batch, GrColor color,
217 const SkMatrix& viewMatrix, const SkRect& rect,
218 const SkRect* localRect, const SkMatrix* localMatrix) {
joshualitt3566d442015-09-18 07:12:55 -0700219 SkASSERT(!viewMatrix.hasPerspective() && (!localMatrix || !localMatrix->hasPerspective()));
joshualittaa37a962015-09-18 13:03:25 -0700220 NonAAFillRectBatchSimple::Geometry& geo = batch->geoData()->push_back();
joshualitt8cce8f12015-08-26 06:23:39 -0700221
joshualitt3566d442015-09-18 07:12:55 -0700222 geo.fColor = color;
223 geo.fViewMatrix = viewMatrix;
224 geo.fRect = rect;
joshualitt8cce8f12015-08-26 06:23:39 -0700225
joshualitt3566d442015-09-18 07:12:55 -0700226 if (localRect && localMatrix) {
227 geo.fLocalQuad.setFromMappedRect(*localRect, *localMatrix);
228 } else if (localRect) {
229 geo.fLocalQuad.set(*localRect);
230 } else if (localMatrix) {
231 geo.fLocalQuad.setFromMappedRect(rect, *localMatrix);
joshualitt9c80b5f2015-08-13 10:05:51 -0700232 } else {
joshualitt3566d442015-09-18 07:12:55 -0700233 geo.fLocalQuad.set(rect);
joshualitt9c80b5f2015-08-13 10:05:51 -0700234 }
joshualitt9c80b5f2015-08-13 10:05:51 -0700235}
joshualitt3566d442015-09-18 07:12:55 -0700236
joshualittaa37a962015-09-18 13:03:25 -0700237inline static void append_to_batch(NonAAFillRectBatchPerspective* batch, GrColor color,
238 const SkMatrix& viewMatrix, const SkRect& rect,
239 const SkRect* localRect, const SkMatrix* localMatrix) {
joshualitt3566d442015-09-18 07:12:55 -0700240 SkASSERT(viewMatrix.hasPerspective() || (localMatrix && localMatrix->hasPerspective()));
joshualittaa37a962015-09-18 13:03:25 -0700241 NonAAFillRectBatchPerspective::Geometry& geo = batch->geoData()->push_back();
joshualitt3566d442015-09-18 07:12:55 -0700242
243 geo.fColor = color;
244 geo.fViewMatrix = viewMatrix;
245 geo.fRect = rect;
246 geo.fHasLocalRect = SkToBool(localRect);
247 geo.fHasLocalMatrix = SkToBool(localMatrix);
248 if (localMatrix) {
249 geo.fLocalMatrix = *localMatrix;
250 }
251 if (localRect) {
252 geo.fLocalRect = *localRect;
253 }
254
joshualittaa37a962015-09-18 13:03:25 -0700255}
256
257namespace GrNonAAFillRectBatch {
258
259GrDrawBatch* Create(GrColor color,
260 const SkMatrix& viewMatrix,
261 const SkRect& rect,
262 const SkRect* localRect,
263 const SkMatrix* localMatrix) {
264 NonAAFillRectBatchSimple* batch = NonAAFillRectBatchSimple::Create();
265 append_to_batch(batch, color, viewMatrix, rect, localRect, localMatrix);
joshualitt3566d442015-09-18 07:12:55 -0700266 batch->init();
267 return batch;
268}
269
joshualittaa37a962015-09-18 13:03:25 -0700270GrDrawBatch* CreateWithPerspective(GrColor color,
271 const SkMatrix& viewMatrix,
272 const SkRect& rect,
273 const SkRect* localRect,
274 const SkMatrix* localMatrix) {
275 NonAAFillRectBatchPerspective* batch = NonAAFillRectBatchPerspective::Create();
276 append_to_batch(batch, color, viewMatrix, rect, localRect, localMatrix);
277 batch->init();
278 return batch;
279}
280
281bool Append(GrBatch* origBatch,
282 GrColor color,
283 const SkMatrix& viewMatrix,
284 const SkRect& rect,
285 const SkRect* localRect,
286 const SkMatrix* localMatrix) {
287 bool usePerspective = viewMatrix.hasPerspective() ||
288 (localMatrix && localMatrix->hasPerspective());
289
290 if (usePerspective && origBatch->classID() != NonAAFillRectBatchPerspective::ClassID()) {
291 return false;
292 }
293
294 if (!usePerspective) {
295 NonAAFillRectBatchSimple* batch = origBatch->cast<NonAAFillRectBatchSimple>();
296 append_to_batch(batch, color, viewMatrix, rect, localRect, localMatrix);
297 batch->updateBoundsAfterAppend();
298 } else {
299 NonAAFillRectBatchPerspective* batch = origBatch->cast<NonAAFillRectBatchPerspective>();
300 const NonAAFillRectBatchPerspective::Geometry& geo = batch->geoData()->back();
301
302 if (!geo.fViewMatrix.cheapEqualTo(viewMatrix) ||
303 geo.fHasLocalRect != SkToBool(localRect) ||
304 geo.fHasLocalMatrix != SkToBool(localMatrix) ||
305 (geo.fHasLocalMatrix && !geo.fLocalMatrix.cheapEqualTo(*localMatrix))) {
306 return false;
307 }
308
309 append_to_batch(batch, color, viewMatrix, rect, localRect, localMatrix);
310 batch->updateBoundsAfterAppend();
311 }
312
313 return true;
314}
315
joshualitt9c80b5f2015-08-13 10:05:51 -0700316};
317
318///////////////////////////////////////////////////////////////////////////////////////////////////
319
320#ifdef GR_TEST_UTILS
321
322#include "GrBatchTest.h"
323
bsalomonabd30f52015-08-13 13:34:48 -0700324DRAW_BATCH_TEST_DEFINE(RectBatch) {
joshualitt2244c272015-08-21 10:33:15 -0700325 GrColor color = GrRandomColor(random);
326 SkRect rect = GrTest::TestRect(random);
327 SkRect localRect = GrTest::TestRect(random);
328 SkMatrix viewMatrix = GrTest::TestMatrixInvertible(random);
329 SkMatrix localMatrix = GrTest::TestMatrix(random);
joshualitt9c80b5f2015-08-13 10:05:51 -0700330
joshualitt2244c272015-08-21 10:33:15 -0700331 bool hasLocalRect = random->nextBool();
332 bool hasLocalMatrix = random->nextBool();
joshualittbcf33d52015-08-26 08:10:35 -0700333 return GrNonAAFillRectBatch::Create(color, viewMatrix, rect,
334 hasLocalRect ? &localRect : nullptr,
335 hasLocalMatrix ? &localMatrix : nullptr);
joshualitt9c80b5f2015-08-13 10:05:51 -0700336}
337
338#endif