Implement instanced rendering for simple shapes

src/gpu/GrClipMaskManager.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrClipMaskManager.h"
 #include "GrCaps.h"
 #include "GrDrawingManager.h"
 #include "GrDrawContextPriv.h"
 #include "GrDrawTarget.h"
 #include "GrGpuResourcePriv.h"
 #include "GrPaint.h"
 #include "GrPathRenderer.h"
 #include "GrRenderTarget.h"
 #include "GrRenderTargetPriv.h"
 #include "GrResourceProvider.h"
+#include "GrInstancedRendering.h"
 #include "GrStencilAttachment.h"
 #include "GrSWMaskHelper.h"
 #include "SkRasterClip.h"
 #include "SkTLazy.h"
 #include "batches/GrRectBatchFactory.h"
 #include "effects/GrConvexPolyEffect.h"
 #include "effects/GrPorterDuffXferProcessor.h"
 #include "effects/GrRRectEffect.h"
 #include "effects/GrTextureDomain.h"
 
@@ skipping 12 matching lines @@
 
     SkIRect domainTexels = SkIRect::MakeWH(devBound.width(), devBound.height());
     return GrTextureDomainEffect::Create(result,
                                          mat,
                                          GrTextureDomain::MakeTexelDomain(result, domainTexels),
                                          GrTextureDomain::kDecal_Mode,
                                          GrTextureParams::kNone_FilterMode,
                                          kDevice_GrCoordSet);
 }
 
