Remove GP from drawstate, revision of invariant output for GP

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
 
@@ skipping 50 matching lines @@
     void reset(const SkMatrix& initialViewMatrix) { this->onReset(&initialViewMatrix); }
 
     /**
      * Initializes the GrDrawState based on a GrPaint, view matrix and render target. Note that
      * GrDrawState encompasses more than GrPaint. Aspects of GrDrawState that have no GrPaint
      * equivalents are set to default values with the exception of vertex attribute state which
      * is unmodified by this function and clipping which will be enabled.
      */
     void setFromPaint(const GrPaint& , const SkMatrix& viewMatrix, GrRenderTarget*);
 
-    ///////////////////////////////////////////////////////////////////////////
-    /// @name Vertex Attributes
-    ////
-
-    // TODO when we move this info off of GrGeometryProcessor, delete these
-    bool hasLocalCoordAttribute() const {
-        return this->hasGeometryProcessor() && this->getGeometryProcessor()->hasLocalCoords();
-    }
-    bool hasColorVertexAttribute() const {
-        return this->hasGeometryProcessor() && this->getGeometryProcessor()->hasVertexColor();
-    }
-    bool hasCoverageVertexAttribute() const {
-        return this->hasGeometryProcessor() && this->getGeometryProcessor()->hasVertexCoverage();
-    }
-
     /// @}
 
     /**
      * Depending on features available in the underlying 3D API and the color blend mode requested
      * it may or may not be possible to correctly blend with fractional pixel coverage generated by
      * the fragment shader.
      *
      * This function considers the current draw state and the draw target's capabilities to
      * determine whether coverage can be handled correctly. This function assumes that the caller
      * intends to specify fractional pixel coverage via a primitive processor but may not have
      * specified it yet.
      */
     bool canUseFracCoveragePrimProc(GrColor color, const GrDrawTargetCaps& caps) const;
 
     /**
      * Determines whether the output coverage is guaranteed to be one for all pixels hit by a draw.
      */
-    bool hasSolidCoverage(GrColor coverage) const;
+    bool hasSolidCoverage(const GrPrimitiveProcessor*) const;
 
     /**
      * This function returns true if the render target destination pixel values will be read for
      * blending during draw.
      */
-    bool willBlendWithDst(GrColor color, GrColor coverage) const;
-
-    /// @}
-
-    /**
-     * The geometry processor is the sole element of the skia pipeline which can use the vertex,
-     * geometry, and tesselation shaders.  The GP may also compute a coverage in its fragment shader
-     * but is never put in the color processing pipeline.
-     */
-
-    const GrGeometryProcessor* setGeometryProcessor(const GrGeometryProcessor* geometryProcessor) {
-        SkASSERT(geometryProcessor);
-        SkASSERT(!this->hasGeometryProcessor());
-        fGeometryProcessor.reset(SkRef(geometryProcessor));
-        fCoverageProcInfoValid = false;
-        return geometryProcessor;
-    }
+    bool willBlendWithDst(const GrPrimitiveProcessor*) const;
 
     ///////////////////////////////////////////////////////////////////////////
     /// @name Effect Stages
     /// Each stage hosts a GrProcessor. The effect produces an output color or coverage in the
     /// fragment shader. Its inputs are the output from the previous stage as well as some variables
     /// available to it in the fragment and vertex shader (e.g. the vertex position, the dst color,
     /// the fragment position, local coordinates).
     ///
     /// The stages are divided into two sets, color-computing and coverage-computing. The final
     /// color stage produces the final pixel color. The coverage-computing stages function exactly
     /// as the color-computing but the output of the final coverage stage is treated as a fractional
     /// pixel coverage rather than as input to the src/dst color blend step.
     ///
     /// The input color to the first color-stage is either the constant color or interpolated
     /// per-vertex colors. The input to the first coverage stage is either a constant coverage
     /// (usually full-coverage) or interpolated per-vertex coverage.
     ///
     /// See the documentation of kCoverageDrawing_StateBit for information about disabling the
     /// the color / coverage distinction.
     ////
 
     int numColorStages() const { return fColorStages.count(); }
     int numCoverageStages() const { return fCoverageStages.count(); }
     int numFragmentStages() const { return this->numColorStages() + this->numCoverageStages(); }
-    int numTotalStages() const {
-         return this->numFragmentStages() + (this->hasGeometryProcessor() ? 1 : 0);
-    }
-
-    bool hasGeometryProcessor() const { return SkToBool(fGeometryProcessor.get()); }
-    const GrGeometryProcessor* getGeometryProcessor() const { return fGeometryProcessor.get(); }
 
     const GrXPFactory* getXPFactory() const { return fXPFactory.get(); }
 
     const GrFragmentStage& getColorStage(int idx) const { return fColorStages[idx]; }
     const GrFragmentStage& getCoverageStage(int idx) const { return fCoverageStages[idx]; }
 
     /**
      * Checks whether any of the effects will read the dst pixel color.
      * TODO remove when we have an XP
      */
