Adds local coords to GrEffect system.

src/gpu/GrDrawState.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrDrawState.h"
 #include "GrPaint.h"
 
@@ skipping 28 matching lines @@
     this->setState(GrDrawState::kDither_StateBit, paint.isDither());
     this->setState(GrDrawState::kHWAntialias_StateBit, paint.isAntiAlias());
 
     this->setBlendFunc(paint.getSrcBlendCoeff(), paint.getDstBlendCoeff());
     this->setColorFilter(paint.getColorFilterColor(), paint.getColorFilterMode());
     this->setCoverage(paint.getCoverage());
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
-namespace {
-
-/**
- * This function generates a mask that we like to have known at compile
- * time. When the number of stages is bumped or the way bits are defined in
- * GrDrawState.h changes this function should be rerun to generate the new mask.
- * (We attempted to force the compiler to generate the mask using recursive
- * templates but always wound up with static initializers under gcc, even if
- * they were just a series of immediate->memory moves.)
- *
- */
-void gen_tex_coord_mask(GrAttribBindings* texCoordMask) {
-    *texCoordMask = 0;
-    for (int s = 0; s < GrDrawState::kNumStages; ++s) {
-        *texCoordMask |= GrDrawState::ExplicitTexCoordAttribBindingsBit(s);
-    }
-}
-
-const GrAttribBindings kTexCoord_AttribBindingsMask = (1 << GrDrawState::kNumStages)-1;
-
-} //unnamed namespace
-
 const size_t GrDrawState::kVertexAttribSizes[kGrVertexAttribTypeCount] = {
     sizeof(float),          // kFloat_GrVertexAttribType
     2*sizeof(float),        // kVec2_GrVertexAttribType
     3*sizeof(float),        // kVec3_GrVertexAttribType
     4*sizeof(float),        // kVec4_GrVertexAttribType
     4*sizeof(char)          // kCVec4_GrVertexAttribType
 };
 
 static size_t vertex_size(const GrVertexAttrib* attribs, int count) {
     // this works as long as we're 4 byte-aligned
@@ skipping 18 matching lines @@
 
 size_t GrDrawState::getVertexSize() const {
     return vertex_size(fVertexAttribs.begin(), fVertexAttribs.count());
 }
 
 const GrAttribBindings GrDrawState::kAttribIndexMasks[kAttribIndexCount] = {
     0,                            // position is not reflected in the bindings
     kColor_AttribBindingsBit,
     kCoverage_AttribBindingsBit,
     kEdge_AttribBindingsBit,
-    kTexCoord_AttribBindingsMask
+    kLocalCoords_AttribBindingsBit,
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 
 void GrDrawState::setVertexAttribs(const GrVertexAttrib* attribs, int count) {
     GrAssert(count <= GrDrawState::kAttribIndexCount);
     fVertexAttribs.reset();
     for (int index = 0; index < count; ++index) {
         fVertexAttribs.push_back(attribs[index]);
     }
@@ skipping 83 matching lines @@
                 attributeTypes[attributeIndex] != attributeType) {
                 return false;
             }
             attributeTypes[attributeIndex] = attributeType;
         }
     }
 
     return true;
 }
 
