Revert of Wrap NV_path_rendering API with GrGLPathRendering

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 "GrGLNameAllocator.h"
 #include "GrGLStencilBuffer.h"
 #include "GrGLPath.h"
 #include "GrGLPathRange.h"
-#include "GrGLPathRendering.h"
 #include "GrGLShaderBuilder.h"
 #include "GrTemplates.h"
 #include "GrTypes.h"
 #include "SkStrokeRec.h"
 #include "SkTemplates.h"
 
 #define GL_CALL(X) GR_GL_CALL(this->glInterface(), X)
 #define GL_CALL_RET(RET, X) GR_GL_CALL_RET(this->glInterface(), RET, X)
 
 #define SKIP_CACHE_CHECK    true
@@ skipping 133 matching lines @@
         GrPrintf("\n");
         GrPrintf(this->glCaps().dump().c_str());
     }
 
     fProgramCache = SkNEW_ARGS(ProgramCache, (this));
 
     SkASSERT(this->glCaps().maxVertexAttributes() >= GrDrawState::kMaxVertexAttribCnt);
 
     fLastSuccessfulStencilFmtIdx = 0;
     fHWProgramID = 0;
-
-    if (this->glCaps().pathRenderingSupport()) {
-        fPathRendering.reset(GrGLPathRendering::Create(glInterface()));
-    }
 }
 
 GrGpuGL::~GrGpuGL() {
     if (0 != fHWProgramID) {
         // detach the current program so there is no confusion on OpenGL's part
         // that we want it to be deleted
         SkASSERT(fHWProgramID == fCurrentProgram->programID());
         GL_CALL(UseProgram(0));
     }
 
@@ skipping 138 matching lines @@
         fHWBoundRenderTargetUniqueID = SK_InvalidUniqueID;
     }
 
     if (resetBits & kPathRendering_GrGLBackendState) {
         if (this->caps()->pathRenderingSupport()) {
             fHWProjectionMatrixState.invalidate();
             // we don't use the model view matrix.
             GL_CALL(MatrixLoadIdentity(GR_GL_MODELVIEW));
 
             for (int i = 0; i < this->glCaps().maxFixedFunctionTextureCoords(); ++i) {
-                fPathRendering->pathTexGen(GR_GL_TEXTURE0 + i, GR_GL_NONE, 0, NULL);
+                GL_CALL(PathTexGen(GR_GL_TEXTURE0 + i, GR_GL_NONE, 0, NULL));
                 fHWPathTexGenSettings[i].fMode = GR_GL_NONE;
                 fHWPathTexGenSettings[i].fNumComponents = 0;
             }
             fHWActivePathTexGenSets = 0;
         }
         fHWPathStencilSettings.invalidate();
     }
 
     // we assume these values
     if (resetBits & kPixelStore_GrGLBackendState) {
@@ skipping 1531 matching lines @@
     SkASSERT(NULL != this->drawState()->getRenderTarget()->getStencilBuffer());
 
     flushPathStencilSettings(fill);
 
     // Decide how to manipulate the stencil buffer based on the fill rule.
     SkASSERT(!fHWPathStencilSettings.isTwoSided());
 
     GrGLenum fillMode =
         gr_stencil_op_to_gl_path_rendering_fill_mode(fHWPathStencilSettings.passOp(GrStencilSettings::kFront_Face));
     GrGLint writeMask = fHWPathStencilSettings.writeMask(GrStencilSettings::kFront_Face);
-    fPathRendering->stencilFillPath(id, fillMode, writeMask);
+    GL_CALL(StencilFillPath(id, fillMode, writeMask));
 }
 
 void GrGpuGL::onGpuDrawPath(const GrPath* path, SkPath::FillType fill) {
     SkASSERT(this->caps()->pathRenderingSupport());
 
     GrGLuint id = static_cast<const GrGLPath*>(path)->pathID();
     SkASSERT(NULL != this->drawState()->getRenderTarget());
     SkASSERT(NULL != this->drawState()->getRenderTarget()->getStencilBuffer());
     SkASSERT(!fCurrentProgram->hasVertexShader());
 
     flushPathStencilSettings(fill);
     const SkStrokeRec& stroke = path->getStroke();
 
     SkPath::FillType nonInvertedFill = SkPath::ConvertToNonInverseFillType(fill);
     SkASSERT(!fHWPathStencilSettings.isTwoSided());
     GrGLenum fillMode =
         gr_stencil_op_to_gl_path_rendering_fill_mode(fHWPathStencilSettings.passOp(GrStencilSettings::kFront_Face));
     GrGLint writeMask = fHWPathStencilSettings.writeMask(GrStencilSettings::kFront_Face);
 
     if (nonInvertedFill == fill) {
         if (stroke.needToApply()) {
             if (SkStrokeRec::kStrokeAndFill_Style == stroke.getStyle()) {
-                fPathRendering->stencilFillPath(id, fillMode, writeMask);
+                GL_CALL(StencilFillPath(id, fillMode, writeMask));
             }
-            fPathRendering->stencilThenCoverStrokePath(id, 0xffff, writeMask, GR_GL_BOUNDING_BOX);
+            GL_CALL(StencilThenCoverStrokePath(id, 0xffff, writeMask, GR_GL_BOUNDING_BOX));
         } else {
-            fPathRendering->stencilThenCoverFillPath(id, fillMode, writeMask, GR_GL_BOUNDING_BOX);
+            GL_CALL(StencilThenCoverFillPath(id, fillMode, writeMask, GR_GL_BOUNDING_BOX));
         }
     } else {
         if (stroke.isFillStyle() || SkStrokeRec::kStrokeAndFill_Style == stroke.getStyle()) {
-            fPathRendering->stencilFillPath(id, fillMode, writeMask);
+            GL_CALL(StencilFillPath(id, fillMode, writeMask));
         }
         if (stroke.needToApply()) {
-            fPathRendering->stencilStrokePath(id, 0xffff, writeMask);
+            GL_CALL(StencilStrokePath(id, 0xffff, writeMask));
         }
 
         GrDrawState* drawState = this->drawState();
         GrDrawState::AutoViewMatrixRestore avmr;
         SkRect bounds = SkRect::MakeLTRB(0, 0,
                                          SkIntToScalar(drawState->getRenderTarget()->width()),
                                          SkIntToScalar(drawState->getRenderTarget()->height()));
         SkMatrix vmi;
         // mapRect through persp matrix may not be correct
         if (!drawState->getViewMatrix().hasPerspective() && drawState->getViewInverse(&vmi)) {
@@ skipping 30 matching lines @@
     SkASSERT(!fHWPathStencilSettings.isTwoSided());
     GrGLenum fillMode =
         gr_stencil_op_to_gl_path_rendering_fill_mode(
             fHWPathStencilSettings.passOp(GrStencilSettings::kFront_Face));
     GrGLint writeMask =
         fHWPathStencilSettings.writeMask(GrStencilSettings::kFront_Face);
 
     if (nonInvertedFill == fill) {
         if (stroke.needToApply()) {
             if (SkStrokeRec::kStrokeAndFill_Style == stroke.getStyle()) {
-                fPathRendering->stencilFillPathInstanced(
-                                    count, GR_GL_UNSIGNED_INT, indices, baseID, fillMode,
-                                    writeMask, gXformType2GLType[transformsType],
-                                    transforms);
+                GL_CALL(StencilFillPathInstanced(
+                            count, GR_GL_UNSIGNED_INT, indices, baseID, fillMode,
+                            writeMask, gXformType2GLType[transformsType],
+                            transforms));
             }
-            fPathRendering->stencilThenCoverStrokePathInstanced(
-                                count, GR_GL_UNSIGNED_INT, indices, baseID, 0xffff, writeMask,
-                                GR_GL_BOUNDING_BOX_OF_BOUNDING_BOXES,
-                                gXformType2GLType[transformsType], transforms);
+            GL_CALL(StencilThenCoverStrokePathInstanced(
+                        count, GR_GL_UNSIGNED_INT, indices, baseID, 0xffff, writeMask,
+                        GR_GL_BOUNDING_BOX_OF_BOUNDING_BOXES,
+                        gXformType2GLType[transformsType], transforms));
         } else {
-            fPathRendering->stencilThenCoverFillPathInstanced(
-                                count, GR_GL_UNSIGNED_INT, indices, baseID, fillMode, writeMask,
-                                GR_GL_BOUNDING_BOX_OF_BOUNDING_BOXES,
-                                gXformType2GLType[transformsType], transforms);
+            GL_CALL(StencilThenCoverFillPathInstanced(
+                        count, GR_GL_UNSIGNED_INT, indices, baseID, fillMode, writeMask,
+                        GR_GL_BOUNDING_BOX_OF_BOUNDING_BOXES,
+                        gXformType2GLType[transformsType], transforms));
         }
     } else {
         if (stroke.isFillStyle() || SkStrokeRec::kStrokeAndFill_Style == stroke.getStyle()) {
-            fPathRendering->stencilFillPathInstanced(
-                                count, GR_GL_UNSIGNED_INT, indices, baseID, fillMode,
-                                writeMask, gXformType2GLType[transformsType],
-                                transforms);
+            GL_CALL(StencilFillPathInstanced(
+                        count, GR_GL_UNSIGNED_INT, indices, baseID, fillMode,
+                        writeMask, gXformType2GLType[transformsType],
+                        transforms));
         }
         if (stroke.needToApply()) {
-            fPathRendering->stencilStrokePathInstanced(
-                                count, GR_GL_UNSIGNED_INT, indices, baseID, 0xffff,
-                                writeMask, gXformType2GLType[transformsType],
-                                transforms);
+            GL_CALL(StencilStrokePathInstanced(
+                        count, GR_GL_UNSIGNED_INT, indices, baseID, 0xffff,
+                        writeMask, gXformType2GLType[transformsType],
+                        transforms));
         }
 
         GrDrawState* drawState = this->drawState();
         GrDrawState::AutoViewMatrixRestore avmr;
         SkRect bounds = SkRect::MakeLTRB(0, 0,
                                          SkIntToScalar(drawState->getRenderTarget()->width()),
                                          SkIntToScalar(drawState->getRenderTarget()->height()));
         SkMatrix vmi;
         // mapRect through persp matrix may not be correct
         if (!drawState->getViewMatrix().hasPerspective() && drawState->getViewInverse(&vmi)) {
@@ skipping 197 matching lines @@
 }
 
 void GrGpuGL::flushPathStencilSettings(SkPath::FillType fill) {
     GrStencilSettings pathStencilSettings;
     this->getPathStencilSettingsForFillType(fill, &pathStencilSettings);
     if (fHWPathStencilSettings != pathStencilSettings) {
         // Just the func, ref, and mask is set here. The op and write mask are params to the call
         // that draws the path to the SB (glStencilFillPath)
         GrGLenum func =
             gr_to_gl_stencil_func(pathStencilSettings.func(GrStencilSettings::kFront_Face));
-        fPathRendering->pathStencilFunc(
-                            func, pathStencilSettings.funcRef(GrStencilSettings::kFront_Face),
-                            pathStencilSettings.funcMask(GrStencilSettings::kFront_Face));
+        GL_CALL(PathStencilFunc(func,
+                                pathStencilSettings.funcRef(GrStencilSettings::kFront_Face),
+                                pathStencilSettings.funcMask(GrStencilSettings::kFront_Face)));
 
         fHWPathStencilSettings = pathStencilSettings;
     }
 }
 
 void GrGpuGL::flushBlend(bool isLines,
                          GrBlendCoeff srcCoeff,
                          GrBlendCoeff dstCoeff) {
     // Any optimization to disable blending should have already been applied and
     // tweaked the coeffs to (1, 0).
@@ skipping 170 matching lines @@
     if (GR_GL_OBJECT_LINEAR == fHWPathTexGenSettings[unitIdx].fMode &&
         components == fHWPathTexGenSettings[unitIdx].fNumComponents &&
         !memcmp(coefficients, fHWPathTexGenSettings[unitIdx].fCoefficients,
                 3 * components * sizeof(GrGLfloat))) {
         return;
     }
 
     this->setTextureUnit(unitIdx);
 
     fHWPathTexGenSettings[unitIdx].fNumComponents = components;
-    fPathRendering->pathTexGen(GR_GL_TEXTURE0 + unitIdx,
-                               GR_GL_OBJECT_LINEAR,
-                               components,
-                               coefficients);
+    GL_CALL(PathTexGen(GR_GL_TEXTURE0 + unitIdx,
+                       GR_GL_OBJECT_LINEAR,
+                       components,
+                       coefficients));
 
     memcpy(fHWPathTexGenSettings[unitIdx].fCoefficients, coefficients,
            3 * components * sizeof(GrGLfloat));
 }
 
 void GrGpuGL::enablePathTexGen(int unitIdx, PathTexGenComponents components,
                                const SkMatrix& matrix) {
     GrGLfloat coefficients[3 * 3];
     SkASSERT(this->glCaps().pathRenderingSupport());
     SkASSERT(components >= kS_PathTexGenComponents &&
@@ skipping 28 matching lines @@
     SkDEBUGCODE(
         for (int i = 0; i < numUsedTexCoordSets; i++) {
             SkASSERT(0 != fHWPathTexGenSettings[i].fNumComponents);
         }
     );
 
     for (int i = numUsedTexCoordSets; i < fHWActivePathTexGenSets; i++) {
         SkASSERT(0 != fHWPathTexGenSettings[i].fNumComponents);
 
         this->setTextureUnit(i);
-        fPathRendering->pathTexGen(GR_GL_TEXTURE0 + i, GR_GL_NONE, 0, NULL);
+        GL_CALL(PathTexGen(GR_GL_TEXTURE0 + i, GR_GL_NONE, 0, NULL));
         fHWPathTexGenSettings[i].fNumComponents = 0;
     }
 
     fHWActivePathTexGenSets = numUsedTexCoordSets;
 }
 
 void GrGpuGL::flushMiscFixedFunctionState() {
 
     const GrDrawState& drawState = this->getDrawState();
 
@@ skipping 35 matching lines @@
             case GrDrawState::kBoth_DrawFace:
                 GL_CALL(Disable(GR_GL_CULL_FACE));
                 break;
             default:
                 SkFAIL("Unknown draw face.");
         }
         fHWDrawFace = drawState.getDrawFace();
     }
 }
 
+GrGLuint GrGpuGL::createGLPathObject() {
+    if (NULL == fPathNameAllocator.get()) {
+        static const int range = 65536;
+        GrGLuint firstName;
+        GL_CALL_RET(firstName, GenPaths(range));
+        fPathNameAllocator.reset(SkNEW_ARGS(GrGLNameAllocator, (firstName, firstName + range)));
+    }
+
+    GrGLuint name = fPathNameAllocator->allocateName();
+    if (0 == name) {
+        // Our reserved path names are all in use. Fall back on GenPaths.
+        GL_CALL_RET(name, GenPaths(1));
+    }
+
+    return name;
+}
+
+void GrGpuGL::deleteGLPathObject(GrGLuint name) {
+    if (NULL == fPathNameAllocator.get() ||
+        name < fPathNameAllocator->firstName() ||
+        name >= fPathNameAllocator->endName()) {
+        // If we aren't inside fPathNameAllocator's range then this name was
+        // generated by the GenPaths fallback (or else the name is unallocated).
+        GL_CALL(DeletePaths(name, 1));
+        return;
+    }
+
+    // Make the path empty to save memory, but don't free the name in the driver.
+    GL_CALL(PathCommands(name, 0, NULL, 0, GR_GL_FLOAT, NULL));
+    fPathNameAllocator->free(name);
+}
+
 bool GrGpuGL::configToGLFormats(GrPixelConfig config,
                                 bool getSizedInternalFormat,
                                 GrGLenum* internalFormat,
                                 GrGLenum* externalFormat,
                                 GrGLenum* externalType) {
     GrGLenum dontCare;
     if (NULL == internalFormat) {
         internalFormat = &dontCare;
     }
     if (NULL == externalFormat) {
@@ skipping 439 matching lines @@
             this->setVertexArrayID(gpu, 0);
         }
         int attrCount = gpu->glCaps().maxVertexAttributes();
         if (fDefaultVertexArrayAttribState.count() != attrCount) {
             fDefaultVertexArrayAttribState.resize(attrCount);
         }
         attribState = &fDefaultVertexArrayAttribState;
     }
     return attribState;
 }