Solo gp

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 GrEffectStage_DEFINED
-#define GrEffectStage_DEFINED
+#ifndef GrProcessorStage_DEFINED
+#define GrProcessorStage_DEFINED
 
-#include "GrBackendEffectFactory.h"
+#include "GrBackendProcessorFactory.h"
 #include "GrCoordTransform.h"
-#include "GrEffect.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 GrEffectStage {
+class GrProcessorStage {
 public:
-    explicit GrEffectStage(const GrEffect* effect)
-    : fEffect(SkRef(effect)) {
+    explicit GrProcessorStage(const GrProcessor* proc)
+    : fProc(SkRef(proc)) {
         fCoordChangeMatrixSet = false;
     }
 
-    GrEffectStage(const GrEffectStage& other) {
+    GrProcessorStage(const GrProcessorStage& other) {
         fCoordChangeMatrixSet = other.fCoordChangeMatrixSet;
         if (other.fCoordChangeMatrixSet) {
             fCoordChangeMatrix = other.fCoordChangeMatrix;
         }
-        fEffect.initAndRef(other.fEffect);
+        fProc.initAndRef(other.fProc);
     }
     
-    static bool AreCompatible(const GrEffectStage& a, const GrEffectStage& b,
+    static bool AreCompatible(const GrProcessorStage& a, const GrProcessorStage& b,
                               bool usingExplicitLocalCoords) {
-        SkASSERT(a.fEffect.get());
-        SkASSERT(b.fEffect.get());
+        SkASSERT(a.fProc.get());
+        SkASSERT(b.fProc.get());
 
-        if (!a.getEffect()->isEqual(*b.getEffect())) {
+        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.
         if (usingExplicitLocalCoords) {
             return true;
         }
 
         if (a.fCoordChangeMatrixSet != b.fCoordChangeMatrixSet) {
@@ skipping 23 matching lines @@
     }
 
     class SavedCoordChange {
     public:
         SkDEBUGCODE(SavedCoordChange() : fEffectUniqueID(SK_InvalidUniqueID) {})
     private:
         bool fCoordChangeMatrixSet;
         SkMatrix fCoordChangeMatrix;
         SkDEBUGCODE(mutable uint32_t fEffectUniqueID;)
 
-        friend class GrEffectStage;
+        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;
         if (fCoordChangeMatrixSet) {
             savedCoordChange->fCoordChangeMatrix = fCoordChangeMatrix;
         }
         SkASSERT(SK_InvalidUniqueID == savedCoordChange->fEffectUniqueID);
-        SkDEBUGCODE(savedCoordChange->fEffectUniqueID = fEffect->getUniqueID();)
+        SkDEBUGCODE(savedCoordChange->fEffectUniqueID = fProc->getUniqueID();)
     }
 
     /**
      * This balances the saveCoordChange call.
      */
     void restoreCoordChange(const SavedCoordChange& savedCoordChange) {
         fCoordChangeMatrixSet = savedCoordChange.fCoordChangeMatrixSet;
         if (fCoordChangeMatrixSet) {
             fCoordChangeMatrix = savedCoordChange.fCoordChangeMatrix;
         }
-        SkASSERT(savedCoordChange.fEffectUniqueID == fEffect->getUniqueID());
+        SkASSERT(savedCoordChange.fEffectUniqueID == fProc->getUniqueID());
         SkDEBUGCODE(savedCoordChange.fEffectUniqueID = SK_InvalidUniqueID);
     }
 
     /**
-     * Gets the matrix representing all changes of coordinate system since the GrEffect was
+     * Gets the matrix representing all changes of coordinate system since the GrProcessor was
      * installed in the stage.
      */
     const SkMatrix& getCoordChangeMatrix() const {
         if (fCoordChangeMatrixSet) {
             return fCoordChangeMatrix;
         } else {
             return SkMatrix::I();
         }
     }
 
     bool isPerspectiveCoordTransform(int matrixIndex, bool useExplicitLocalCoords) const {
-        const GrCoordTransform& coordTransform = this->getEffect()->coordTransform(matrixIndex);
+        const GrCoordTransform& coordTransform = this->getProcessor()->coordTransform(matrixIndex);
         SkMatrix::TypeMask type0 = coordTransform.getMatrix().getType();
         SkMatrix::TypeMask type1 = SkMatrix::kIdentity_Mask;
         if (kLocal_GrCoordSet == coordTransform.sourceCoords()) {
           type1 = useExplicitLocalCoords ?
                   SkMatrix::kIdentity_Mask : this->getCoordChangeMatrix().getType();
         }
 
         int combinedTypes = type0 | type1;
         if (SkMatrix::kPerspective_Mask & combinedTypes) {
           return true;
         } else {
           return false;
         }
     }
 
-    const GrEffect* getEffect() const { return fEffect.get(); }
+    const GrProcessor* getProcessor() const { return fProc.get(); }
 
-    void convertToPendingExec() { fEffect.convertToPendingExec(); }
+    void convertToPendingExec() { fProc.convertToPendingExec(); }
 
 private:
-    bool                                fCoordChangeMatrixSet;
-    SkMatrix                            fCoordChangeMatrix;
-    GrProgramElementRef<const GrEffect> fEffect;
+    bool                                   fCoordChangeMatrixSet;
+    SkMatrix                               fCoordChangeMatrix;
+    GrProgramElementRef<const GrProcessor> fProc;
+};
+
+class GrFragmentStage : public GrProcessorStage {
+public:
+    GrFragmentStage(const GrFragmentProcessor* fp) : GrProcessorStage(fp) {}
+
+    const GrFragmentProcessor* getFragmentProcessor() const {
+        return static_cast<const GrFragmentProcessor*>(this->getProcessor());

[bsalomon, 2014/09/22 14:56:38]

Is the base class ever useful? I wonder if we should hide it's getProcesor
function in the protected section and only use the derived classes.

[joshua.litt, 2014/09/22 18:14:44]

Well, its useful a bit right now.  Let me further refactor program builder.  It
may turn out we end up keeping these two classes entirely separated.

+    }
+};
+
+class GrGeometryStage : public GrProcessorStage {
+public:
+    GrGeometryStage(const GrGeometryProcessor* gp) : GrProcessorStage(gp) {}
+
+    const GrGeometryProcessor* getGeometryProcessor() const {
+        return static_cast<const GrGeometryProcessor*>(this->getProcessor());
+    }
 };
 
 #endif