Enable blend optimizations with instanced draws

src/gpu/instanced/InstanceProcessor.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 "InstanceProcessor.h"
 
 #include "GrContext.h"
@@ skipping 123 matching lines @@
     }
 
 private:
     const InstanceProcessor&     fInstProc;
     GrGLSLVertexBuilder*         fVertexBuilder;
     SamplerHandle                fParamsBuffer;
 };
 
 class GLSLInstanceProcessor::Backend {
 public:
-    static Backend* SK_WARN_UNUSED_RESULT Create(const GrGLSLProgramBuilder*, BatchInfo,
-                                                 const VertexInputs&);
+    static Backend* SK_WARN_UNUSED_RESULT Create(const GrPipeline&, BatchInfo, const VertexInputs&);
     virtual ~Backend() {}
 
     void init(GrGLSLVaryingHandler*, GrGLSLVertexBuilder*);
     virtual void setupRect(GrGLSLVertexBuilder*) = 0;
     virtual void setupOval(GrGLSLVertexBuilder*) = 0;
     void setupRRect(GrGLSLVertexBuilder*);
 
     void initInnerShape(GrGLSLVaryingHandler*, GrGLSLVertexBuilder*);
     virtual void setupInnerRect(GrGLSLVertexBuilder*) = 0;
     virtual void setupInnerOval(GrGLSLVertexBuilder*) = 0;
@@ skipping 45 matching lines @@
     bool                  fNeedsNeighborRadii;
     GrGLSLVertToFrag      fColor;
     GrGLSLVertToFrag      fTriangleIsArc;
     GrGLSLVertToFrag      fArcCoords;
     GrGLSLVertToFrag      fInnerShapeCoords;
     GrGLSLVertToFrag      fInnerRRect;
     const char*           fModifiedShapeCoords;
 };
 
 void GLSLInstanceProcessor::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) {
+    const GrPipeline& pipeline = args.fVertBuilder->getProgramBuilder()->pipeline();
     const InstanceProcessor& ip = args.fGP.cast<InstanceProcessor>();
     GrGLSLUniformHandler* uniHandler = args.fUniformHandler;
     GrGLSLVaryingHandler* varyingHandler = args.fVaryingHandler;
     GrGLSLVertexBuilder* v = args.fVertBuilder;
     GrGLSLPPFragmentBuilder* f = args.fFragBuilder;
 
     varyingHandler->emitAttributes(ip);
 
     VertexInputs inputs(ip, v);
     if (ip.batchInfo().fHasParams) {
@@ skipping 19 matching lines @@
     int usedShapeTypes = 0;
 
     bool hasSingleShapeType = SkIsPow2(ip.batchInfo().fShapeTypes);
     if (!hasSingleShapeType) {
         usedShapeTypes |= ip.batchInfo().fShapeTypes;
         v->define("SHAPE_TYPE_BIT", kShapeType_InfoBit);
         v->codeAppendf("uint shapeType = %s >> SHAPE_TYPE_BIT;",
                        inputs.attr(Attrib::kInstanceInfo));
     }
 
-    SkAutoTDelete<Backend> backend(Backend::Create(v->getProgramBuilder(), ip.batchInfo(), inputs));
+    SkAutoTDelete<Backend> backend(Backend::Create(pipeline, ip.batchInfo(), inputs));
     backend->init(varyingHandler, v);
 
     if (hasSingleShapeType) {
         if (kRect_ShapeFlag == ip.batchInfo().fShapeTypes) {
             backend->setupRect(v);
         } else if (kOval_ShapeFlag == ip.batchInfo().fShapeTypes) {
             backend->setupOval(v);
         } else {
             backend->setupRRect(v);
         }
@@ skipping 71 matching lines @@
         }
     }
 
     if (usedShapeTypes & kRect_ShapeFlag) {
         v->definef("RECT_SHAPE_TYPE", "%du", (int)ShapeType::kRect);
     }
     if (usedShapeTypes & kOval_ShapeFlag) {
         v->definef("OVAL_SHAPE_TYPE", "%du", (int)ShapeType::kOval);
     }
 
-    backend->emitCode(v, f, args.fOutputCoverage, args.fOutputColor);
+    backend->emitCode(v, f, pipeline.ignoresCoverage() ? nullptr : args.fOutputCoverage,
+                      args.fOutputColor);
 
     const char* localCoords = nullptr;
     if (ip.batchInfo().fUsesLocalCoords) {
         localCoords = "localCoords";
         v->codeAppendf("vec2 t = 0.5 * (%s + vec2(1));", backend->outShapeCoords());
         v->codeAppendf("vec2 localCoords = (1.0 - t) * %s.xy + t * %s.zw;",
                        inputs.attr(Attrib::kLocalRect), inputs.attr(Attrib::kLocalRect));
     }
     if (ip.batchInfo().fHasLocalMatrix && ip.batchInfo().fHasParams) {
         v->definef("LOCAL_MATRIX_FLAG", "0x%xu", kLocalMatrix_InfoFlag);
@@ skipping 156 matching lines @@
 void GLSLInstanceProcessor::Backend::setupInnerRRect(GrGLSLVertexBuilder* v) {
     v->codeAppend("mat2 innerP = ");
     fInputs.fetchNextParam(kMat22f_GrSLType);
     v->codeAppend(";");
     v->codeAppend("vec2 innerRadii = innerP[0] * 2.0 / innerP[1];");
     this->onSetupInnerRRect(v);
 }
 
 void GLSLInstanceProcessor::Backend::emitCode(GrGLSLVertexBuilder* v, GrGLSLPPFragmentBuilder* f,
                                               const char* outCoverage, const char* outColor) {
+    SkASSERT(!fModifiesCoverage || outCoverage);
     this->onEmitCode(v, f, fModifiesCoverage ? outCoverage : nullptr,
                      fModifiesColor ? outColor : nullptr);
-    if (!fModifiesCoverage) {
+    if (outCoverage && !fModifiesCoverage) {
         // Even though the subclass doesn't use coverage, we are expected to assign some value.
         f->codeAppendf("%s = vec4(1);", outCoverage);
     }
     if (!fModifiesColor) {
         // The subclass didn't assign a value to the output color.
         f->codeAppendf("%s = %s;", outColor, fColor.fsIn());
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
@@ skipping 1122 matching lines @@
             f->overrideSampleCoverage(shapeMask);
         }
     } else {
         f->maskSampleCoverage(shapeMask, opts.fInvertCoverage);
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 GLSLInstanceProcessor::Backend*
-GLSLInstanceProcessor::Backend::Create(const GrGLSLProgramBuilder* p, BatchInfo batchInfo,
+GLSLInstanceProcessor::Backend::Create(const GrPipeline& pipeline, BatchInfo batchInfo,
                                        const VertexInputs& inputs) {
     switch (batchInfo.fAntialiasMode) {
         default:
             SkFAIL("Unexpected antialias mode.");
         case AntialiasMode::kNone:
             return new BackendNonAA(batchInfo, inputs);
         case AntialiasMode::kCoverage:
             return new BackendCoverage(batchInfo, inputs);
         case AntialiasMode::kMSAA:
         case AntialiasMode::kMixedSamples: {
-            const GrPipeline& pipeline = p->pipeline();
             const GrRenderTargetPriv& rtp = pipeline.getRenderTarget()->renderTargetPriv();
             const GrGpu::MultisampleSpecs& specs = rtp.getMultisampleSpecs(pipeline.getStencil());
             return new BackendMultisample(batchInfo, inputs, specs.fEffectiveSampleCnt);
         }
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 const ShapeVertex kVertexData[] = {
@@ skipping 407 matching lines @@
 
         case kCorneredRect_FirstIndex: return "basic_round_rect";
         case kCorneredFramedRect_FirstIndex: return "coverage_round_rect";
         case kCorneredRectFanned_FirstIndex: return "mixed_samples_round_rect";
 
         default: return "unknown";
     }
 }
 
 }