Implement instanced rendering for simple shapes

src/gpu/GrDrawContext.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrBatchTest.h"
 #include "GrColor.h"
 #include "GrDrawContext.h"
 #include "GrDrawContextPriv.h"
 #include "GrDrawingManager.h"
 #include "GrOvalRenderer.h"
 #include "GrPathRenderer.h"
 #include "GrRenderTarget.h"
 #include "GrRenderTargetPriv.h"
 #include "GrResourceProvider.h"
+#include "GrInstancedRendering.h"
 #include "SkSurfacePriv.h"
 
 #include "batches/GrBatch.h"
 #include "batches/GrDrawAtlasBatch.h"
 #include "batches/GrDrawVerticesBatch.h"
 #include "batches/GrRectBatchFactory.h"
 #include "batches/GrNinePatch.h" // TODO Factory
 
 #include "effects/GrRRectEffect.h"
 
@@ skipping 36 matching lines @@
     : fDrawingManager(drawingMgr)
     , fRenderTarget(rt)
     , fDrawTarget(SkSafeRef(rt->getLastDrawTarget()))
     , fContext(context)
     , fSurfaceProps(SkSurfacePropsCopyOrDefault(surfaceProps))
     , fAuditTrail(auditTrail)
 #ifdef SK_DEBUG
     , fSingleOwner(singleOwner)
 #endif
 {
+    fInstancedRenderingFlags = GrInstancedRendering::kColorWrite_Flag;
+    if (fRenderTarget->isStencilBufferMultisampled()) {
+        fInstancedRenderingFlags |= GrInstancedRendering::kStencilBufferMSAA_Flag;
+    }
+    if (fRenderTarget->isUnifiedMultisampled()) {
+        fInstancedRenderingFlags |= GrInstancedRendering::kColorBufferMSAA_Flag;
+    }
     SkDEBUGCODE(this->validate();)
 }
 
 #ifdef SK_DEBUG
 void GrDrawContext::validate() const {
     SkASSERT(fRenderTarget);
     ASSERT_OWNED_RESOURCE(fRenderTarget);
 
     if (fDrawTarget && !fDrawTarget->isClosed()) {
         SkASSERT(fRenderTarget->getLastDrawTarget() == fDrawTarget);
@@ skipping 164 matching lines @@
 static bool view_matrix_ok_for_aa_fill_rect(const SkMatrix& viewMatrix) {
     return viewMatrix.preservesRightAngles();
 }
 
 static bool should_apply_coverage_aa(const GrPaint& paint, GrRenderTarget* rt) {
     return paint.isAntiAlias() && !rt->isUnifiedMultisampled();
 }
 
 GrDrawBatch* GrDrawContext::getFillRectBatch(const GrPaint& paint,
                                              const SkMatrix& viewMatrix,
-                                             const SkRect& rect) {
-
-    GrDrawBatch* batch = nullptr;
+                                             const SkRect& rect,
+                                             uint32_t extraInstRenderFlags,
+                                             bool* requireHWAA) {
+    if (GrInstancedRendering* ir = this->getDrawTarget()->instancedRendering()) {
+        if (GrDrawBatch* batch = ir->recordRect(rect, viewMatrix, paint.getColor(),
+                                                paint.isAntiAlias(),
+                                                fInstancedRenderingFlags | extraInstRenderFlags,
+                                                requireHWAA)) {
+            return batch;
+        }
+    }
     if (should_apply_coverage_aa(paint, fRenderTarget)) {
         // The fill path can handle rotation but not skew.
         if (view_matrix_ok_for_aa_fill_rect(viewMatrix)) {
             SkRect devBoundRect;
             viewMatrix.mapRect(&devBoundRect, rect);
-            batch = GrRectBatchFactory::CreateAAFill(paint.getColor(), viewMatrix,
-                                                     rect, devBoundRect);
+            return GrRectBatchFactory::CreateAAFill(paint.getColor(), viewMatrix, rect,
+                                                    devBoundRect);
         }
     } else {
         // filled BW rect
-        batch = GrRectBatchFactory::CreateNonAAFill(paint.getColor(), viewMatrix, rect,
-                                                    nullptr, nullptr);
+        return GrRectBatchFactory::CreateNonAAFill(paint.getColor(), viewMatrix, rect, nullptr,
+                                                   nullptr);
     }
 
-    return batch;
+    return nullptr;
 }
 
 void GrDrawContext::drawRect(const GrClip& clip,
                              const GrPaint& paint,
                              const SkMatrix& viewMatrix,
                              const SkRect& rect,
                              const GrStrokeInfo* strokeInfo) {
     ASSERT_SINGLE_OWNER
     RETURN_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
@@ skipping 34 matching lines @@
                 GrColor clearColor;
                 if (paint.isConstantBlendedColor(&clearColor)) {
                     this->getDrawTarget()->clear(nullptr, clearColor, true, fRenderTarget);
                     return;
                 }
             }
         }
     }
 
     bool snapToPixelCenters = false;
