Add test configs for instanced rendering

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"
 #include "GrRenderTargetPriv.h"
 #include "GrResourceCache.h"
 #include "GrResourceProvider.h"
 #include "glsl/GrGLSLGeometryProcessor.h"
 #include "glsl/GrGLSLFragmentShaderBuilder.h"
 #include "glsl/GrGLSLProgramBuilder.h"
 #include "glsl/GrGLSLVarying.h"
 
 namespace gr_instanced {
 
-bool InstanceProcessor::IsSupported(const GrGLSLCaps& glslCaps, const GrCaps& caps,
-                                    AntialiasMode* lastSupportedAAMode) {
+GrCaps::InstancedSupport InstanceProcessor::CheckSupport(const GrGLSLCaps& glslCaps,
+                                                         const GrCaps& caps) {
     if (!glslCaps.canUseAnyFunctionInShader() ||
         !glslCaps.flatInterpolationSupport() ||
         !glslCaps.integerSupport() ||
         0 == glslCaps.maxVertexSamplers() ||
         !caps.shaderCaps()->texelBufferSupport() ||
         caps.maxVertexAttributes() < kNumAttribs) {
-        return false;
+        return GrCaps::InstancedSupport::kNone;
     }
-    if (caps.sampleLocationsSupport() &&
-        glslCaps.sampleVariablesSupport() &&
-        glslCaps.shaderDerivativeSupport()) {
-        if (0 != caps.maxRasterSamples() &&
-            glslCaps.sampleMaskOverrideCoverageSupport()) {
-            *lastSupportedAAMode = AntialiasMode::kMixedSamples;
-        } else {
-            *lastSupportedAAMode = AntialiasMode::kMSAA;
-        }
-    } else {
-        *lastSupportedAAMode = AntialiasMode::kCoverage;
+    if (!caps.sampleLocationsSupport() ||
+        !glslCaps.sampleVariablesSupport() ||
+        !glslCaps.shaderDerivativeSupport()) {
+        return GrCaps::InstancedSupport::kBasic;
     }
-    return true;
+    if (0 == caps.maxRasterSamples() ||
+        !glslCaps.sampleMaskOverrideCoverageSupport()) {
+        return GrCaps::InstancedSupport::kMultisampled;
+    }
+    return GrCaps::InstancedSupport::kMixedSampled;
 }
 
 InstanceProcessor::InstanceProcessor(BatchInfo batchInfo, GrBuffer* paramsBuffer)
     : fBatchInfo(batchInfo) {
     this->initClassID<InstanceProcessor>();
 
     this->addVertexAttrib(Attribute("shapeCoords", kVec2f_GrVertexAttribType, kHigh_GrSLPrecision));
     this->addVertexAttrib(Attribute("vertexAttrs", kInt_GrVertexAttribType));
     this->addVertexAttrib(Attribute("instanceInfo", kUint_GrVertexAttribType));
     this->addVertexAttrib(Attribute("shapeMatrixX", kVec3f_GrVertexAttribType,
@@ skipping 706 matching lines @@
             varyingHandler->addVarying("rectCoverage", &fRectCoverage, kLow_GrSLPrecision);
         }
         v->codeAppend("float rectCoverage = 0.0;");
     }
     if (kRect_ShapeFlag != fBatchInfo.fShapeTypes) {
         varyingHandler->addFlatVarying("triangleIsArc", &fTriangleIsArc, kLow_GrSLPrecision);
         if (!fShapeIsCircle) {
             varyingHandler->addVarying("ellipseCoords", &fEllipseCoords, kMedium_GrSLPrecision);
             varyingHandler->addFlatVarying("ellipseName", &fEllipseName, kHigh_GrSLPrecision);
         } else {
-            varyingHandler->addVarying("circleCoords", &fEllipseCoords, kMedium_GrSLPrecision);
-            varyingHandler->addFlatVarying("bloatedRadius", &fBloatedRadius, kMedium_GrSLPrecision);
+            varyingHandler->addVarying("circleCoords", &fEllipseCoords, kHigh_GrSLPrecision);
+            varyingHandler->addFlatVarying("bloatedRadius", &fBloatedRadius, kHigh_GrSLPrecision);
         }
     }
 }
 
 void GLSLInstanceProcessor::BackendCoverage::setupRect(GrGLSLVertexBuilder* v) {
     // Make the border one pixel wide. Inner vs outer is indicated by coordAttrs.
     v->codeAppendf("vec2 rectBloat = (%s != 0) ? bloat : -bloat;",
                    fInputs.attr(Attrib::kVertexAttrs));
     // Here we use the absolute value, because when the rect is thinner than a pixel, this makes it
     // mark the spot where pixel center is within half a pixel of the *opposite* edge. This,
@@ skipping 227 matching lines @@
         f->codeAppendf("%s = %s;", outCoverage, fRectCoverage.fsIn());
     } else {
         f->codeAppendf("%s = 1.0;", outCoverage);
     }
 }
 
 void GLSLInstanceProcessor::BackendCoverage::emitCircle(GrGLSLPPFragmentBuilder* f,
                                                         const char* outCoverage) {
     // TODO: circleCoords = max(circleCoords, 0) if we decide to do this optimization on rrects.
     SkASSERT(!(kRRect_ShapesMask & fBatchInfo.fShapeTypes));
-    f->appendPrecisionModifier(kLow_GrSLPrecision);
+    f->appendPrecisionModifier(kMedium_GrSLPrecision);
     f->codeAppendf("float distanceToEdge = %s - length(%s);",
                    fBloatedRadius.fsIn(), fEllipseCoords.fsIn());
     f->codeAppendf("%s = clamp(distanceToEdge, 0.0, 1.0);", outCoverage);
 }
 
 void GLSLInstanceProcessor::BackendCoverage::emitArc(GrGLSLPPFragmentBuilder* f,
                                                      const char* ellipseCoords,
                                                      const char* ellipseName,
                                                      bool ellipseCoordsNeedClamp,
                                                      bool ellipseCoordsMayBeNegative,
@@ skipping 370 matching lines @@
     if (!this->isMixedSampled()) {
         SkASSERT(!fArcTest.fsIn());
         if (fTriangleIsArc.fsIn()) {
             f->codeAppendf("if (%s != 0) {", fTriangleIsArc.fsIn());
             this->emitArc(f, arcCoords, false, clampArcCoords, opts);
 
             f->codeAppend ("}");
         }
     } else {
         const char* arcTest = fArcTest.fsIn();
-        SkASSERT(arcTest);
-        if (fBatchInfo.fHasPerspective) {
-            // The non-perspective version accounts for fwith() in the vertex shader.
+        if (arcTest && fBatchInfo.fHasPerspective) {
+            // The non-perspective version accounts for fwidth() in the vertex shader.
             // We make sure to take the derivative here, before a neighbor pixel may early accept.
             f->enableFeature(GrGLSLPPFragmentBuilder::kStandardDerivatives_GLSLFeature);
             f->appendPrecisionModifier(kHigh_GrSLPrecision);
             f->codeAppendf("vec2 arcTest = %s - 0.5 * fwidth(%s);",
                            fArcTest.fsIn(), fArcTest.fsIn());
             arcTest = "arcTest";
         }
         const char* earlyAccept = fEarlyAccept.fsIn() ? fEarlyAccept.fsIn() : "SAMPLE_MASK_ALL";
         f->codeAppendf("if (gl_SampleMaskIn[0] == %s) {", earlyAccept);
         f->overrideSampleCoverage(earlyAccept);
@@ skipping 694 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";
     }
 }
 
 }