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"
@@ skipping 1881 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()) {
                 GL_CALL(StencilFillPath(id, fillMode, writeMask));
             }
-            GL_CALL(StencilThenCoverStrokePath(id, 0xffff, writeMask, GR_GL_BOUNDING_BOX));
+            this->stencilThenCoverStrokePath(id, 0xffff, writeMask, GR_GL_BOUNDING_BOX);
         } else {
-            GL_CALL(StencilThenCoverFillPath(id, fillMode, writeMask, GR_GL_BOUNDING_BOX));
+            this->stencilThenCoverFillPath(id, fillMode, writeMask, GR_GL_BOUNDING_BOX);
         }
     } else {
         if (stroke.isFillStyle() || SkStrokeRec::kStrokeAndFill_Style == stroke.getStyle()) {
             GL_CALL(StencilFillPath(id, fillMode, writeMask));
         }
         if (stroke.needToApply()) {
             GL_CALL(StencilStrokePath(id, 0xffff, writeMask));
         }
 
         GrDrawState* drawState = this->drawState();
@@ skipping 42 matching lines @@
         fHWPathStencilSettings.writeMask(GrStencilSettings::kFront_Face);
 
     if (nonInvertedFill == fill) {
         if (stroke.needToApply()) {
             if (SkStrokeRec::kStrokeAndFill_Style == stroke.getStyle()) {
                 GL_CALL(StencilFillPathInstanced(
                             count, GR_GL_UNSIGNED_INT, indices, baseID, fillMode,
                             writeMask, gXformType2GLType[transformsType],
                             transforms));
             }
-            GL_CALL(StencilThenCoverStrokePathInstanced(
+            this->stencilThenCoverStrokePathInstanced(
                         count, GR_GL_UNSIGNED_INT, indices, baseID, 0xffff, writeMask,
                         GR_GL_BOUNDING_BOX_OF_BOUNDING_BOXES,
-                        gXformType2GLType[transformsType], transforms));
+                        gXformType2GLType[transformsType], transforms);
         } else {
-            GL_CALL(StencilThenCoverFillPathInstanced(
+            this->stencilThenCoverFillPathInstanced(
                         count, GR_GL_UNSIGNED_INT, indices, baseID, fillMode, writeMask,
                         GR_GL_BOUNDING_BOX_OF_BOUNDING_BOXES,
-                        gXformType2GLType[transformsType], transforms));
+                        gXformType2GLType[transformsType], transforms);
         }
     } else {
         if (stroke.isFillStyle() || SkStrokeRec::kStrokeAndFill_Style == stroke.getStyle()) {
             GL_CALL(StencilFillPathInstanced(
                         count, GR_GL_UNSIGNED_INT, indices, baseID, fillMode,
                         writeMask, gXformType2GLType[transformsType],
                         transforms));
         }
         if (stroke.needToApply()) {
             GL_CALL(StencilStrokePathInstanced(
@@ skipping 688 matching lines @@
 }
 
 void GrGpuGL::setTextureUnit(int unit) {
     SkASSERT(unit >= 0 && unit < fHWBoundTextureUniqueIDs.count());
     if (unit != fHWActiveTextureUnitIdx) {
         GL_CALL(ActiveTexture(GR_GL_TEXTURE0 + unit));
         fHWActiveTextureUnitIdx = unit;
     }
 }
 
+void GrGpuGL::stencilThenCoverFillPath(GrGLuint path, GrGLenum fillMode,
+                                       GrGLuint mask, GrGLenum coverMode) {
+    SkASSERT(this->caps()->pathRenderingSupport());
+    if (!this->caps()->pathRenderingV13Support()) {
+        GL_CALL(StencilFillPath(path, fillMode, mask));
+        GL_CALL(CoverFillPath(path, coverMode));
+        return;
+    }
+    GL_CALL(StencilThenCoverFillPath(path, fillMode, mask, coverMode));
+}
+
+void GrGpuGL::stencilThenCoverStrokePath(GrGLuint path, GrGLint reference,
+                                         GrGLuint mask, GrGLenum coverMode) {
+    SkASSERT(this->caps()->pathRenderingSupport());
+    if (!this->caps()->pathRenderingV13Support()) {
+        GL_CALL(StencilStrokePath(path, reference, mask));
+        GL_CALL(CoverStrokePath(path, coverMode));
+        return;
+    }
+    GL_CALL(StencilThenCoverStrokePath(path, reference, mask, coverMode));
+}
+
+void GrGpuGL::stencilThenCoverFillPathInstanced(GrGLsizei numPaths, GrGLenum pathNameType,
+                                                const GrGLvoid *paths, GrGLuint pathBase,
+                                                GrGLenum fillMode, GrGLuint mask,
+                                                GrGLenum coverMode, GrGLenum transformType,
+                                                const GrGLfloat *transformValues) {
+    SkASSERT(this->caps()->pathRenderingSupport());
+    if (!this->caps()->pathRenderingV13Support()) {
+        GL_CALL(StencilFillPathInstanced(numPaths, pathNameType, paths, pathBase,
+                                         fillMode, mask, transformType, transformValues));
+        GL_CALL(CoverFillPathInstanced(numPaths, pathNameType, paths, pathBase,
+                                       coverMode, transformType, transformValues));
+        return;
+    }
+    GL_CALL(StencilThenCoverFillPathInstanced(numPaths, pathNameType, paths, pathBase, fillMode,
+                                              mask, coverMode, transformType, transformValues));
+}
+
+void GrGpuGL::stencilThenCoverStrokePathInstanced(GrGLsizei numPaths, GrGLenum pathNameType,
+                                                  const GrGLvoid *paths, GrGLuint pathBase,
+                                                  GrGLint reference, GrGLuint mask,
+                                                  GrGLenum coverMode, GrGLenum transformType,
+                                                  const GrGLfloat *transformValues) {
+    SkASSERT(this->caps()->pathRenderingSupport());
+    if (!this->caps()->pathRenderingV13Support()) {
+        GL_CALL(StencilStrokePathInstanced(numPaths, pathNameType, paths, pathBase,
+                                           reference, mask, transformType, transformValues));
+        GL_CALL(CoverStrokePathInstanced(numPaths, pathNameType, paths, pathBase,
+                                         coverMode, transformType, transformValues));
+        return;
+    }
+    GL_CALL(StencilThenCoverStrokePathInstanced(numPaths, pathNameType, paths, pathBase, reference,
+                                                mask, coverMode, transformType, transformValues));
+}
+
 void GrGpuGL::setScratchTextureUnit() {
     // Bind the last texture unit since it is the least likely to be used by GrGLProgram.
     int lastUnitIdx = fHWBoundTextureUniqueIDs.count() - 1;
     if (lastUnitIdx != fHWActiveTextureUnitIdx) {
         GL_CALL(ActiveTexture(GR_GL_TEXTURE0 + lastUnitIdx));
         fHWActiveTextureUnitIdx = lastUnitIdx;
     }
     // clear out the this field so that if a program does use this unit it will rebind the correct
     // texture.
     fHWBoundTextureUniqueIDs[lastUnitIdx] = SK_InvalidUniqueID;
@@ skipping 294 matching lines @@
             this->setVertexArrayID(gpu, 0);
         }
         int attrCount = gpu->glCaps().maxVertexAttributes();
         if (fDefaultVertexArrayAttribState.count() != attrCount) {
             fDefaultVertexArrayAttribState.resize(attrCount);
         }
         attribState = &fDefaultVertexArrayAttribState;
     }
     return attribState;
 }