-////////////////////////////////////////////////////////////////////////////////
-
-bool GrDrawState::AttributesBindExplicitTexCoords(GrAttribBindings attribBindings) {
-    return SkToBool(kTexCoord_AttribBindingsMask & attribBindings);
-}
-
-////////////////////////////////////////////////////////////////////////////////
 
 void GrDrawState::VertexAttributesUnitTest() {
-    // Ensure that our tex coord mask is correct
-    GrAttribBindings texCoordMask;
-    gen_tex_coord_mask(&texCoordMask);
-    GrAssert(texCoordMask == kTexCoord_AttribBindingsMask);
-
     // not necessarily exhaustive
     static bool run;
     if (!run) {
         run = true;
 
         GrVertexAttribArray<6> attribs;
         GrAssert(0 == vertex_size(attribs.begin(), attribs.count()));
 
         GrVertexAttrib currAttrib = {kFloat_GrVertexAttribType, 0};
         attribs.push_back(currAttrib);
@@ skipping 15 matching lines @@
         GrAssert(4*sizeof(char) + 2*sizeof(float) + 3*sizeof(float) ==
                  vertex_size(attribs.begin(), attribs.count()));
         currAttrib.set(kFloat_GrVertexAttribType, attribs[2].fOffset + 3*sizeof(float));
         attribs.push_back(currAttrib);
         GrAssert(4*sizeof(char) + 2*sizeof(float) + 3*sizeof(float) + sizeof(float) ==
                  vertex_size(attribs.begin(), attribs.count()));
         currAttrib.set(kVec4f_GrVertexAttribType, attribs[3].fOffset + sizeof(float));
         attribs.push_back(currAttrib);
         GrAssert(4*sizeof(char) + 2*sizeof(float) + 3*sizeof(float) + sizeof(float) + 4*sizeof(float) ==
                  vertex_size(attribs.begin(), attribs.count()));
-
-        GrAttribBindings tcMask = 0;
-        GrAssert(!AttributesBindExplicitTexCoords(0));
-        for (int s = 0; s < GrDrawState::kNumStages; ++s) {
-            tcMask |= ExplicitTexCoordAttribBindingsBit(s);
-            GrAssert(AttributesBindExplicitTexCoords(tcMask));
-            GrAssert(StageBindsExplicitTexCoords(tcMask, s));
-            for (int s2 = s + 1; s2 < GrDrawState::kNumStages; ++s2) {
-                GrAssert(!StageBindsExplicitTexCoords(tcMask, s2));
-            }
-        }
-        GrAssert(kTexCoord_AttribBindingsMask == tcMask);
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
-bool GrDrawState::StageBindsExplicitTexCoords(GrAttribBindings bindings, int stageIdx) {
-    return SkToBool(bindings & ExplicitTexCoordAttribBindingsBit(stageIdx));
-}
-
 bool GrDrawState::srcAlphaWillBeOne(GrAttribBindings bindings) const {
 
     uint32_t validComponentFlags;
     GrColor color;
     // Check if per-vertex or constant color may have partial alpha
     if (bindings & kColor_AttribBindingsBit) {
         validComponentFlags = 0;
         color = 0; // not strictly necessary but we get false alarms from tools about uninit.
     } else {
         validComponentFlags = GrEffect::kAll_ValidComponentFlags;
@@ skipping 200 matching lines @@
         for (int s = 0; s < GrDrawState::kNumStages; ++s) {
             if (fRestoreMask & (1 << s)) {
                 fDrawState->fStages[s].restoreCoordChange(fSavedCoordChanges[s]);
             }
         }
     }
     fDrawState = NULL;
 }
 
 void GrDrawState::AutoViewMatrixRestore::set(GrDrawState* drawState,
-                                             const SkMatrix& preconcatMatrix,
-                                             uint32_t explicitCoordStageMask) {
+                                             const SkMatrix& preconcatMatrix) {
     this->restore();
 
     fDrawState = drawState;
     if (NULL == drawState) {
         return;
     }
 
     fRestoreMask = 0;
     fViewMatrix = drawState->getViewMatrix();
     drawState->preConcatViewMatrix(preconcatMatrix);
     for (int s = 0; s < GrDrawState::kNumStages; ++s) {
-        if (!(explicitCoordStageMask & (1 << s)) && drawState->isStageEnabled(s)) {
+        if (drawState->isStageEnabled(s)) {
             fRestoreMask |= (1 << s);
             fDrawState->fStages[s].saveCoordChange(&fSavedCoordChanges[s]);
-            drawState->fStages[s].preConcatCoordChange(preconcatMatrix);
+            drawState->fStages[s].localCoordChange(preconcatMatrix);
         }
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 void GrDrawState::AutoDeviceCoordDraw::restore() {
     if (NULL != fDrawState) {
         fDrawState->setViewMatrix(fViewMatrix);
         for (int s = 0; s < GrDrawState::kNumStages; ++s) {
             if (fRestoreMask & (1 << s)) {
                 fDrawState->fStages[s].restoreCoordChange(fSavedCoordChanges[s]);
             }
         }
     }
     fDrawState = NULL;
 }
 
-bool GrDrawState::AutoDeviceCoordDraw::set(GrDrawState* drawState,
-                                           uint32_t explicitCoordStageMask) {
+bool GrDrawState::AutoDeviceCoordDraw::set(GrDrawState* drawState) {
     GrAssert(NULL != drawState);
 
     this->restore();
 
     fDrawState = drawState;
     if (NULL == fDrawState) {
         return false;
     }
 
     fViewMatrix = drawState->getViewMatrix();
     fRestoreMask = 0;
     SkMatrix invVM;
     bool inverted = false;
 
     for (int s = 0; s < GrDrawState::kNumStages; ++s) {
-        if (!(explicitCoordStageMask & (1 << s)) && drawState->isStageEnabled(s)) {
+        if (drawState->isStageEnabled(s)) {
             if (!inverted && !fViewMatrix.invert(&invVM)) {
                 // sad trombone sound
                 fDrawState = NULL;
                 return false;
             } else {
                 inverted = true;
             }
             fRestoreMask |= (1 << s);
             GrEffectStage* stage = drawState->fStages + s;
             stage->saveCoordChange(&fSavedCoordChanges[s]);
-            stage->preConcatCoordChange(invVM);
+            stage->localCoordChange(invVM);
         }
     }
     drawState->viewMatrix()->reset();
     return true;
 }