+    bool requireHWAA = false;
     SkAutoTUnref<GrDrawBatch> batch;
     if (width < 0) {
-        batch.reset(this->getFillRectBatch(paint, viewMatrix, rect));
+        batch.reset(this->getFillRectBatch(paint, viewMatrix, rect, 0, &requireHWAA));
     } else {
         GrColor color = paint.getColor();
 
         if (should_apply_coverage_aa(paint, fRenderTarget)) {
             // The stroke path needs the rect to remain axis aligned (no rotation or skew).
             if (viewMatrix.rectStaysRect()) {
                 batch.reset(GrRectBatchFactory::CreateAAStroke(color, viewMatrix, rect,
                                                                *strokeInfo));
             }
         } else {
             // Non-AA hairlines are snapped to pixel centers to make which pixels are hit
             // deterministic
             snapToPixelCenters = (0 == width && !fRenderTarget->isUnifiedMultisampled());
             batch.reset(GrRectBatchFactory::CreateNonAAStroke(color, viewMatrix, rect,
                                                               width, snapToPixelCenters));
 
             // Depending on sub-pixel coordinates and the particular GPU, we may lose a corner of
             // hairline rects. We jam all the vertices to pixel centers to avoid this, but not
             // when MSAA is enabled because it can cause ugly artifacts.
         }
     }
 
     if (batch) {
-        GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
+        GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip, requireHWAA);
 
         if (snapToPixelCenters) {
             pipelineBuilder.setState(GrPipelineBuilder::kSnapVerticesToPixelCenters_Flag,
                                      snapToPixelCenters);
         }
 
         this->getDrawTarget()->drawBatch(pipelineBuilder, batch);
         return;
     }
 
@@ skipping 15 matching lines @@
     RETURN_FALSE_IF_ABANDONED_PRIV
     SkDEBUGCODE(fDrawContext->validate();)
     GR_AUDIT_TRAIL_AUTO_FRAME(fDrawContext->fAuditTrail, "GrDrawContext::stencilRect");
 
     AutoCheckFlush acf(fDrawContext->fDrawingManager);
 
     GrPaint paint;
     paint.setAntiAlias(doAA);
     paint.setCoverageSetOpXPFactory(op, invert);
 
