Adds local coords to GrEffect system.

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 239 matching lines @@
 
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
     /// @name Attribute Bindings
     ////
 
     /**
      * The vertex data used by the current program is represented as a bitfield
      * of flags. Programs always use positions and may also use texture
-     * coordinates, per-vertex colors, per-vertex coverage and edge data. Each
-     * stage can use the explicit texture coordinates as its input texture
-     * coordinates or it may use the positions as texture coordinates.
+     * coordinates, per-vertex colors, per-vertex coverage and edge data. The
+     * local coords accessible by effects may either come from positions or
+     * be specified explicitly.
      */
 
     /**
-     * Generates a bit indicating that a texture stage uses texture coordinates
-     *
-     * @param stageIdx    the stage that will use texture coordinates.
-     *
-     * @return the bit to add to a GrAttribBindings bitfield.
-     */
-    static int ExplicitTexCoordAttribBindingsBit(int stageIdx) {
-        GrAssert(stageIdx < kNumStages);
-        return (1 << stageIdx);
-    }
-
-    static bool StageBindsExplicitTexCoords(GrAttribBindings bindings, int stageIdx);
-
-    /**
      * Additional Bits that can be specified in GrAttribBindings.
      */
     enum AttribBindingsBits {
+        /** explicit local coords are provided (instead of using pre-view-matrix positions) */
+        kLocalCoords_AttribBindingsBit        = 0x1,
         /* program uses colors (GrColor) */
-        kColor_AttribBindingsBit              = 1 << (kNumStages + 0),
+        kColor_AttribBindingsBit              = 0x2,
         /* program uses coverage (GrColor)
          */
-        kCoverage_AttribBindingsBit           = 1 << (kNumStages + 1),
+        kCoverage_AttribBindingsBit           = 0x4,
         /* program uses edge data. Distance to the edge is used to
          * compute a coverage. See GrDrawState::setVertexEdgeType().
          */
-        kEdge_AttribBindingsBit               = 1 << (kNumStages + 2),
+        kEdge_AttribBindingsBit               = 0x8,
         // for below assert
         kDummyAttribBindingsBit,
         kHighAttribBindingsBit = kDummyAttribBindingsBit - 1
     };
     // make sure we haven't exceeded the number of bits in GrAttribBindings.
     GR_STATIC_ASSERT(kHighAttribBindingsBit < ((uint64_t)1 << 8*sizeof(GrAttribBindings)));
 
     enum AttribBindings {
         kDefault_AttribBindings = 0
     };
 
     /**
      *  Sets attribute bindings for next draw.
      *
      *  @param bindings    the attribute bindings to set.
      */
     void setAttribBindings(GrAttribBindings bindings) { fCommon.fAttribBindings = bindings; }
 
     GrAttribBindings getAttribBindings() const { return fCommon.fAttribBindings; }
 
     ////////////////////////////////////////////////////////////////////////////
     // Helpers for picking apart attribute bindings
 
     /**
-     * Helper function to determine if program uses explicit texture
-     * coordinates.
-     *
-     * @param  bindings  attribute bindings to query
-     *
-     * @return true if program uses texture coordinates,
-     *         false otherwise.
-     */
-    static bool AttributesBindExplicitTexCoords(GrAttribBindings bindings);
-
-    /**
      * Determines whether src alpha is guaranteed to be one for all src pixels
      */
     bool srcAlphaWillBeOne(GrAttribBindings) const;
 
     /**
      * Determines whether the output coverage is guaranteed to be one for all pixels hit by a draw.
      */
     bool hasSolidCoverage(GrAttribBindings) const;
 
     static void VertexAttributesUnitTest();
@@ skipping 12 matching lines @@
      * attribute index if we're binding attributes in GL.
      *
      * Indices which do not have active attribute bindings will be ignored.
      */
 
     enum AttribIndex {
         kPosition_AttribIndex = 0,
         kColor_AttribIndex,
         kCoverage_AttribIndex,
         kEdge_AttribIndex,
-        kTexCoord_AttribIndex,
+        kLocalCoords_AttribIndex,
 
-        kLast_AttribIndex = kTexCoord_AttribIndex
+        kLast_AttribIndex = kLocalCoords_AttribIndex
     };
     static const int kAttribIndexCount = kLast_AttribIndex + 1;
 
     // these are used when vertex color and coverage isn't set
     enum {
         kColorOverrideAttribIndexValue = GrDrawState::kVertexAttribCnt,
         kCoverageOverrideAttribIndexValue = GrDrawState::kVertexAttribCnt+1,
     };
 
     ////////////////////////////////////////////////////////////////////////////