-static void draw_non_aa_rect(GrDrawTarget* drawTarget,
-                             const GrPipelineBuilder& pipelineBuilder,
-                             GrColor color,
-                             const SkMatrix& viewMatrix,
-                             const SkRect& rect) {
-    SkAutoTUnref<GrDrawBatch> batch(GrRectBatchFactory::CreateNonAAFill(color, viewMatrix, rect,
-                                                                        nullptr, nullptr));
-    drawTarget->drawBatch(pipelineBuilder, batch);
-}
-
 // Does the path in 'element' require SW rendering? If so, return true (and,
 // optionally, set 'prOut' to NULL. If not, return false (and, optionally, set
 // 'prOut' to the non-SW path renderer that will do the job).
 bool GrClipMaskManager::PathNeedsSWRenderer(GrContext* context,
                                             bool isStencilDisabled,
                                             const GrRenderTarget* rt,
                                             const SkMatrix& viewMatrix,
                                             const Element* element,
                                             GrPathRenderer** prOut,
                                             bool needsStencil) {
@@ skipping 676 matching lines @@
         stencilSpaceIBounds.offset(clipSpaceToStencilOffset);
         GrClip clip(stencilSpaceIBounds);
 
         int clipBit = stencilAttachment->bits();
         SkASSERT((clipBit <= 16) && "Ganesh only handles 16b or smaller stencil buffers");
         clipBit = (1 << (clipBit-1));
 
         fDrawTarget->cmmAccess().clearStencilClip(stencilSpaceIBounds,
             GrReducedClip::kAllIn_InitialState == initialState, rt);
 
+        GrInstancedRendering* instRendering = fDrawTarget->instancedRendering();
+        uint32_t instRenderingFlags;
+        if (instRendering) {
+            instRenderingFlags = GrInstancedRendering::kStencilWrite_Flag |
+                                 GrInstancedRendering::kCanDiscardFragments_Flag;
+            if (rt->isStencilBufferMultisampled()) {
+                instRenderingFlags |= GrInstancedRendering::kStencilBufferMSAA_Flag;
+            }
+        }
+
         // walk through each clip element and perform its set op
         // with the existing clip.
         for (GrReducedClip::ElementList::Iter iter(elements.headIter()); iter.get(); iter.next()) {
             const Element* element = iter.get();
 
             GrPipelineBuilder pipelineBuilder;
             pipelineBuilder.setClip(clip);
             pipelineBuilder.setRenderTarget(rt);
 
             pipelineBuilder.setDisableColorXPFactory();
 
             // if the target is MSAA then we want MSAA enabled when the clip is soft
             if (rt->isStencilBufferMultisampled()) {
                 pipelineBuilder.setState(GrPipelineBuilder::kHWAntialias_Flag, element->isAA());
             }
 
             bool fillInverted = false;
             // enabled at bottom of loop
             fClipMode = kIgnoreClip_StencilClipMode;
 
             // This will be used to determine whether the clip shape can be rendered into the
             // stencil with arbitrary stencil settings.
             GrPathRenderer::StencilSupport stencilSupport;
 
             GrStrokeInfo stroke(SkStrokeRec::kFill_InitStyle);
             SkRegion::Op op = element->getOp();
 
+            SkAutoTUnref<GrDrawBatch> fastBatch;
+            if (Element::kPath_Type != element->getType()) {
+                if (instRendering) {
+                    fastBatch.reset(instRendering->recordRRect(element->asRRect(), viewMatrix,
+                                                               GrColor_WHITE,
+                                                               pipelineBuilder.isHWAntialias(),
+                                                               instRenderingFlags));
+                }
+                if (!fastBatch && Element::kRect_Type == element->getType()) {
+                    fastBatch.reset(GrRectBatchFactory::CreateNonAAFill(GrColor_WHITE, viewMatrix,
+                                                                        element->getRect(), nullptr,
+                                                                        nullptr));
+                }
+            }
+
             GrPathRenderer* pr = nullptr;
             SkPath clipPath;
-            if (Element::kRect_Type == element->getType()) {
+            if (fastBatch) {
                 stencilSupport = GrPathRenderer::kNoRestriction_StencilSupport;
                 fillInverted = false;
             } else {
                 element->asPath(&clipPath);
                 fillInverted = clipPath.isInverseFillType();
                 if (fillInverted) {
                     clipPath.toggleInverseFillType();
                 }
 
                 SkASSERT(pipelineBuilder.getStencil().isDisabled());
@@ skipping 33 matching lines @@
 
             // draw the element to the client stencil bits if necessary
             if (!canDrawDirectToClip) {
                 GR_STATIC_CONST_SAME_STENCIL(gDrawToStencil,
                                              kIncClamp_StencilOp,
                                              kIncClamp_StencilOp,
                                              kAlways_StencilFunc,
                                              0xffff,
                                              0x0000,
                                              0xffff);
-                if (Element::kRect_Type == element->getType()) {
+                if (fastBatch) {
                     *pipelineBuilder.stencil() = gDrawToStencil;
-
-                    draw_non_aa_rect(fDrawTarget, pipelineBuilder, GrColor_WHITE, viewMatrix,
-                                     element->getRect());
+                    fDrawTarget->drawBatch(pipelineBuilder, fastBatch);
                 } else {
                     if (!clipPath.isEmpty()) {
                         if (canRenderDirectToStencil) {
                             *pipelineBuilder.stencil() = gDrawToStencil;
 
                             GrPathRenderer::DrawPathArgs args;
                             args.fTarget = fDrawTarget;
                             args.fResourceProvider = this->getContext()->resourceProvider();
                             args.fPipelineBuilder = &pipelineBuilder;
                             args.fColor = GrColor_WHITE;
@@ skipping 17 matching lines @@
                 }
             }
 
             // now we modify the clip bit by rendering either the clip
             // element directly or a bounding rect of the entire clip.
             fClipMode = kModifyClip_StencilClipMode;
             for (int p = 0; p < passes; ++p) {
                 *pipelineBuilder.stencil() = stencilSettings[p];
 
                 if (canDrawDirectToClip) {
-                    if (Element::kRect_Type == element->getType()) {
-                        draw_non_aa_rect(fDrawTarget, pipelineBuilder, GrColor_WHITE, viewMatrix,
-                                         element->getRect());
+                    if (fastBatch) {
+                        fDrawTarget->drawBatch(pipelineBuilder, fastBatch);
                     } else {
                         GrPathRenderer::DrawPathArgs args;
                         args.fTarget = fDrawTarget;
                         args.fResourceProvider = this->getContext()->resourceProvider();
                         args.fPipelineBuilder = &pipelineBuilder;
                         args.fColor = GrColor_WHITE;
                         args.fViewMatrix = &viewMatrix;
                         args.fPath = &clipPath;
                         args.fStroke = &stroke;
                         args.fAntiAlias = false;
                         args.fGammaCorrect = false;
                         pr->drawPath(args);
                     }
                 } else {
                     // The view matrix is setup to do clip space -> stencil space translation, so
                     // draw rect in clip space.
-                    draw_non_aa_rect(fDrawTarget, pipelineBuilder, GrColor_WHITE, viewMatrix,
-                                     SkRect::Make(clipSpaceIBounds));
+                    const SkRect& clipSpaceRect = SkRect::Make(clipSpaceIBounds);
+                    SkAutoTUnref<GrDrawBatch> coverBatch;
+                    if (instRendering) {
+                        coverBatch.reset(instRendering->recordRect(clipSpaceRect, viewMatrix,
+                                                                   GrColor_WHITE,
+                                                                   pipelineBuilder.isHWAntialias(),
+                                                                   instRenderingFlags));
+                    }
+                    if (!coverBatch) {
+                        coverBatch.reset(GrRectBatchFactory::CreateNonAAFill(GrColor_WHITE,
+                                                                             viewMatrix,
+                                                                             clipSpaceRect,
+                                                                             nullptr, nullptr));
+                    }
+                    fDrawTarget->drawBatch(pipelineBuilder, coverBatch);
                 }
             }
         }
     }
     fClipMode = kRespectClip_StencilClipMode;
     return true;
 }
 
 // mapping of clip-respecting stencil funcs to normal stencil funcs
 // mapping depends on whether stencil-clipping is in effect.
@@ skipping 243 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 
 void GrClipMaskManager::adjustPathStencilParams(const GrStencilAttachment* stencilAttachment,
                                                 GrStencilSettings* settings) {
     if (stencilAttachment) {
         int stencilBits = stencilAttachment->bits();
         this->adjustStencilParams(settings, fClipMode, stencilBits);
     }
 }