Check for xfer barriers in GrBatch, auto-issue barriers in GrGpu

src/gpu/GrPipeline.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrPipeline_DEFINED
 #define GrPipeline_DEFINED
 
@@ skipping 11 matching lines @@
 class GrBatch;
 class GrDeviceCoordTexture;
 class GrPipelineBuilder;
 
 /**
  * Class that holds an optimized version of a GrPipelineBuilder. It is meant to be an immutable
  * class, and contains all data needed to set the state for a gpu draw.
  */
 class GrPipeline : public GrNonAtomicRef {
 public:
+    ///////////////////////////////////////////////////////////////////////////
+    /// @name Creation
+
     struct CreateArgs {
         const GrPipelineBuilder*    fPipelineBuilder;
         const GrCaps*               fCaps;
         GrProcOptInfo               fColorPOI;
         GrProcOptInfo               fCoveragePOI;
         const GrScissorState*       fScissor;
         GrXferProcessor::DstTexture fDstTexture;
     };
 
     /** Creates a pipeline into a pre-allocated buffer */
     static GrPipeline* CreateAt(void* memory, const CreateArgs&, GrPipelineOptimizations*);
 
-    /*
+    /// @}
+
+    ///////////////////////////////////////////////////////////////////////////
+    /// @name Comparisons
+
+    /**
      * Returns true if these pipelines are equivalent.  Coord transforms may be applied either on
      * the GPU or the CPU. When we apply them on the CPU then the matrices need not agree in order
      * to combine draws. Therefore we take a param that indicates whether coord transforms should be
      * compared."
      */
-    bool isEqual(const GrPipeline& that, bool ignoreCoordTransforms = false) const;
+    static bool AreEqual(const GrPipeline& a, const GrPipeline& b, bool ignoreCoordTransforms);
+
+    /**
+     * Allows a GrBatch subclass to determine whether two GrBatches can combine. This is a stricter
+     * test than isEqual because it also considers blend barriers when the two batches' bounds
+     * overlap
+     */
+    static bool CanCombine(const GrPipeline& a, const SkRect& aBounds,
+                           const GrPipeline& b, const SkRect& bBounds,
+                           const GrCaps& caps,
+                           bool ignoreCoordTransforms = false)  {
+        if (!AreEqual(a, b, ignoreCoordTransforms)) {
+            return false;
+        }
+        if (a.xferBarrierType(caps)) {
+            return aBounds.fRight <= bBounds.fLeft ||
+                   aBounds.fBottom <= bBounds.fTop ||
+                   bBounds.fRight <= aBounds.fLeft ||
+                   bBounds.fBottom <= aBounds.fTop;
+        }
+        return true;
+    }
 
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
     /// @name GrFragmentProcessors
 
 
     int numColorFragmentStages() const { return fNumColorStages; }
     int numCoverageFragmentStages() const { return fFragmentStages.count() - fNumColorStages; }
     int numFragmentStages() const { return fFragmentStages.count(); }
@@ skipping 22 matching lines @@
     GrRenderTarget* getRenderTarget() const { return fRenderTarget.get(); }
 
     const GrStencilSettings& getStencil() const { return fStencilSettings; }
 
     const GrScissorState& getScissorState() const { return fScissorState; }
 
     bool isDitherState() const { return SkToBool(fFlags & kDither_Flag); }
     bool isHWAntialiasState() const { return SkToBool(fFlags & kHWAA_Flag); }
     bool snapVerticesToPixelCenters() const { return SkToBool(fFlags & kSnapVertices_Flag); }
 
+    GrXferBarrierType xferBarrierType(const GrCaps& caps) const {
+        return fXferProcessor->xferBarrierType(fRenderTarget.get(), caps);
+    }
+
     /**
      * Gets whether the target is drawing clockwise, counterclockwise,
      * or both faces.
      * @return the current draw face(s).
      */
     GrPipelineBuilder::DrawFace getDrawFace() const { return fDrawFace; }
 
 
     ///////////////////////////////////////////////////////////////////////////
 
@@ skipping 45 matching lines @@
     // This function is equivalent to the offset into fFragmentStages where coverage stages begin.
     int                                 fNumColorStages;
 
     SkSTArray<8, const GrCoordTransform*, true> fCoordTransforms;
     GrProgramDesc                       fDesc;
 
     typedef SkRefCnt INHERITED;
 };
 
 #endif