More changes to bring together path / geo procs

src/gpu/GrGeometryProcessor.h

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrGeometryProcessor_DEFINED
 #define GrGeometryProcessor_DEFINED
 
@@ skipping 103 matching lines @@
     /*
      * We always call canMakeEqual before makeEqual so there is no need to do any kind of equality
      * testing here
      * TODO make this pure virtual when primProcs can actually use it
      */
     virtual void makeEqual(GrBatchTracker*, const GrBatchTracker&) const {}
 
     virtual void getInvariantOutputColor(GrInitInvariantOutput* out) const = 0;
     virtual void getInvariantOutputCoverage(GrInitInvariantOutput* out) const = 0;
 
+    // Only the GrGeometryProcessor subclass actually has a geo shader or vertex attributes, but
+    // we put these calls on the base class to prevent having to cast
+    virtual bool willUseGeoShader() const = 0;
+
+    /*
+     * This is a safeguard to prevent GrPrimitiveProcessor's from going beyond platform specific
+     * attribute limits. This number can almost certainly be raised if required.
+     */
+    static const int kMaxVertexAttribs = 6;
+
+    struct Attribute {
+        Attribute()
+            : fName(NULL)
+            , fType(kFloat_GrVertexAttribType)
+            , fOffset(0) {}
+        Attribute(const char* name, GrVertexAttribType type)
+            : fName(name)
+            , fType(type)
+            , fOffset(SkAlign4(GrVertexAttribTypeSize(type))) {}
+        const char* fName;
+        GrVertexAttribType fType;
+        size_t fOffset;
+    };
+
+    int numAttribs() const { return fNumAttribs; }
+    const Attribute& getAttrib(int index) const {
+        SkASSERT(index < fNumAttribs);
+        return fAttribs[index];
+    }
+
+    // Returns the vertex stride of the GP.  A common use case is to request geometry from a
+    // drawtarget based off of the stride, and to populate this memory using an implicit array of
+    // structs.  In this case, it is best to assert the vertexstride == sizeof(VertexStruct).
+    size_t getVertexStride() const { return fVertexStride; }
+
     /**
      * Gets a transformKey from an array of coord transforms
      */
     uint32_t getTransformKey(const SkTArray<const GrCoordTransform*, true>&) const;
 
     /**
      * Sets a unique key on the GrProcessorKeyBuilder that is directly associated with this geometry
      * processor's GL backend implementation.
      */
     virtual void getGLProcessorKey(const GrBatchTracker& bt,
                                    const GrGLCaps& caps,
                                    GrProcessorKeyBuilder* b) const = 0;
 
 
     /** Returns a new instance of the appropriate *GL* implementation class
         for the given GrProcessor; caller is responsible for deleting
         the object. */
     virtual GrGLPrimitiveProcessor* createGLInstance(const GrBatchTracker& bt,
                                                      const GrGLCaps& caps) const = 0;
 
 protected:
     GrPrimitiveProcessor(const SkMatrix& viewMatrix, const SkMatrix& localMatrix)
-        : fViewMatrix(viewMatrix)
+        : fNumAttribs(0)
+        , fVertexStride(0)
+        , fViewMatrix(viewMatrix)
         , fLocalMatrix(localMatrix) {}
 
     /*
      * CanCombineOutput will return true if two draws are 'batchable' from a color perspective.
      * TODO remove this when GPs can upgrade to attribute color
      */
     static bool CanCombineOutput(GrGPInput left, GrColor lColor, GrGPInput right, GrColor rColor) {
         if (left != right) {
             return false;
         }
@@ skipping 12 matching lines @@
         if (leftUsesLocalCoords != rightUsesLocalCoords) {
             return false;
         }
 
         if (leftUsesLocalCoords && !left.localMatrix().cheapEqualTo(right.localMatrix())) {
             return false;
         }
         return true;
     }
 
