Enable vertexless shading when path rendering is supported

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 106 matching lines @@
 
 GrGpuGL::GrGpuGL(const GrGLContext& ctx, GrContext* context)
     : GrGpu(context)
     , fGLContext(ctx) {
 
     SkASSERT(ctx.isInitialized());
 
     fCaps.reset(SkRef(ctx.info().caps()));
 
     fHWBoundTextures.reset(ctx.info().caps()->maxFragmentTextureUnits());
+    fHWTexGenSettings.reset(ctx.info().caps()->maxFixedFunctionTextureCoords());
 
     fillInConfigRenderableTable();
 
 
     GrGLClearErr(fGLContext.interface());
 
     if (gPrintStartupSpew) {
         const GrGLubyte* vendor;
         const GrGLubyte* renderer;
         const GrGLubyte* version;
@@ skipping 233 matching lines @@
         // we don't use the model view matrix.
         GL_CALL(MatrixMode(GR_GL_MODELVIEW));
         GL_CALL(LoadIdentity());
 
         for (int i = 0; i < this->glCaps().maxFixedFunctionTextureCoords(); ++i) {
             GL_CALL(ActiveTexture(GR_GL_TEXTURE0 + i));
             GL_CALL(Disable(GR_GL_TEXTURE_GEN_S));
             GL_CALL(Disable(GR_GL_TEXTURE_GEN_T));
             GL_CALL(Disable(GR_GL_TEXTURE_GEN_Q));
             GL_CALL(Disable(GR_GL_TEXTURE_GEN_R));
+            fHWTexGenSettings[i].fMode = GR_GL_NONE;
+            fHWTexGenSettings[i].fNumComponents = 0;
         }
+        fHWActiveTexGenUnits = 0;
     }
 
     // we assume these values
     if (resetBits & kPixelStore_GrGLBackendState) {
         if (this->glCaps().unpackRowLengthSupport()) {
             GL_CALL(PixelStorei(GR_GL_UNPACK_ROW_LENGTH, 0));
         }
         if (this->glCaps().packRowLengthSupport()) {
             GL_CALL(PixelStorei(GR_GL_PACK_ROW_LENGTH, 0));
         }
@@ skipping 1714 matching lines @@
             GL_CALL(TexParameteri(GR_GL_TEXTURE_2D, GR_GL_TEXTURE_SWIZZLE_A, swizzle[3]));
         } else {
             GR_STATIC_ASSERT(sizeof(newTexParams.fSwizzleRGBA[0]) == sizeof(GrGLint));
             const GrGLint* swizzle = reinterpret_cast<const GrGLint*>(newTexParams.fSwizzleRGBA);
             GL_CALL(TexParameteriv(GR_GL_TEXTURE_2D, GR_GL_TEXTURE_SWIZZLE_RGBA, swizzle));
         }
     }
     texture->setCachedTexParams(newTexParams, this->getResetTimestamp());
 }
 
+void GrGpuGL::setProjectionMatrix(const SkMatrix& matrix,
+                                  const SkISize& renderTargetSize,
+                                  GrSurfaceOrigin renderTargetOrigin) {
+
+    SkASSERT(this->glCaps().fixedFunctionSupport());
+
+    if (renderTargetOrigin == fHWProjectionMatrixState.fRenderTargetOrigin &&
+        renderTargetSize == fHWProjectionMatrixState.fRenderTargetSize &&
+        matrix.cheapEqualTo(fHWProjectionMatrixState.fViewMatrix)) {
+        return;
+    }
+
+    fHWProjectionMatrixState.fViewMatrix = matrix;
+    fHWProjectionMatrixState.fRenderTargetSize = renderTargetSize;
+    fHWProjectionMatrixState.fRenderTargetOrigin = renderTargetOrigin;
+
+    GrGLfloat glMatrix[4 * 4];
+    fHWProjectionMatrixState.getGLMatrix<4>(glMatrix);

[Mark Kilgard, 2013/09/10 02:13:48]

glMatrixLoadfEXT opportunity

+    GL_CALL(MatrixMode(GR_GL_PROJECTION));
+    GL_CALL(LoadMatrixf(glMatrix));
+}
+
+void GrGpuGL::enableTexGen(int unitIdx, int numComponents, const GrGLfloat* coefficients) {
+
+    SkASSERT(this->glCaps().fixedFunctionSupport());
+    SkASSERT(numComponents <= 3 && numComponents > 0);
+
+    if (GR_GL_OBJECT_LINEAR == fHWTexGenSettings[unitIdx].fMode &&
+        numComponents == fHWTexGenSettings[unitIdx].fNumComponents &&
+        !memcmp(coefficients, fHWTexGenSettings[unitIdx].fCoefficients,
+                3 * numComponents * sizeof(GrGLfloat))) {
+        return;
+    }
+

[Mark Kilgard, 2013/09/10 02:13:48]

It would be nice if we did *either* the fixed-function vertex validation (many
glEnable & glTexGen commands) or the single glPathTexGenNV command based on
which was actually necessary.

Can we reasonably do one or the other?

Perhaps have two routines:
1) enableTexGenFixedFunction
2) enableTexGenNVpr

