Revert of Opt state takes a GP instead of a GeometryStage

include/gpu/GrProcessorStage.h

 
 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 
 #ifndef GrProcessorStage_DEFINED
 #define GrProcessorStage_DEFINED
 
 #include "GrBackendProcessorFactory.h"
 #include "GrCoordTransform.h"
 #include "GrProcessor.h"
 #include "GrGeometryProcessor.h"
 #include "GrProgramElementRef.h"
 #include "SkMatrix.h"
 #include "SkShader.h"
 
 // TODO: Make two variations on this class: One for GrDrawState that only owns regular refs
 // and supports compatibility checks and changing local coords. The second is for GrOptDrawState,
 // is immutable, and only owns pending execution refs. This requries removing the common base
 // class from GrDrawState and GrOptDrawState called GrRODrawState and converting to GrOptDrawState
 // when draws are enqueued in the GrInOrderDrawBuffer.
-class GrFragmentStage {
+class GrProcessorStage {
 public:
-    explicit GrFragmentStage(const GrFragmentProcessor* proc)
+    explicit GrProcessorStage(const GrProcessor* proc)
     : fProc(SkRef(proc)) {
         fCoordChangeMatrixSet = false;
     }
 
-    GrFragmentStage(const GrFragmentStage& other) {
+    virtual ~GrProcessorStage() {}
+
+    GrProcessorStage(const GrProcessorStage& other) {
         fCoordChangeMatrixSet = other.fCoordChangeMatrixSet;
         if (other.fCoordChangeMatrixSet) {
             fCoordChangeMatrix = other.fCoordChangeMatrix;
         }
         fProc.initAndRef(other.fProc);
     }
     
-    static bool AreCompatible(const GrFragmentStage& a, const GrFragmentStage& b,
+    static bool AreCompatible(const GrProcessorStage& a, const GrProcessorStage& b,
                               bool usingExplicitLocalCoords) {
         SkASSERT(a.fProc.get());
         SkASSERT(b.fProc.get());
 
         if (!a.getProcessor()->isEqual(*b.getProcessor())) {
             return false;
         }
 
         // We always track the coord change matrix, but it has no effect when explicit local coords
         // are used.
@@ skipping 28 matching lines @@
     }
 
     class SavedCoordChange {
     public:
         SkDEBUGCODE(SavedCoordChange() : fEffectUniqueID(SK_InvalidUniqueID) {})
     private:
         bool fCoordChangeMatrixSet;
         SkMatrix fCoordChangeMatrix;
         SkDEBUGCODE(mutable uint32_t fEffectUniqueID;)
 
-        friend class GrFragmentStage;
+        friend class GrProcessorStage;
     };
 
     /**
      * This gets the current coordinate system change. It is the accumulation of
      * localCoordChange calls since the effect was installed. It is used when then caller
      * wants to temporarily change the source geometry coord system, draw something, and then
      * restore the previous coord system (e.g. temporarily draw in device coords).
      */
     void saveCoordChange(SavedCoordChange* savedCoordChange) const {
         savedCoordChange->fCoordChangeMatrixSet = fCoordChangeMatrixSet;
@@ skipping 38 matching lines @@
         }
 
         int combinedTypes = type0 | type1;
         if (SkMatrix::kPerspective_Mask & combinedTypes) {
           return true;
         } else {
           return false;
         }
     }
 
-    const GrFragmentProcessor* getProcessor() const { return fProc.get(); }
+    virtual const GrProcessor* getProcessor() const = 0;
 
     void convertToPendingExec() { fProc.convertToPendingExec(); }
 
 protected:
-    bool                                           fCoordChangeMatrixSet;
-    SkMatrix                                       fCoordChangeMatrix;
-    GrProgramElementRef<const GrFragmentProcessor> fProc;
+    bool                                   fCoordChangeMatrixSet;
+    SkMatrix                               fCoordChangeMatrix;
+    GrProgramElementRef<const GrProcessor> fProc;
+};
+
+class GrFragmentStage : public GrProcessorStage {
+public:
+    GrFragmentStage(const GrFragmentProcessor* fp) : GrProcessorStage(fp) {}
+
+    virtual const GrFragmentProcessor* getProcessor() const {
+        return static_cast<const GrFragmentProcessor*>(fProc.get());
+    }
+
+    typedef GrFragmentProcessor   Processor;
+    typedef GrGLFragmentProcessor GLProcessor;
+};
+
+class GrGeometryStage : public GrProcessorStage {
+public:
+    GrGeometryStage(const GrGeometryProcessor* gp) : GrProcessorStage(gp) {}
+
+    virtual const GrGeometryProcessor* getProcessor() const {
+        return static_cast<const GrGeometryProcessor*>(fProc.get());
+    }
+
+    typedef GrGeometryProcessor   Processor;
+    typedef GrGLGeometryProcessor GLProcessor;
 };
 
 #endif