+    Attribute fAttribs[kMaxVertexAttribs];
+    int fNumAttribs;
+    size_t fVertexStride;
+
 private:
     virtual bool hasExplicitLocalCoords() const = 0;
 
     SkMatrix fViewMatrix;
     SkMatrix fLocalMatrix;
 
     typedef GrProcessor INHERITED;
 };
 
 /**
  * A GrGeometryProcessor is a flexible method for rendering a primitive.  The GrGeometryProcessor
  * has complete control over vertex attributes and uniforms(aside from the render target) but it
  * must obey the same contract as any GrPrimitiveProcessor, specifically it must emit a color and
  * coverage into the fragment shader.  Where this color and coverage come from is completely the
  * responsibility of the GrGeometryProcessor.
  */
 class GrGeometryProcessor : public GrPrimitiveProcessor {
 public:
     // TODO the Hint can be handled in a much more clean way when we have deferred geometry or
     // atleast bundles
     GrGeometryProcessor(GrColor color,
                         const SkMatrix& viewMatrix = SkMatrix::I(),
                         const SkMatrix& localMatrix = SkMatrix::I(),
                         bool opaqueVertexColors = false)
         : INHERITED(viewMatrix, localMatrix)
-        , fVertexStride(0)
         , fColor(color)
         , fOpaqueVertexColors(opaqueVertexColors)
         , fWillUseGeoShader(false)
         , fHasVertexColor(false)
         , fHasLocalCoords(false) {}
 
-    /*
-     * This is a safeguard to prevent GPs from going beyond platform specific attribute limits.
-     * This number can almost certainly be raised if required.
-     */
-    static const int kMaxVertexAttribs = 6;
-
-    struct GrAttribute {
-        GrAttribute(const char* name, GrVertexAttribType type)
-            : fName(name)
-            , fType(type)
-            , fOffset(SkAlign4(GrVertexAttribTypeSize(type))) {}
-        const char* fName;
-        GrVertexAttribType fType;
-        size_t fOffset;
-    };
-
-    typedef SkTArray<GrAttribute, true> VertexAttribArray;
-
-    const VertexAttribArray& getAttribs() const { return fAttribs; }
-
-    // Returns the vertex stride of the GP.  A common use case is to request geometry from a
-    // drawtarget based off of the stride, and to populate this memory using an implicit array of
-    // structs.  In this case, it is best to assert the vertexstride == sizeof(VertexStruct).
-    size_t getVertexStride() const { return fVertexStride; }
-
     bool willUseGeoShader() const { return fWillUseGeoShader; }
 
     /*
      * In an ideal world, two GrGeometryProcessors with the same class id and texture accesses
      * would ALWAYS be able to batch together.  If two GrGeometryProcesosrs are the same then we
      * will only keep one of them.  The remaining GrGeometryProcessor then updates its
      * GrBatchTracker to incorporate the draw information from the GrGeometryProcessor we discard.
      * Any bundles associated with the discarded GrGeometryProcessor will be attached to the
      * remaining GrGeometryProcessor.
      */
@@ skipping 65 matching lines @@
 
     /**
      * Subclasses call this from their constructor to register vertex attributes.  Attributes
      * will be padded to the nearest 4 bytes for performance reasons.
      * TODO After deferred geometry, we should do all of this inline in GenerateGeometry alongside
      * the struct used to actually populate the attributes.  This is all extremely fragile, vertex
      * attributes have to be added in the order they will appear in the struct which maps memory.
      * The processor key should reflect the vertex attributes, or there lack thereof in the
      * GrGeometryProcessor.
      */
-    const GrAttribute& addVertexAttrib(const GrAttribute& attribute) {
+    const Attribute& addVertexAttrib(const Attribute& attribute) {
         fVertexStride += attribute.fOffset;

[bsalomon, 2015/01/13 20:19:22]

fail if too many are added?

-        return fAttribs.push_back(attribute);
+        fAttribs[fNumAttribs] = attribute;
+        return fAttribs[fNumAttribs++];
     }
 
     void setWillUseGeoShader() { fWillUseGeoShader = true; }
 
     // TODO hack see above
     void setHasVertexColor() { fHasVertexColor = true; }
     void setHasLocalCoords() { fHasLocalCoords = true; }
 
     virtual void onGetInvariantOutputColor(GrInitInvariantOutput*) const {}
     virtual void onGetInvariantOutputCoverage(GrInitInvariantOutput*) const = 0;
 
 private:
     virtual bool onCanMakeEqual(const GrBatchTracker& mine,
                                 const GrGeometryProcessor& that,
                                 const GrBatchTracker& theirs) const = 0;
 
     // TODO delete this when we have more advanced equality testing via bundles and the BT
     virtual bool onIsEqual(const GrGeometryProcessor&) const = 0;
 
     bool hasExplicitLocalCoords() const SK_OVERRIDE { return fHasLocalCoords; }
 
-    SkSTArray<kMaxVertexAttribs, GrAttribute, true> fAttribs;
-    size_t fVertexStride;
     GrColor fColor;
     bool fOpaqueVertexColors;
     bool fWillUseGeoShader;
     bool fHasVertexColor;
     bool fHasLocalCoords;
 
     typedef GrPrimitiveProcessor INHERITED;
 };
 
 /*
@@ skipping 14 matching lines @@
                       const GrPrimitiveProcessor& that,
                       const GrBatchTracker& theirs) const SK_OVERRIDE;
 
     const char* name() const SK_OVERRIDE { return "PathProcessor"; }
 
     GrColor color() const { return fColor; }
 
     void getInvariantOutputColor(GrInitInvariantOutput* out) const SK_OVERRIDE;
     void getInvariantOutputCoverage(GrInitInvariantOutput* out) const SK_OVERRIDE;
 
+    bool willUseGeoShader() const SK_OVERRIDE { return false; }
+
     virtual void getGLProcessorKey(const GrBatchTracker& bt,
                                    const GrGLCaps& caps,
                                    GrProcessorKeyBuilder* b) const SK_OVERRIDE;
 
     virtual GrGLPrimitiveProcessor* createGLInstance(const GrBatchTracker& bt,
                                                      const GrGLCaps& caps) const SK_OVERRIDE;
 
 protected:
     GrPathProcessor(GrColor color, const SkMatrix& viewMatrix, const SkMatrix& localMatrix);
 
 private:
     bool hasExplicitLocalCoords() const SK_OVERRIDE { return false; }
 
     GrColor fColor;
 
     typedef GrPrimitiveProcessor INHERITED;
 };
 
 #endif