Fix few inconsistencies in handling fixed-function texture coordinate set generation

src/gpu/gl/GrGpuGL.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "GrGpuGL.h"
 #include "GrGLStencilBuffer.h"
@@ skipping 2086 matching lines @@
 
     GrGLfloat glMatrix[4 * 4];
     fHWProjectionMatrixState.getGLMatrix<4>(glMatrix);
     GL_CALL(MatrixMode(GR_GL_PROJECTION));
     GL_CALL(LoadMatrixf(glMatrix));
 }
 
 void GrGpuGL::enableTexGen(int unitIdx,
                            TexGenComponents components,
                            const GrGLfloat* coefficients) {
-
     SkASSERT(this->glCaps().fixedFunctionSupport());
-    SkASSERT(this->caps()->pathRenderingSupport());
     SkASSERT(components >= kS_TexGenComponents && components <= kSTR_TexGenComponents);
     SkASSERT(this->glCaps().maxFixedFunctionTextureCoords() >= unitIdx);
 
     if (GR_GL_OBJECT_LINEAR == fHWTexGenSettings[unitIdx].fMode &&
         components == fHWTexGenSettings[unitIdx].fNumComponents &&
         !memcmp(coefficients, fHWTexGenSettings[unitIdx].fCoefficients,
                 3 * components * sizeof(GrGLfloat))) {
         return;
     }
 
@@ skipping 15 matching lines @@
     fHWTexGenSettings[unitIdx].fNumComponents = components;
 
     for (int i = 0; i < components; i++) {
         GrGLfloat plane[] = {coefficients[0 + 3 * i],
                              coefficients[1 + 3 * i],
                              0,
                              coefficients[2 + 3 * i]};
         GL_CALL(TexGenfv(GR_GL_S + i, GR_GL_OBJECT_PLANE, plane));
     }
 
-    GL_CALL(PathTexGen(GR_GL_TEXTURE0 + unitIdx,
-                       GR_GL_OBJECT_LINEAR,
-                       components,
-                       coefficients));
+    if (this->caps()->pathRenderingSupport()) {
+        GL_CALL(PathTexGen(GR_GL_TEXTURE0 + unitIdx,
+                           GR_GL_OBJECT_LINEAR,
+                           components,
+                           coefficients));
+    }
 
     memcpy(fHWTexGenSettings[unitIdx].fCoefficients, coefficients,
            3 * components * sizeof(GrGLfloat));
-
-    fHWActiveTexGenSets = SkTMax(fHWActiveTexGenSets, unitIdx);
 }
 
 void GrGpuGL::enableTexGen(int unitIdx, TexGenComponents components, const SkMatrix& matrix) {
-
     GrGLfloat coefficients[3 * 3];
     SkASSERT(this->glCaps().fixedFunctionSupport());
     SkASSERT(components >= kS_TexGenComponents && components <= kSTR_TexGenComponents);
 
     coefficients[0] = SkScalarToFloat(matrix[SkMatrix::kMScaleX]);
     coefficients[1] = SkScalarToFloat(matrix[SkMatrix::kMSkewX]);
     coefficients[2] = SkScalarToFloat(matrix[SkMatrix::kMTransX]);
 
     if (components >= kST_TexGenComponents) {
         coefficients[3] = SkScalarToFloat(matrix[SkMatrix::kMSkewY]);
         coefficients[4] = SkScalarToFloat(matrix[SkMatrix::kMScaleY]);
         coefficients[5] = SkScalarToFloat(matrix[SkMatrix::kMTransY]);
     }
 
     if (components >= kSTR_TexGenComponents) {
         coefficients[6] = SkScalarToFloat(matrix[SkMatrix::kMPersp0]);
         coefficients[7] = SkScalarToFloat(matrix[SkMatrix::kMPersp1]);
         coefficients[8] = SkScalarToFloat(matrix[SkMatrix::kMPersp2]);
     }
 
     enableTexGen(unitIdx, components, coefficients);
 }
 
-void GrGpuGL::disableUnusedTexGen(int numUsedTexCoordSets) {
-
+void GrGpuGL::flushTexGenSettings(int numUsedTexCoordSets) {
     SkASSERT(this->glCaps().fixedFunctionSupport());
     SkASSERT(this->glCaps().maxFixedFunctionTextureCoords() >= numUsedTexCoordSets);
 
+    // Only write the inactive tex gens, since active tex gens were written
+    // when they were enabled.
+
+    SkDEBUGCODE(
+        for (int i = 0; i < numUsedTexCoordSets; i++) {
+            SkASSERT(0 != fHWTexGenSettings[i].fNumComponents);
+        }
+    );
+
     for (int i = numUsedTexCoordSets; i < fHWActiveTexGenSets; i++) {
-        if (0 == fHWTexGenSettings[i].fNumComponents) {
-            continue;
-        }
+        SkASSERT(0 != fHWTexGenSettings[i].fNumComponents);
 
         this->setTextureUnit(i);
         for (int j = 0; j < fHWTexGenSettings[i].fNumComponents; j++) {
             GL_CALL(Disable(GR_GL_TEXTURE_GEN_S + j));
         }
-        GL_CALL(PathTexGen(GR_GL_TEXTURE0 + i, GR_GL_NONE, 0, NULL));
+
+        if (this->caps()->pathRenderingSupport()) {
+            GL_CALL(PathTexGen(GR_GL_TEXTURE0 + i, GR_GL_NONE, 0, NULL));
+        }
+
         fHWTexGenSettings[i].fNumComponents = 0;
     }
 
-    fHWActiveTexGenSets = SkTMin(fHWActiveTexGenSets, numUsedTexCoordSets);
+    fHWActiveTexGenSets = numUsedTexCoordSets;
 }
 
 void GrGpuGL::flushMiscFixedFunctionState() {
 
     const GrDrawState& drawState = this->getDrawState();
 
     if (drawState.isDitherState()) {
         if (kYes_TriState != fHWDitherEnabled) {
             GL_CALL(Enable(GR_GL_DITHER));
             fHWDitherEnabled = kYes_TriState;
@@ skipping 467 matching lines @@
             this->setVertexArrayID(gpu, 0);
         }
         int attrCount = gpu->glCaps().maxVertexAttributes();
         if (fDefaultVertexArrayAttribState.count() != attrCount) {
             fDefaultVertexArrayAttribState.resize(attrCount);
         }
         attribState = &fDefaultVertexArrayAttribState;
     }
     return attribState;
 }