Implement instanced rendering for simple shapes

src/gpu/effects/GrInstanceProcessor.h

+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrInstanceProcessor_DEFINED
+#define GrInstanceProcessor_DEFINED
+
+#include "GrBufferAccess.h"
+#include "GrGeometryProcessor.h"
+#include "GrInstancedRenderingTypes.h"
+
+/**
+ * This class provides a GP implementation that uses instanced rendering. Is sends geometry in as
+ * basic, pre-baked canonical shapes, and uses instanced vertex attribs to control how these shapes
+ * are transformed and drawn. MSAA is accomplished with the sample mask rather than finely
+ * tesselated geometry.
+ */
+class GrInstanceProcessor : public GrGeometryProcessor, private GrInstancedRenderingTypes {
+public:
+    static uint32_t GetSupportedAAModes(const GrGLSLCaps&, const GrCaps&);

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

Having GLSL caps here is sort of violation of the layering, should be agnostic.
Can this be made to work with ShaderCaps?

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

Is it really a layering violation when the class has a method called
"createGLSLInstance" that also accepts GLSL caps? I guess it didn't seem weird
to me for the method of deciding which AA modes are supported to be tied to a
specific shading language.

If another shading language came along, I figured we would just add a couple
more methods like this:

 static uint32_t GetSupportedAAModes(const GrHLSLCaps&, const GrCaps&);
 ...
 GrHLSLPrimitiveProcessor* createHLSLInstance(const GrHLSLCaps&) const override;


In theory it could probably be made agnostic, but for now a lot of the caps that
GetSupportedAAModes(GrGLSLCaps) needs to check live on GrGLSLCaps instead of
GrShaderCaps.

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

It is definitely the case that if we added another shading language we'd have to
add new GrNewSLFooProcessor factory methods (as well as getNewSLKey() methods).
However, we've tried to limit the number of SL-specific methods. Currently,
they're all called in the GLSL-specific code, not in API-neutral layer, which I
suppose is also the case here. Looking at the caps used they'd all make sense to
me as GrShaderCaps with the exception of canUseAnyFunctionInShader which is
definitely a GLSL-specific driver bug workaround. So, I suppose it is ok to keep
as is.

+
+    GrInstanceProcessor(BatchTracker, GrBuffer* paramsBuffer, AntialiasMode);
+
+    const char* name() const override { return "Instance Processor"; }
+    BatchTracker tracker() const { return fTracker; }
+    AntialiasMode antialiasMode() const { return fAntialiasMode; }
+
+    void getGLSLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override;
+    GrGLSLPrimitiveProcessor* createGLSLInstance(const GrGLSLCaps&) const override;
+
+    /**
+     * Returns a buffer of ShapeVertex that defines the canonical instanced geometry.
+     */
+    static const GrBuffer* SK_WARN_UNUSED_RESULT FindOrCreateVertexBuffer(GrGpu*);
+
+    /**
+     * Returns a buffer of 8-bit indices for the canonical instanced geometry. The client can call
+     * GetIndexRangeForXXX to know which indices to use for a specific shape.
+     */
+    static const GrBuffer* SK_WARN_UNUSED_RESULT FindOrCreateIndex8Buffer(GrGpu*);
+
+    static void GetIndexRangeForRect(AntialiasMode, uint32_t* firstIndex, uint32_t* count);
+    static void GetIndexRangeForOval(AntialiasMode, const SkRect& devBounds, uint32_t* firstIndex,
+                                     uint32_t* count);
+    static void GetIndexRangeForRRect(AntialiasMode, uint32_t* firstIndex, uint32_t* count);
+
+private:
+    const BatchTracker    fTracker;
+    const AntialiasMode   fAntialiasMode;
+    GrBufferAccess        fParamsAccess;
+
+    typedef GrGeometryProcessor INHERITED;
+};
+
+#endif