And call the appropriate one?

[bsalomon, 2013/09/10 13:51:06]

seems reasonable

+    setTextureUnit(unitIdx);

[bsalomon, 2013/09/10 13:51:06]

style nit: this->setTextureUnit(unitIdx);

(we use this-> when calling members within a class)

+

[Mark Kilgard, 2013/09/10 02:13:48]

Instead of glActiveTexture/glTexGeni/glEnable/glDisable/glTexGenfv, you can use
selector free DSA routines to do
glMultiTexGeni/glEnablei/glDisablei/glMultiTexGenfv where you install helper
routines if DSA isn't available to track the active texture.

+    if (GR_GL_OBJECT_LINEAR != fHWTexGenSettings[unitIdx].fMode) {
+        for (int i = 0; i < 4; i++) {
+            GL_CALL(TexGeni(GR_GL_S + i, GR_GL_TEXTURE_GEN_MODE, GR_GL_OBJECT_LINEAR));
+        }
+        fHWTexGenSettings[unitIdx].fMode = GR_GL_OBJECT_LINEAR;
+    }
+
+    for (int i = fHWTexGenSettings[unitIdx].fNumComponents; i < numComponents; i++) {
+        GL_CALL(Enable(GR_GL_TEXTURE_GEN_S + i));
+    }
+    for (int i = numComponents; i < fHWTexGenSettings[unitIdx].fNumComponents; i++) {
+        GL_CALL(Disable(GR_GL_TEXTURE_GEN_S + i));
+    }
+    fHWTexGenSettings[unitIdx].fNumComponents = numComponents;
+
+    for (int i = 0; i < numComponents; 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,
+                       numComponents,
+                       coefficients));
+
+    memcpy(fHWTexGenSettings[unitIdx].fCoefficients, coefficients,
+           3 * numComponents * sizeof(GrGLfloat));
+
+    fHWActiveTexGenUnits = SkTMax(fHWActiveTexGenUnits, unitIdx);
+}
+
+void GrGpuGL::enableTexGen(int unitIdx, int numComponents, const SkMatrix& matrix) {
+
+    GrGLfloat coefficients[9];
+    SkASSERT(this->glCaps().fixedFunctionSupport());
+    SkASSERT(numComponents <= 3 && numComponents > 0);
+
+    coefficients[0] = SkScalarToFloat(matrix[SkMatrix::kMScaleX]);
+    coefficients[1] = SkScalarToFloat(matrix[SkMatrix::kMSkewX]);
+    coefficients[2] = SkScalarToFloat(matrix[SkMatrix::kMTransX]);
+
+    if (numComponents >= 2) {
+        coefficients[3] = SkScalarToFloat(matrix[SkMatrix::kMSkewY]);
+        coefficients[4] = SkScalarToFloat(matrix[SkMatrix::kMScaleY]);
+        coefficients[5] = SkScalarToFloat(matrix[SkMatrix::kMTransY]);
+    }
+
+    if (numComponents >= 3) {
+        coefficients[6] = SkScalarToFloat(matrix[SkMatrix::kMPersp0]);
+        coefficients[7] = SkScalarToFloat(matrix[SkMatrix::kMPersp1]);
+        coefficients[8] = SkScalarToFloat(matrix[SkMatrix::kMPersp2]);
+    }
+
+    enableTexGen(unitIdx, numComponents, coefficients);
+}
+
+void GrGpuGL::disableUnusedTexGenUnits(int numUsedUnits) {
+
+    SkASSERT(this->glCaps().fixedFunctionSupport());
+
+    for (int i = numUsedUnits; i < fHWActiveTexGenUnits; i++) {
+        if (!fHWTexGenSettings[i].fNumComponents) {
+            continue;
+        }
+

[Mark Kilgard, 2013/09/10 02:13:48]

Again, a lot of glDisable calls or glPathTexGen.

Can you do one or the other based on the true need?

+        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));
+        fHWTexGenSettings[i].fNumComponents = 0;
+    }
+
+    fHWActiveTexGenUnits = SkTMin(fHWActiveTexGenUnits, numUsedUnits);
+}
+
 void GrGpuGL::flushMiscFixedFunctionState() {
 
     const GrDrawState& drawState = this->getDrawState();
 
     if (drawState.isDitherState()) {
         if (kYes_TriState != fHWDitherEnabled) {
             GL_CALL(Enable(GR_GL_DITHER));
             fHWDitherEnabled = kYes_TriState;
         }
     } else {
@@ skipping 463 matching lines @@
             this->setVertexArrayID(gpu, 0);
         }
         int attrCount = gpu->glCaps().maxVertexAttributes();
         if (fDefaultVertexArrayAttribState.count() != attrCount) {
             fDefaultVertexArrayAttribState.resize(attrCount);
         }
         attribState = &fDefaultVertexArrayAttribState;
     }
     return attribState;
 }