-    SkAutoTUnref<GrDrawBatch> batch(fDrawContext->getFillRectBatch(paint, viewMatrix, rect));
+    bool requireHWAA = false;
+    SkAutoTUnref<GrDrawBatch> batch(
+        fDrawContext->getFillRectBatch(paint, viewMatrix, rect,
+                                       GrInstancedRendering::kStencilWrite_Flag, &requireHWAA));
     if (batch) {
-        GrPipelineBuilder pipelineBuilder(paint, fDrawContext->fRenderTarget, GrClip::WideOpen());
+        GrPipelineBuilder pipelineBuilder(paint, fDrawContext->fRenderTarget, GrClip::WideOpen(),
+                                          requireHWAA);
         pipelineBuilder.setStencil(ss);
 
         fDrawContext->getDrawTarget()->drawBatch(pipelineBuilder, batch, scissorRect);
         return true;
     }
 
     SkPath path;
     path.setIsVolatile(true);
     path.addRect(rect);
     return this->drawAndStencilPath(scissorRect, ss, op, invert, doAA, viewMatrix, path);
 }
 
 void GrDrawContext::fillRectToRect(const GrClip& clip,
                                    const GrPaint& paint,
                                    const SkMatrix& viewMatrix,
                                    const SkRect& rectToDraw,
                                    const SkRect& localRect) {
     ASSERT_SINGLE_OWNER
     RETURN_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
     GR_AUDIT_TRAIL_AUTO_FRAME(fAuditTrail, "GrDrawContext::fillRectToRect");
 
     AutoCheckFlush acf(fDrawingManager);
 
     SkAutoTUnref<GrDrawBatch> batch;
+    if (GrInstancedRendering* ir = this->getDrawTarget()->instancedRendering()) {
+        bool requireHWAA = false;
+        batch.reset(ir->recordRect(rectToDraw, viewMatrix, paint.getColor(), localRect,
+                                   paint.isAntiAlias(), fInstancedRenderingFlags, &requireHWAA));
+        if (batch) {
+            GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip, requireHWAA);
+            this->drawBatch(&pipelineBuilder, batch);
+            return;
+        }
+    }
+
     if (should_apply_coverage_aa(paint, fRenderTarget) &&
         view_matrix_ok_for_aa_fill_rect(viewMatrix)) {
         batch.reset(GrAAFillRectBatch::CreateWithLocalRect(paint.getColor(), viewMatrix, rectToDraw,
                                                            localRect));
     } else {
         batch.reset(GrRectBatchFactory::CreateNonAAFill(paint.getColor(), viewMatrix, rectToDraw,
                                                         &localRect, nullptr));
     }
 
     if (batch) {
         GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
         this->drawBatch(&pipelineBuilder, batch);
     }
 }
 
 void GrDrawContext::fillRectWithLocalMatrix(const GrClip& clip,
                                             const GrPaint& paint,
                                             const SkMatrix& viewMatrix,
                                             const SkRect& rectToDraw,
                                             const SkMatrix& localMatrix) {
     ASSERT_SINGLE_OWNER
     RETURN_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
     GR_AUDIT_TRAIL_AUTO_FRAME(fAuditTrail, "GrDrawContext::fillRectWithLocalMatrix");
 
     AutoCheckFlush acf(fDrawingManager);
 
     SkAutoTUnref<GrDrawBatch> batch;
+    if (GrInstancedRendering* ir = this->getDrawTarget()->instancedRendering()) {
+        bool requireHWAA = false;
+        batch.reset(ir->recordRect(rectToDraw, viewMatrix, paint.getColor(), localMatrix,
+                                   paint.isAntiAlias(), fInstancedRenderingFlags, &requireHWAA));
+        if (batch) {
+            GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip, requireHWAA);
+            this->drawBatch(&pipelineBuilder, batch);
+            return;
+        }
+    }
+
     if (should_apply_coverage_aa(paint, fRenderTarget) &&
         view_matrix_ok_for_aa_fill_rect(viewMatrix)) {
         batch.reset(GrAAFillRectBatch::Create(paint.getColor(), viewMatrix, localMatrix,
                                               rectToDraw));
     } else {
         batch.reset(GrRectBatchFactory::CreateNonAAFill(paint.getColor(), viewMatrix, rectToDraw,
                                                         nullptr, &localMatrix));
     }
 
     GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
@@ skipping 83 matching lines @@
     GR_AUDIT_TRAIL_AUTO_FRAME(fAuditTrail, "GrDrawContext::drawRRect");
 
     if (rrect.isEmpty()) {
        return;
     }
 
     SkASSERT(!strokeInfo.isDashed()); // this should've been devolved to a path in SkGpuDevice
 
     AutoCheckFlush acf(fDrawingManager);
 
