Implement instanced rendering for simple shapes

src/gpu/GrInstancedRendering.cpp

+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "GrInstancedRendering.h"
+
+#include "GrBatchFlushState.h"
+#include "GrPipeline.h"
+#include "GrResourceProvider.h"
+#include "effects/GrInstanceProcessor.h"
+
+GrInstancedRendering::GrInstancedRendering(GrGpu* gpu, uint32_t supportedAAModes,
+                                           size_t sizeofBatchClass)
+    : fGpu(SkRef(gpu)),
+      fSupportedAAModes(supportedAAModes),
+      fState(State::kRecordingShapes),
+      fBatchAllocator(sizeofBatchClass) {
+    SkDEBUGCODE(fInUseBatchCount = 0;)
+}
+
+GrDrawBatch* GrInstancedRendering::recordRect(const SkRect& rect, const SkMatrix& viewMatrix,
+                                              GrColor color, bool antialias, uint32_t flags,
+                                              bool* useHWAA) {
+    return this->recordShape(kRect_ShapeType, rect, viewMatrix, color, rect, antialias, flags,
+                             useHWAA);
+}
+
+GrDrawBatch* GrInstancedRendering::recordRect(const SkRect& rect, const SkMatrix& viewMatrix,
+                                              GrColor color, const SkRect& localRect,
+                                              bool antialias, uint32_t flags, bool* useHWAA) {
+    return this->recordShape(kRect_ShapeType, rect, viewMatrix, color, localRect, antialias, flags,
+                             useHWAA);
+}
+
+GrDrawBatch* GrInstancedRendering::recordRect(const SkRect& rect, const SkMatrix& viewMatrix,
+                                              GrColor color, const SkMatrix& localMatrix,
+                                              bool antialias, uint32_t flags, bool* useHWAA) {
+    if (localMatrix.hasPerspective()) {
+        return nullptr; // Perspective is not yet supported in the local matrix.
+    }
+    if (Batch* batch = this->recordShape(kRect_ShapeType, rect, viewMatrix, color, rect, antialias,
+                                         flags, useHWAA)) {
+        fInstances.back().fInfo |= kLocalMatrix_InfoFlag;
+        this->appendParamsTexel(localMatrix.getScaleX(), localMatrix.getSkewX(),
+                                localMatrix.getTranslateX());
+        this->appendParamsTexel(localMatrix.getSkewY(), localMatrix.getScaleY(),
+                                localMatrix.getTranslateY());
+        batch->fTracker.fHasLocalMatrix = true;
+        batch->fTracker.fHasParams = true;
+        return batch;
+    }
+    return nullptr;
+}
+
+GrDrawBatch* GrInstancedRendering::recordOval(const SkRect& oval, const SkMatrix& viewMatrix,
+                                              GrColor color, bool antialias, uint32_t flags,
+                                              bool* useHWAA) {
+    return this->recordShape(kOval_ShapeType, oval, viewMatrix, color, oval, antialias, flags,
+                             useHWAA);
+}
+
+GrDrawBatch* GrInstancedRendering::recordRRect(const SkRRect& rrect, const SkMatrix& viewMatrix,
+                                               GrColor color, bool antialias, uint32_t flags,
+                                               bool* useHWAA) {
+    if (Batch* batch = this->recordShape(RRectShapeType(rrect), rrect.rect(), viewMatrix, color,
+                                         rrect.rect(), antialias, flags, useHWAA)) {
+        this->appendRRectParams(rrect, &batch->fTracker);
+        return batch;
+    }
+    return nullptr;
+}
+
+GrDrawBatch* GrInstancedRendering::recordDRRect(const SkRRect& outer, const SkRRect& inner,
+                                                const SkMatrix& viewMatrix, GrColor color,
+                                                bool antialias, uint32_t flags, bool* useHWAA) {
+    if (inner.getType() > SkRRect::kSimple_Type) {
+       return nullptr; // Complex inner round rects are not yet supported.
+    }
+    if (SkRRect::kEmpty_Type == inner.getType()) {
+        return this->recordRRect(outer, viewMatrix, color, antialias, flags, useHWAA);
+    }
+    if (Batch* batch = this->recordShape(RRectShapeType(outer), outer.rect(), viewMatrix, color,
+                                         outer.rect(), antialias, flags, useHWAA)) {
+        this->appendRRectParams(outer, &batch->fTracker);
+        ShapeType innerShapeType = RRectShapeType(inner);
+        batch->fTracker.fInnerShapeTypes |= (1 << innerShapeType);
+        fInstances.back().fInfo |= (innerShapeType << kInnerShapeType_InfoBit);
+        this->appendParamsTexel(inner.rect().asScalars(), 4);
+        this->appendRRectParams(inner, &batch->fTracker);
+        batch->fTracker.fHasParams = true;
+        return batch;
+    }
+    return nullptr;
+}
+
+GrInstancedRendering::Batch* GrInstancedRendering::recordShape(ShapeType type, const SkRect& bounds,
+                                                               const SkMatrix& viewMatrix,
+                                                               GrColor color,
+                                                               const SkRect& localRect,
+                                                               bool antialias, uint32_t flags,
+                                                               bool* useHWAA) {
+    SkASSERT(State::kRecordingShapes == fState);
+
+    uint32_t paramsIdx = fParams.count();
+    if (paramsIdx > kParamsIdx_InfoMask) {
+        return nullptr; // paramsIdx is too large for its allotted space.
+    }
+
+    AntialiasMode aa;
+    if (!this->selectAntialiasMode(viewMatrix, antialias, flags, &aa, useHWAA)) {
+        return nullptr;
+    }
+
+    Batch* batch = this->constructBatch(fBatchAllocator.push_back(), aa, fInstances.count());
+    SkASSERT(batch == fBatchAllocator.back()); // We rely on batch ptr equality with the allocator.
+    SkDEBUGCODE(++fInUseBatchCount;)
+    batch->fTracker.fShapeTypes |= (1 << type);
+    batch->fTracker.fCannotDiscard = !(flags & kUseDiscard_Flag);
+
+    Instance& instance = fInstances.push_back();
+    instance.fInfo = (type << kShapeType_InfoBit) | paramsIdx;
+
+    // The instanced shape renderer draws rectangles of [-1, -1, +1, +1], so we find the matrix that
+    // will map this rectangle to the same device coordinates as "viewMatrix * bounds".
+    float sx = 0.5f * bounds.width();
+    float sy = 0.5f * bounds.height();
+    float tx = sx + bounds.fLeft;
+    float ty = sy + bounds.fTop;
+    if (!viewMatrix.hasPerspective()) {
+        float* m = instance.fShapeMatrix2x3;
+        m[0] = viewMatrix.getScaleX() * sx;
+        m[1] = viewMatrix.getSkewX() * sy;
+        m[2] = viewMatrix.getTranslateX() +
+               viewMatrix.getScaleX() * tx + viewMatrix.getSkewX() * ty;
+
+        m[3] = viewMatrix.getSkewY() * sx;
+        m[4] = viewMatrix.getScaleY() * sy;
+        m[5] = viewMatrix.getTranslateY() +
+               viewMatrix.getSkewY() * tx + viewMatrix.getScaleY() * ty;
+
+        // Since 'm' is a 2x3 matrix that maps the rect [-1, +1] into the shape's device-space quad,
+        // it's quite simple to find the bounding rectangle:
+        float devBoundsHalfWidth = fabsf(m[0]) + fabsf(m[1]);
+        float devBoundsHalfHeight = fabsf(m[3]) + fabsf(m[4]);
+        batch->fBounds.fLeft = m[2] - devBoundsHalfWidth;
+        batch->fBounds.fRight = m[2] + devBoundsHalfWidth;
+        batch->fBounds.fTop = m[5] - devBoundsHalfHeight;
+        batch->fBounds.fBottom = m[5] + devBoundsHalfHeight;
+
+        // TODO: Is this worth the CPU overhead?
+        batch->fTracker.fNonSquare =
+            fabsf(devBoundsHalfHeight - devBoundsHalfWidth) > 0.5f || // Early out.
+            fabs(m[0] * m[3] + m[1] * m[4]) > 1e-3f || // Skew?
+            fabs(m[0] * m[0] + m[1] * m[1] - m[3] * m[3] - m[4] * m[4]) > 1e-2f; // Diff. lengths?
+    } else {
+        SkMatrix shapeMatrix(viewMatrix);
+        shapeMatrix.preTranslate(tx, ty);
+        shapeMatrix.preScale(sx, sy);
+        instance.fInfo |= kPerspective_InfoFlag;
+
+        float* m = instance.fShapeMatrix2x3;
+        m[0] = SkScalarToFloat(shapeMatrix.getScaleX());
+        m[1] = SkScalarToFloat(shapeMatrix.getSkewX());
+        m[2] = SkScalarToFloat(shapeMatrix.getTranslateX());
+        m[3] = SkScalarToFloat(shapeMatrix.getSkewY());
+        m[4] = SkScalarToFloat(shapeMatrix.getScaleY());
+        m[5] = SkScalarToFloat(shapeMatrix.getTranslateY());
+
+        // Send the perspective column as a param.
+        this->appendParamsTexel(shapeMatrix[SkMatrix::kMPersp0], shapeMatrix[SkMatrix::kMPersp1],
+                                shapeMatrix[SkMatrix::kMPersp2]);
+        batch->fTracker.fHasPerspective = true;
+        batch->fTracker.fHasParams = true;
+
+        viewMatrix.mapRect(&batch->fBounds, bounds);
+
+        batch->fTracker.fNonSquare = true;
+    }
+
+    instance.fColor = color;
+#if SK_SCALAR_IS_FLOAT

[bsalomon, 2016/04/25 13:22:38]

I'd just static assert that SkScalar is float here. Ganesh already does so in
many places and there will be no testing of the #else code.

[Chris Dalton, 2016/04/26 19:18:07]

Done. (SkScalar == double isn't on the table?)

[bsalomon, 2016/04/27 14:10:32]

It's on the table but there is no plan to tackle it in the next year. And if we
did it I think there would be lots of hard thinking about how to make Ganesh
work with doubles. Also, probably many of things that are currently SkScalar
would become explicit float. E.g., you want doubles for positions but maybe not
for fields of a color matrix.

+    const float* rectAsFloats = localRect.asScalars();
+    memcpy(&instance.fLocalRect, rectAsFloats, 4 * sizeof(float));
+#else
+    instance.fLocalRect[0] = SkScalarToFloat(localRect.left());
+    instance.fLocalRect[1] = SkScalarToFloat(localRect.top());
+    instance.fLocalRect[2] = SkScalarToFloat(localRect.right());
+    instance.fLocalRect[3] = SkScalarToFloat(localRect.bottom());
+#endif
+
+    return batch;
+}
+
+inline bool GrInstancedRendering::selectAntialiasMode(const SkMatrix& viewMatrix, bool antialias,
+                                                      uint32_t flags, AntialiasMode* antialiasMode,
+                                                      bool* useHWAA) {
+    SkASSERT(flags & (kColorWrite_Flag | kStencilWrite_Flag));
+    SkASSERT((flags & (kColorBufferMSAA_Flag | kStencilBufferMSAA_Flag)) != kColorBufferMSAA_Flag);
+
+    if (!antialias) {
+        if (!(fSupportedAAModes & kNone_AntialiasFlag)) {
+            return false;
+        }
+        if ((flags & (kStencilWrite_Flag | kUseDiscard_Flag)) == kStencilWrite_Flag) {
+            // We can only subtract coverage from the stencil output via discard when no MSAA.
+            return false;
+        }
+        *antialiasMode = kNone_AntialiasMode;
+        *useHWAA = false;
+        return true;
+    }
+
+    if (!(flags & (kColorBufferMSAA_Flag | kStencilWrite_Flag)) &&
+        viewMatrix.preservesRightAngles()) {
+        SkASSERT(fSupportedAAModes & kCoverage_AntialiasFlag);
+        *antialiasMode = kCoverage_AntialiasMode;
+        *useHWAA = false;
+        return true;
+    }
+
+    if ((fSupportedAAModes & kMSAA_AntialiasFlag) && (flags & kStencilBufferMSAA_Flag)) {
+        if ((flags ^ kColorWrite_Flag) & (kColorWrite_Flag | kColorBufferMSAA_Flag)) {
+            // We either do not write color, or the color buffer is multisampled.
+            *antialiasMode = kMSAA_AntialiasMode;
+            *useHWAA = true;
+            return true;
+        }
+        if (fSupportedAAModes & kMixedSamples_AntialiasFlag) {
+            *antialiasMode = kMixedSamples_AntialiasMode;
+            *useHWAA = true;
+            return true;
+        }
+    }
+
+    return false;
+}
+
+void GrInstancedRendering::appendRRectParams(const SkRRect& rrect, BatchTracker* tracker) {
+    switch (rrect.getType()) {
+        case SkRRect::kSimple_Type: {
+            const SkVector& radii = rrect.getSimpleRadii();
+            this->appendParamsTexel(radii.x(), radii.y(), rrect.width(), rrect.height());
+            tracker->fHasParams = true;
+            return;
+        }
+        case SkRRect::kNinePatch_Type: {
+            float twoOverW = 2 / rrect.width();
+            float twoOverH = 2 / rrect.height();
+            const SkVector& radiiTL = rrect.radii(SkRRect::kUpperLeft_Corner);
+            const SkVector& radiiBR = rrect.radii(SkRRect::kLowerRight_Corner);
+            this->appendParamsTexel(radiiTL.x() * twoOverW, radiiBR.x() * twoOverW,
+                                    radiiTL.y() * twoOverH, radiiBR.y() * twoOverH);
+            tracker->fHasParams = true;
+            return;
+        }
+        case SkRRect::kComplex_Type: {
+            /**
+             * The x and y radii of each arc are stored in separate vectors,
+             * in the following order:
+             *
+             *        __x1 _ _ _ x3__
+             *    y1 |               | y2
+             *
+             *       |               |
+             *
+             *    y3 |__   _ _ _   __| y4
+             *          x2       x4
+             *
+             */
+            float twoOverW = 2 / rrect.width();
+            float twoOverH = 2 / rrect.height();
+            const SkVector& radiiTL = rrect.radii(SkRRect::kUpperLeft_Corner);
+            const SkVector& radiiTR = rrect.radii(SkRRect::kUpperRight_Corner);
+            const SkVector& radiiBR = rrect.radii(SkRRect::kLowerRight_Corner);
+            const SkVector& radiiBL = rrect.radii(SkRRect::kLowerLeft_Corner);
+            this->appendParamsTexel(radiiTL.x() * twoOverW, radiiBL.x() * twoOverW,
+                                    radiiTR.x() * twoOverW, radiiBR.x() * twoOverW);
+            this->appendParamsTexel(radiiTL.y() * twoOverH, radiiTR.y() * twoOverH,
+                                    radiiBL.y() * twoOverH, radiiBR.y() * twoOverH);
+            tracker->fHasParams = true;
+            return;
+        }
+        default: return;
+    }
+}
+
+void GrInstancedRendering::appendParamsTexel(const SkScalar* vals, int count) {
+    SkASSERT(count <= 4 && count >= 0);
+#if SK_SCALAR_IS_FLOAT

[bsalomon, 2016/04/25 13:22:38]

ditto

[Chris Dalton, 2016/04/26 19:18:07]

Done.

+    const float* valsAsFloats = vals;
+    memcpy(&fParams.push_back(), valsAsFloats, count * sizeof(float));
+#else
+    float* params = fParams.push_back().fValues;
+    for (int i = 0; i < count; i++) {
+        params[i] = SkScalarToFloat(vals[i]);
+    }
+#endif
+}
+
+void GrInstancedRendering::appendParamsTexel(SkScalar x, SkScalar y, SkScalar z, SkScalar w) {
+    ParamsTexel& texel = fParams.push_back();
+    texel.fX = SkScalarToFloat(x);
+    texel.fY = SkScalarToFloat(y);
+    texel.fZ = SkScalarToFloat(z);
+    texel.fW = SkScalarToFloat(w);
+}
+
+void GrInstancedRendering::appendParamsTexel(SkScalar x, SkScalar y, SkScalar z) {
+    ParamsTexel& texel = fParams.push_back();
+    texel.fX = SkScalarToFloat(x);
+    texel.fY = SkScalarToFloat(y);
+    texel.fZ = SkScalarToFloat(z);
+}
+
+void GrInstancedRendering::Batch::computePipelineOptimizations(GrInitInvariantOutput* color,
+                                                            GrInitInvariantOutput* coverage,
+                                                            GrBatchToXPOverrides* overrides) const {
+    // We can't generally rely on fTracker here because it might change when batches get combined.

[bsalomon, 2016/04/25 13:22:38]

Isn't this always called before batches are combined, when installing the
pipeline object?

[Chris Dalton, 2016/04/25 17:01:19]

Yes, but for example a non-discarding non-AA draw can't make any conclusions
about coverage based on "fTracker.isSimpleRects()". Because it might get
combined later with an oval that actually needs to set coverage to zero on
certain pixels.

[Chris Dalton, 2016/04/26 19:18:07]

Done. (Made the comment better)

[bsalomon, 2016/04/27 14:10:32]

Ok, that makes it clearer.

+    color->setUnknownFourComponents();
+    if (fAntialiasMode >= kMSAA_AntialiasMode) {
+        coverage->setKnownSingleComponent(255);
+    } else if (kNone_AntialiasMode == fAntialiasMode && !fTracker.fCannotDiscard) {
+        // We can rely on fCannotDiscard because this particular field does not change.
+        coverage->setKnownSingleComponent(255);
+    } else {
+        coverage->setUnknownSingleComponent();
+    }
+}
+
+void GrInstancedRendering::Batch::initBatchTracker(const GrXPOverridesForBatch& overrides) {
+    fTracker.fUsesColor = overrides.readsColor();
+    fTracker.fUsesCoverage = overrides.readsCoverage();
+    fTracker.fUsesLocalCoords = overrides.readsLocalCoords();
+    fTracker.fCannotTweakAlphaForCoverage = !overrides.canTweakAlphaForCoverage();
+
+    GrColor overrideColor;
+    if (overrides.getOverrideColorIfSet(&overrideColor)) {
+        SkASSERT(State::kRecordingShapes == fInstancedRendering->fState);
+        SkASSERT(!fIsCombined);
+        fInstancedRendering->fInstances[fFirstInstanceIdx].fColor = overrideColor;
+    }
+}
+
+void GrInstancedRendering::commitToGpu(GrResourceProvider* rp) {
+    SkASSERT(State::kRecordingShapes == fState);
+    fState = State::kDrawingBatches;
+
+    if (fInstances.empty()) {
+        return;
+    }
+
+    if (!fVertexBuffer) {
+        fVertexBuffer.reset(GrInstanceProcessor::FindOrCreateVertexBuffer(fGpu));
+        if (!fVertexBuffer) {
+            return;
+        }
+    }
+
+    if (!fIndexBuffer) {
+        fIndexBuffer.reset(GrInstanceProcessor::FindOrCreateIndex8Buffer(fGpu));
+        if (!fIndexBuffer) {
+            return;
+        }
+    }
+
+    fInstanceBuffer.reset(rp->createBuffer(fInstances.count() * sizeof(Instance),
+                                           kVertex_GrBufferType, kDynamic_GrAccessPattern,
+                                           GrResourceProvider::kNoPendingIO_Flag,
+                                           fInstances.begin()));
+    if (!fInstanceBuffer) {
+        return;
+    }
+
+    if (!fParams.empty()) {
+        fParamsBuffer.reset(rp->createBuffer(fParams.count() * sizeof(ParamsTexel),
+                                             kTexel_GrBufferType, kDynamic_GrAccessPattern,
+                                             GrResourceProvider::kNoPendingIO_Flag,
+                                             fParams.begin()));
+        if (!fParamsBuffer) {
+            return;
+        }
+    }
+
+    this->onCommitToGpu(rp);
+}
+
+void GrInstancedRendering::Batch::onDraw(GrBatchFlushState* state) {
+    SkASSERT(State::kDrawingBatches == fInstancedRendering->fState);
+    SkASSERT(state->gpu() == fInstancedRendering->gpu());
+
+    GrInstanceProcessor instProc(fTracker, fInstancedRendering->fParamsBuffer, fAntialiasMode);
+    fInstancedRendering->onDraw(*this->pipeline(), instProc, this);
+}
+
+void GrInstancedRendering::Batch::onDelete() const {

[bsalomon, 2016/04/25 13:22:38]

Is it really necessary to you your own custom allocator for these batches? It
seems like an unfortunate complication. GrBatches already live in block
allocated memory.

[Chris Dalton, 2016/04/25 17:01:19]

Oh really? How long have they lived in block allocated memory?

But it really is necessary for this class to keep track of all the batches it
has created. Take a look at GrGLInstancedRendering::onCommitToGpu. It loops
through all the batches in fBatchAllocator in order to generate the draw
indirect buffer for the flush.

Also, for now we just dump the instance data linearly into a buffer. But if we
want to make this work without EXT_base_instance, we will need to similarly
defer the instance buffer generation until commitToGpu (after all combining has
occurred). 

And as we start putting more data in the texel buffer (coord transforms for
starters, basic uniforms, clip planes) we will also need to defer the texel
buffer generation until commitToGpu.

[Chris Dalton, 2016/04/26 19:18:07]

Added a comment to the BatchAllocator class in GrInstancedRendering.h

[bsalomon, 2016/04/27 14:10:32]

Until they're unreffed (at the end of GrDT flush). blocks are freed after all
the batches have been freed.
But isn't there a difference between "keeping track of" and allocating? Would it
hurt to keep an array of ptrs rather than own the storage?

[csmartdalton, 2016/05/20 01:09:45]

The main advantage to owning is that you know when a batch is deleted and
therefore no longer in use. We could do it with pointers too, but in order to
know if a batch is still in use then we might need to peek at the ref count and
see if it's >1 (assuming one of the refs comes from us.)

I can see it working, but I'm not sure I understand the advantage in complexity
of an array of ref'd pointers vs an array of structs. Is your main beef the
special handling when the ref count reaches zero?

[bsalomon, 2016/05/20 14:04:48]

There is no reason we couldn't have the instanced batch subclass call a function
on the GrInstancedRendering when it is destroyed, perhaps conveying its index
into the batches that the GrIR is keeping track of. 
It just seems like we're deploying a heavier hammer than is necessary here in
ways that aren't limited in scope to GrIR and GrIR::Batch. We're block
allocating an already block allocated type, adding a onDelete to the base class,
and adding a GrTDeleteNonAtomicRef overload [batches will likely not derive from
GrNonAtomicRef in the future]. AIUI GrIR just needs to be able to iterate over
its batches and know when they're deleted. It seems doable by having GrIR have
non-ref'ed ptrs and having a notification call back in GrIR:Batch::~Batch to let
GrIR know the instance is deleted.

What exactly is the notification requirement? Is it to handle batch combining in
GrDT? Otherwise it seems like any batch added to a GrDT must survive until the
flush.

[csmartdalton, 2016/05/21 06:54:24]

OK, I like that idea.
Correct, it's just for when a batch gets combined into a previous one.

[bsalomon, 2016/05/23 14:05:43]

Cool, I suppose the notification could happen from the merge? I don't know which
makes more sense.

+    this->~Batch();
+    SkDEBUGCODE(--fInstancedRendering->fInUseBatchCount);
+    if (this == fInstancedRendering->fBatchAllocator.back()) {
+        fInstancedRendering->fBatchAllocator.pop_back();
+    }
+}
+
+void GrInstancedRendering::restart() {
+    SkASSERT(0 == fInUseBatchCount);
+    fBatchAllocator.reset();
+    // Hold on to the shape coords and index buffers.
+    fInstances.reset();
+    fParams.reset();
+    fInstanceBuffer.reset();
+    fParamsBuffer.reset();
+    this->onRestart();
+    fState = State::kRecordingShapes;
+}
+
+void GrInstancedRendering::clearGpuResources(ClearType clearType) {
+    fVertexBuffer.reset();
+    fIndexBuffer.reset();
+    fInstanceBuffer.reset();
+    fParamsBuffer.reset();
+    this->onClearGpuResources(clearType);
+}