-    bool willEffectReadDstColor(GrColor color, GrColor coverage) const;
+    bool willEffectReadDstColor(const GrPrimitiveProcessor*) const;
 
     /**
      * The xfer processor factory.
      */
     const GrXPFactory* setXPFactory(const GrXPFactory* xpFactory) {
         fXPFactory.reset(SkRef(xpFactory));
         return xpFactory;
     }
 
     void setPorterDuffXPFactory(SkXfermode::Mode mode) {
@@ skipping 54 matching lines @@
      * significant complexity to the multi-ref architecture for deferred drawing. Once GrDrawState
      * and GrOptDrawState are fully separated then GrDrawState will never be in the deferred
      * execution state and GrOptDrawState always will be (and will be immutable and therefore
      * unable to have an ARE). At this point we can restore sanity and have the ARE save and restore
      * the GP.
      */
     class AutoRestoreEffects : public ::SkNoncopyable {
     public:
         AutoRestoreEffects() 
             : fDrawState(NULL)
-            , fOriginalGPID(SK_InvalidUniqueID)
             , fColorEffectCnt(0)
             , fCoverageEffectCnt(0) {}
 
         AutoRestoreEffects(GrDrawState* ds)
             : fDrawState(NULL)
-            , fOriginalGPID(SK_InvalidUniqueID)
             , fColorEffectCnt(0)
             , fCoverageEffectCnt(0) {
             this->set(ds);
         }
 
         ~AutoRestoreEffects() { this->set(NULL); }
 
         void set(GrDrawState* ds);
 
         bool isSet() const { return SkToBool(fDrawState); }
 
     private:
         GrDrawState*    fDrawState;
-        uint32_t        fOriginalGPID;
         int             fColorEffectCnt;
         int             fCoverageEffectCnt;
     };
 
     /**
      * AutoRestoreStencil
      *
      * This simple struct saves and restores the stencil settings
      */
     class AutoRestoreStencil : public ::SkNoncopyable {
@@ skipping 256 matching lines @@
      * @param face  the face(s) to draw.
      */
     void setDrawFace(DrawFace face) {
         SkASSERT(kInvalid_DrawFace != face);
         fDrawFace = face;
     }
 
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
-    /// @name Hints
-    /// Hints that when provided can enable optimizations.
-    ////
-
-    enum Hints {
-        kVertexColorsAreOpaque_Hint = 0x1,
-        kLast_Hint = kVertexColorsAreOpaque_Hint
-    };
-
-    void setHint(Hints hint, bool value) { fHints = value ? (fHints | hint) : (fHints & ~hint); }
-
-    bool vertexColorsAreOpaque() const { return kVertexColorsAreOpaque_Hint & fHints; }
-
-    /// @}
-
-    ///////////////////////////////////////////////////////////////////////////
 
     GrDrawState& operator= (const GrDrawState& that);
 
 private:
-    bool isEqual(const GrDrawState& that) const;
+    bool isEqual(const GrDrawState& that, bool explicitLocalCoords) const;
 
-    const GrProcOptInfo& colorProcInfo(GrColor color) const { 
-        this->calcColorInvariantOutput(color);
+    const GrProcOptInfo& colorProcInfo(const GrPrimitiveProcessor* pp) const {
+        this->calcColorInvariantOutput(pp);
         return fColorProcInfo;
     }
 
-    const GrProcOptInfo& coverageProcInfo(GrColor coverage) const {
-        this->calcCoverageInvariantOutput(coverage);
+    const GrProcOptInfo& coverageProcInfo(const GrPrimitiveProcessor* pp) const {
+        this->calcCoverageInvariantOutput(pp);
         return fCoverageProcInfo;
     }
 
     /**
-     * Determines whether src alpha is guaranteed to be one for all src pixels
+     * If fColorProcInfoValid is false, function calculates the invariant output for the color
+     * stages and results are stored in fColorProcInfo.
      */
-    bool srcAlphaWillBeOne(GrColor color, GrColor coverage) const;
+    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;
 
     /**
      * 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;
 
     void onReset(const SkMatrix* initialViewMatrix);
 
     // Some of the auto restore objects assume that no effects are removed during their lifetime.
     // This is used to assert that this condition holds.
     SkDEBUGCODE(int fBlockEffectRemovalCnt;)
 
     typedef SkSTArray<4, GrFragmentStage> FragmentStageArray;
 
     SkAutoTUnref<GrRenderTarget>            fRenderTarget;
     SkMatrix                                fViewMatrix;
     uint32_t                                fFlagBits;
     GrStencilSettings                       fStencilSettings;
     DrawFace                                fDrawFace;
-    SkAutoTUnref<const GrGeometryProcessor> fGeometryProcessor;
     SkAutoTUnref<const GrXPFactory>         fXPFactory;
     FragmentStageArray                      fColorStages;
     FragmentStageArray                      fCoverageStages;
-    uint32_t                                fHints;
 
     mutable GrProcOptInfo fColorProcInfo;
     mutable GrProcOptInfo fCoverageProcInfo;
     mutable bool fColorProcInfoValid;
     mutable bool fCoverageProcInfoValid;
     mutable GrColor fColorCache;
     mutable GrColor fCoverageCache;
+    mutable const GrPrimitiveProcessor* fColorPrimProc;
+    mutable const GrPrimitiveProcessor* fCoveragePrimProc;
 
     friend class GrOptDrawState;
 };
 
 #endif