@@ skipping 31 matching lines @@
      *  (r,g,b,a) = (alpha, alpha, alpha, alpha).
      *
      *  @param alpha The alpha value to set as the color.
      */
     void setAlpha(uint8_t a) {
         this->setColor((a << 24) | (a << 16) | (a << 8) | a);
     }
 
     /**
      * Add a color filter that can be represented by a color and a mode. Applied
-     * after color-computing texture stages.
+     * after color-computing effect stages.
      */
     void setColorFilter(GrColor c, SkXfermode::Mode mode) {
         fCommon.fColorFilterColor = c;
         fCommon.fColorFilterMode = mode;
     }
 
     GrColor getColorFilterColor() const { return fCommon.fColorFilterColor; }
     SkXfermode::Mode getColorFilterMode() const { return fCommon.fColorFilterMode; }
 
     /**
@@ skipping 61 matching lines @@
     /// @name Effect Stages
     ////
 
     const GrEffectRef* setEffect(int stageIdx, const GrEffectRef* effect,
                                  const int* indices = NULL) {
         fStages[stageIdx].setEffect(effect, indices);
         return effect;
     }
 
     /**
-     * Creates a GrSimpleTextureEffect.
+     * Creates a GrSimpleTextureEffect that uses local coords as texture coordinates.
      */
     void createTextureEffect(int stageIdx, GrTexture* texture, const SkMatrix& matrix) {
         GrAssert(!this->getStage(stageIdx).getEffect());
         GrEffectRef* effect = GrSimpleTextureEffect::Create(texture, matrix);
         this->setEffect(stageIdx, effect)->unref();
     }
     void createTextureEffect(int stageIdx,
                              GrTexture* texture,
                              const SkMatrix& matrix,
                              const GrTextureParams& params) {
@@ skipping 38 matching lines @@
 
     /**
      * Returns the current stage by index.
      */
     const GrEffectStage& getStage(int stageIdx) const {
         GrAssert((unsigned)stageIdx < kNumStages);
         return fStages[stageIdx];
     }
 
     /**
-     * Called when the source coord system is changing. preConcat gives the transformation from the
-     * old coord system to the new coord system.
+     * Called when the source coord system is changing. This ensures that effects will see the
+     * correct local coordinates. oldToNew gives the transformation from the old coord system in
+     * which the geometry was specified to the new coordinate system from which it will be rendered.
      */
-    void preConcatStageMatrices(const SkMatrix& preConcat) {
-        this->preConcatStageMatrices(~0U, preConcat);
-    }
-    /**
-     * Version of above that applies the update matrix selectively to stages via a mask.
-     */
-    void preConcatStageMatrices(uint32_t stageMask, const SkMatrix& preConcat) {
+    void localCoordChange(const SkMatrix& oldToNew) {
         for (int i = 0; i < kNumStages; ++i) {
-            if (((1 << i) & stageMask) && this->isStageEnabled(i)) {
-                fStages[i].preConcatCoordChange(preConcat);
+            if (this->isStageEnabled(i)) {
+                fStages[i].localCoordChange(oldToNew);
             }
         }
     }
 
-    /**
-     * Called when the source coord system is changing. preConcatInverse is the inverse of the
-     * transformation from the old coord system to the new coord system. Returns false if the matrix
-     * cannot be inverted.
-     */
-    bool preConcatStageMatricesWithInverse(const SkMatrix& preConcatInverse) {
-        SkMatrix inv;
-        bool computed = false;
-        for (int i = 0; i < kNumStages; ++i) {
-            if (this->isStageEnabled(i)) {
-                if (!computed && !preConcatInverse.invert(&inv)) {
-                    return false;
-                } else {
-                    computed = true;
-                }
-                fStages[i].preConcatCoordChange(preConcatInverse);
-            }
-        }
-        return true;
-    }
-
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
     /// @name Coverage / Color Stages
     ////
 
     /**
      * A common pattern is to compute a color with the initial stages and then
      * modulate that color by a coverage value in later stage(s) (AA, mask-
      * filters, glyph mask, etc). Color-filters, xfermodes, etc should be
@@ skipping 218 matching lines @@
     ////////////////////////////////////////////////////////////////////////////
 
     /**
      * Preconcats the current view matrix and restores the previous view matrix in the destructor.
      * Effect matrices are automatically adjusted to compensate.
      */
     class AutoViewMatrixRestore : public ::GrNoncopyable {
     public:
         AutoViewMatrixRestore() : fDrawState(NULL) {}
 
-        AutoViewMatrixRestore(GrDrawState* ds,
-                              const SkMatrix& preconcatMatrix,
-                              uint32_t explicitCoordStageMask = 0) {
+        AutoViewMatrixRestore(GrDrawState* ds, const SkMatrix& preconcatMatrix) {
             fDrawState = NULL;
-            this->set(ds, preconcatMatrix, explicitCoordStageMask);
+            this->set(ds, preconcatMatrix);
         }
 
         ~AutoViewMatrixRestore() { this->restore(); }
 
         /**
          * Can be called prior to destructor to restore the original matrix.
          */
         void restore();
 
-        void set(GrDrawState* drawState,
-                 const SkMatrix& preconcatMatrix,
-                 uint32_t explicitCoordStageMask = 0);
+        void set(GrDrawState* drawState, const SkMatrix& preconcatMatrix);
 
         bool isSet() const { return NULL != fDrawState; }
 
     private:
         GrDrawState*                        fDrawState;
         SkMatrix                            fViewMatrix;
         GrEffectStage::SavedCoordChange     fSavedCoordChanges[GrDrawState::kNumStages];
         uint32_t                            fRestoreMask;
     };
 
     ////////////////////////////////////////////////////////////////////////////
 
     /**
      * This sets the view matrix to identity and adjusts stage matrices to compensate. The
      * destructor undoes the changes, restoring the view matrix that was set before the
      * constructor. It is similar to passing the inverse of the current view matrix to
      * AutoViewMatrixRestore, but lazily computes the inverse only if necessary.
      */
     class AutoDeviceCoordDraw : ::GrNoncopyable {
     public:
         AutoDeviceCoordDraw() : fDrawState(NULL) {}
         /**
          * If a stage's texture matrix is applied to explicit per-vertex coords, rather than to
          * positions, then we don't want to modify its matrix. The explicitCoordStageMask is used
          * to specify such stages.
          */
-        AutoDeviceCoordDraw(GrDrawState* drawState,
-                            uint32_t explicitCoordStageMask = 0) {
+        AutoDeviceCoordDraw(GrDrawState* drawState) {
             fDrawState = NULL;
-            this->set(drawState, explicitCoordStageMask);
+            this->set(drawState);
         }
 
         ~AutoDeviceCoordDraw() { this->restore(); }
 
-        bool set(GrDrawState* drawState, uint32_t explicitCoordStageMask = 0);
+        bool set(GrDrawState* drawState);
 
         /**
          * Returns true if this object was successfully initialized on to a GrDrawState. It may
          * return false because a non-default constructor or set() were never called or because
          * the view matrix was not invertible.
          */
         bool succeeded() const { return NULL != fDrawState; }
 
         /**
          * Returns the matrix that was set previously set on the drawState. This is only valid
@@ skipping 296 matching lines @@
     }
 
     bool operator ==(const GrDrawState& s) const {
         if (fRenderTarget.get() != s.fRenderTarget.get() || fCommon != s.fCommon) {
             return false;
         }
         if (fVertexAttribs != s.fVertexAttribs) {
             return false;
         }
         for (int i = 0; i < kAttribIndexCount; ++i) {
-            if ((i == kPosition_AttribIndex ||
-                    s.fCommon.fAttribBindings & kAttribIndexMasks[i]) &&
+            if ((i == kPosition_AttribIndex || s.fCommon.fAttribBindings & (1 << i)) &&
                 fAttribIndices[i] != s.fAttribIndices[i]) {
                 return false;
             }
         }
         for (int i = 0; i < kNumStages; i++) {
             bool enabled = this->isStageEnabled(i);
             if (enabled != s.isStageEnabled(i)) {
                 return false;
             }
             if (enabled && this->fStages[i] != s.fStages[i]) {
@@ skipping 153 matching lines @@
     int                                    fAttribIndices[kAttribIndexCount];
     GrVertexAttribArray<kVertexAttribCnt>  fVertexAttribs;
     GrEffectStage                          fStages[kNumStages];
 
     typedef GrRefCnt INHERITED;
 };
 
 GR_MAKE_BITFIELD_OPS(GrDrawState::BlendOptFlags);
 
 #endif