+    if (this->getDrawTarget()->instancedRendering() && strokeInfo.isFillStyle()) {
+        GrInstancedRendering* ir = this->getDrawTarget()->instancedRendering();
+        bool requireHWAA = false;
+        SkAutoTUnref<GrDrawBatch> batch(ir->recordRRect(rrect, viewMatrix, paint.getColor(),
+                                                        paint.isAntiAlias(),
+                                                        fInstancedRenderingFlags, &requireHWAA));
+        if (batch) {
+            GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip, requireHWAA);
+            this->drawBatch(&pipelineBuilder, batch);
+            return;
+        }
+    }
+
     if (should_apply_coverage_aa(paint, fRenderTarget)) {
         GrShaderCaps* shaderCaps = fContext->caps()->shaderCaps();
 
         SkAutoTUnref<GrDrawBatch> batch(GrOvalRenderer::CreateRRectBatch(paint.getColor(),
                                                                          viewMatrix,
                                                                          rrect,
                                                                          strokeInfo,
                                                                          shaderCaps));
         if (batch) {
             GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
             this->getDrawTarget()->drawBatch(pipelineBuilder, batch);
             return;
         }
     }
 
     SkPath path;
     path.setIsVolatile(true);
     path.addRRect(rrect);
     this->internalDrawPath(clip, paint, viewMatrix, path, strokeInfo);
 }
 
 bool GrDrawContext::drawFilledDRRect(const GrClip& clip,
                                      const GrPaint& paintIn,
                                      const SkMatrix& viewMatrix,
                                      const SkRRect& origOuter,
                                      const SkRRect& origInner) {
     SkASSERT(!origInner.isEmpty());
     SkASSERT(!origOuter.isEmpty());
 
+    if (GrInstancedRendering* ir = this->getDrawTarget()->instancedRendering()) {
+        bool requireHWAA = false;
+        SkAutoTUnref<GrDrawBatch> batch(ir->recordDRRect(origOuter, origInner, viewMatrix,
+                                                         paintIn.getColor(), paintIn.isAntiAlias(),
+                                                         fInstancedRenderingFlags, &requireHWAA));
+        if (batch) {
+            GrPipelineBuilder pipelineBuilder(paintIn, fRenderTarget, clip, requireHWAA);
+            this->drawBatch(&pipelineBuilder, batch);
+            return true;
+        }
+    }
+
     bool applyAA = paintIn.isAntiAlias() && !fRenderTarget->isUnifiedMultisampled();
 
     GrPrimitiveEdgeType innerEdgeType = applyAA ? kInverseFillAA_GrProcessorEdgeType :
                                                   kInverseFillBW_GrProcessorEdgeType;
     GrPrimitiveEdgeType outerEdgeType = applyAA ? kFillAA_GrProcessorEdgeType :
                                                   kFillBW_GrProcessorEdgeType;
 
     SkTCopyOnFirstWrite<SkRRect> inner(origInner), outer(origOuter);
     SkMatrix inverseVM;
     if (!viewMatrix.isIdentity()) {
@@ skipping 78 matching lines @@
     GR_AUDIT_TRAIL_AUTO_FRAME(fAuditTrail, "GrDrawContext::drawOval");
 
     if (oval.isEmpty()) {
        return;
     }
 
     SkASSERT(!strokeInfo.isDashed()); // this should've been devolved to a path in SkGpuDevice
 
     AutoCheckFlush acf(fDrawingManager);
 
+    if (this->getDrawTarget()->instancedRendering() && strokeInfo.isFillStyle()) {
+        GrInstancedRendering* ir = this->getDrawTarget()->instancedRendering();
+        bool requireHWAA = false;
+        SkAutoTUnref<GrDrawBatch> batch(ir->recordOval(oval, viewMatrix, paint.getColor(),
+                                                       paint.isAntiAlias(),
+                                                       fInstancedRenderingFlags, &requireHWAA));
+        if (batch) {
+            GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip, requireHWAA);
+            this->drawBatch(&pipelineBuilder, batch);
+            return;
+        }
+    }
+
     if (should_apply_coverage_aa(paint, fRenderTarget)) {
         GrShaderCaps* shaderCaps = fContext->caps()->shaderCaps();
         SkAutoTUnref<GrDrawBatch> batch(GrOvalRenderer::CreateOvalBatch(paint.getColor(),
                                                                         viewMatrix,
                                                                         oval,
                                                                         strokeInfo,
                                                                         shaderCaps));
         if (batch) {
             GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
             this->getDrawTarget()->drawBatch(pipelineBuilder, batch);
@@ skipping 343 matching lines @@
 }
 
 void GrDrawContext::drawBatch(GrPipelineBuilder* pipelineBuilder, GrDrawBatch* batch) {
     ASSERT_SINGLE_OWNER
     RETURN_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
     GR_AUDIT_TRAIL_AUTO_FRAME(fAuditTrail, "GrDrawContext::drawBatch");
 
     this->getDrawTarget()->drawBatch(*pipelineBuilder, batch);
 }