GrBatchPrototype

src/gpu/GrDrawState.h

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrDrawState_DEFINED
 #define GrDrawState_DEFINED
 
-
+#include "GrBatch.h"
 #include "GrBlend.h"
 #include "GrDrawTargetCaps.h"
 #include "GrGeometryProcessor.h"
 #include "GrGpuResourceRef.h"
 #include "GrFragmentStage.h"
 #include "GrProcOptInfo.h"
 #include "GrRenderTarget.h"
 #include "GrStencil.h"
 #include "GrXferProcessor.h"
 #include "SkMatrix.h"
@@ skipping 377 matching lines @@
 
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
 
     GrDrawState& operator= (const GrDrawState& that);
 
 private:
     bool isEqual(const GrDrawState& that, bool explicitLocalCoords) const;
 
+    // TODO delete when we have Batch
     const GrProcOptInfo& colorProcInfo(const GrPrimitiveProcessor* pp) const {
         this->calcColorInvariantOutput(pp);
         return fColorProcInfo;
     }
 
     const GrProcOptInfo& coverageProcInfo(const GrPrimitiveProcessor* pp) const {
         this->calcCoverageInvariantOutput(pp);
         return fCoverageProcInfo;
     }
 
+    const GrProcOptInfo& colorProcInfo(const GrBatch* batch) const {
+        this->calcColorInvariantOutput(batch);
+        return fColorProcInfo;
+    }
+
+    const GrProcOptInfo& coverageProcInfo(const GrBatch* batch) const {
+        this->calcCoverageInvariantOutput(batch);
+        return fCoverageProcInfo;
+    }
+
     /**
-     * If fColorProcInfoValid is false, function calculates the invariant output for the color
-     * stages and results are stored in fColorProcInfo.
+     * Primproc variants of the calc functions
+     * TODO remove these when batch is everywhere
      */
     void calcColorInvariantOutput(const GrPrimitiveProcessor*) const;
-
-    /**
-     * If fCoverageProcInfoValid is false, function calculates the invariant output for the coverage
-     * stages and results are stored in fCoverageProcInfo.
-     */
     void calcCoverageInvariantOutput(const GrPrimitiveProcessor*) const;
 
     /**
+     * GrBatch provides the initial seed for these loops based off of its initial geometry data
+     */
+    void calcColorInvariantOutput(const GrBatch*) const;
+    void calcCoverageInvariantOutput(const GrBatch*) const;
+
+    /**
      * If fColorProcInfoValid is false, function calculates the invariant output for the color
      * stages and results are stored in fColorProcInfo.
      */
     void calcColorInvariantOutput(GrColor) const;
 
     /**
      * If fCoverageProcInfoValid is false, function calculates the invariant output for the coverage
      * stages and results are stored in fCoverageProcInfo.
      */
     void calcCoverageInvariantOutput(GrColor) const;
@@ skipping 13 matching lines @@
     SkAutoTUnref<const GrXPFactory>         fXPFactory;
     FragmentStageArray                      fColorStages;
     FragmentStageArray                      fCoverageStages;
 
     mutable GrProcOptInfo fColorProcInfo;
     mutable GrProcOptInfo fCoverageProcInfo;
     mutable bool fColorProcInfoValid;
     mutable bool fCoverageProcInfoValid;
     mutable GrColor fColorCache;
     mutable GrColor fCoverageCache;
+    // TODO delete when batch is everywhere
     mutable const GrPrimitiveProcessor* fColorPrimProc;
     mutable const GrPrimitiveProcessor* fCoveragePrimProc;
+    // These oddly named parameters are used by the Calc*InvariantOutput calls to determine if they
+    // need to recalculate optimization information.  They are just pointer caches for the two loops
+    mutable const GrBatch* fColorBatch;
+    mutable const GrBatch* fCoverageBatch;
 
     friend class GrOptDrawState;
 };
 
 #endif