Beginning to refactor nvpr code

src/gpu/gl/GrGLPathRendering.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "gl/GrGLPathRendering.h"
 #include "gl/GrGLNameAllocator.h"
 #include "gl/GrGLUtil.h"
@@ skipping 134 matching lines @@
         return GrPathRendering::createGlyphs(typeface, NULL, stroke);
     }
 
     // This is a crude approximation. We may want to consider giving this class
     // a pseudo PathGenerator whose sole purpose is to track the approximate gpu
     // memory size.
     const size_t gpuMemorySize = fontDataLength / 4;
     return SkNEW_ARGS(GrGLPathRange, (fGpu, basePathID, numPaths, gpuMemorySize, stroke));
 }
 
-void GrGLPathRendering::stencilPath(const GrPath* path, SkPath::FillType fill) {
+void GrGLPathRendering::stencilPath(const GrPath* path, const GrStencilSettings& stencilSettings) {
     GrGLuint id = static_cast<const GrGLPath*>(path)->pathID();
     SkASSERT(fGpu->drawState()->getRenderTarget());
     SkASSERT(fGpu->drawState()->getRenderTarget()->getStencilBuffer());
 
-    this->flushPathStencilSettings(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);
-    GL_CALL(StencilFillPath(id, fillMode, writeMask));
-}
-
-void GrGLPathRendering::drawPath(const GrPath* path, SkPath::FillType fill) {
-    GrGLuint id = static_cast<const GrGLPath*>(path)->pathID();
-    SkASSERT(fGpu->drawState()->getRenderTarget());
-    SkASSERT(fGpu->drawState()->getRenderTarget()->getStencilBuffer());
-
-    this->flushPathStencilSettings(fill);
+    this->flushPathStencilSettings(stencilSettings);
     SkASSERT(!fHWPathStencilSettings.isTwoSided());
 
     const SkStrokeRec& stroke = path->getStroke();
 
-    SkPath::FillType nonInvertedFill = SkPath::ConvertToNonInverseFillType(fill);
-
     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));
-            }
-            this->stencilThenCoverStrokePath(id, 0xffff, writeMask, GR_GL_BOUNDING_BOX);
-        } else {
-            this->stencilThenCoverFillPath(id, fillMode, writeMask, GR_GL_BOUNDING_BOX);
-        }
-    } else {
-        if (stroke.isFillStyle() || SkStrokeRec::kStrokeAndFill_Style == stroke.getStyle()) {
+    if (stroke.isFillStyle() || SkStrokeRec::kStrokeAndFill_Style == stroke.getStyle()) {

[Kimmo Kinnunen, 2014/11/03 20:39:12]

So I guess this is not part of "refactoring", rather intended functionality
change?

[joshualitt, 2014/11/03 20:51:46]

Err, is there a problem with this chunk?  The original flow seemed to do this
test before stenciling inverse paths, so I figured we might have to do it.

+        GL_CALL(StencilFillPath(id, fillMode, writeMask));
+    }
+    if (stroke.needToApply()) {
+        GL_CALL(StencilStrokePath(id, 0xffff, writeMask));
+    }
+}
+
+void GrGLPathRendering::drawPath(const GrPath* path, const GrStencilSettings& stencilSettings) {
+    GrGLuint id = static_cast<const GrGLPath*>(path)->pathID();
+    SkASSERT(fGpu->drawState()->getRenderTarget());
+    SkASSERT(fGpu->drawState()->getRenderTarget()->getStencilBuffer());
+
+    this->flushPathStencilSettings(stencilSettings);
+    SkASSERT(!fHWPathStencilSettings.isTwoSided());
+
+    const SkStrokeRec& stroke = path->getStroke();
+
+    GrGLenum fillMode =
+        gr_stencil_op_to_gl_path_rendering_fill_mode(fHWPathStencilSettings.passOp(GrStencilSettings::kFront_Face));
+    GrGLint writeMask = fHWPathStencilSettings.writeMask(GrStencilSettings::kFront_Face);
+
+    if (stroke.needToApply()) {
+        if (SkStrokeRec::kStrokeAndFill_Style == stroke.getStyle()) {
             GL_CALL(StencilFillPath(id, fillMode, writeMask));
         }
-        if (stroke.needToApply()) {
-            GL_CALL(StencilStrokePath(id, 0xffff, writeMask));
-        }
-
-        GrDrawState* drawState = fGpu->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)) {
-            vmi.mapRect(&bounds);
-            // theoretically could set bloat = 0, instead leave it because of matrix inversion
-            // precision.
-            SkScalar bloat = drawState->getViewMatrix().getMaxScale() * SK_ScalarHalf;
-            bounds.outset(bloat, bloat);
-        } else {
-            avmr.setIdentity(drawState);
-        }
-
-        fGpu->drawSimpleRect(bounds);
+        this->stencilThenCoverStrokePath(id, 0xffff, writeMask, GR_GL_BOUNDING_BOX);
+    } else {
+        this->stencilThenCoverFillPath(id, fillMode, writeMask, GR_GL_BOUNDING_BOX);
     }
 }
 
 void GrGLPathRendering::drawPaths(const GrPathRange* pathRange, const uint32_t indices[], int count,
                                   const float transforms[], PathTransformType transformsType,
-                                  SkPath::FillType fill) {
+                                  const GrStencilSettings& stencilSettings) {
     SkASSERT(fGpu->caps()->pathRenderingSupport());
     SkASSERT(fGpu->drawState()->getRenderTarget());
     SkASSERT(fGpu->drawState()->getRenderTarget()->getStencilBuffer());
 
     GrGLuint baseID = static_cast<const GrGLPathRange*>(pathRange)->basePathID();
 
-    this->flushPathStencilSettings(fill);
+    this->flushPathStencilSettings(stencilSettings);
     SkASSERT(!fHWPathStencilSettings.isTwoSided());
 
     const SkStrokeRec& stroke = pathRange->getStroke();
 
-    SkPath::FillType nonInvertedFill =
-        SkPath::ConvertToNonInverseFillType(fill);
-
     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(StencilFillPathInstanced(
-                                count, GR_GL_UNSIGNED_INT, indices, baseID, fillMode,
-                                writeMask, gXformType2GLType[transformsType],
-                                transforms));
-            }
-            this->stencilThenCoverStrokePathInstanced(
-                                count, GR_GL_UNSIGNED_INT, indices, baseID, 0xffff, writeMask,
-                                GR_GL_BOUNDING_BOX_OF_BOUNDING_BOXES,
-                                gXformType2GLType[transformsType], transforms);
-        } else {
-            this->stencilThenCoverFillPathInstanced(
-                                count, GR_GL_UNSIGNED_INT, indices, baseID, fillMode, writeMask,
-                                GR_GL_BOUNDING_BOX_OF_BOUNDING_BOXES,
-                                gXformType2GLType[transformsType], transforms);
+    if (stroke.needToApply()) {
+        if (SkStrokeRec::kStrokeAndFill_Style == stroke.getStyle()) {
+            GL_CALL(StencilFillPathInstanced(
+                            count, GR_GL_UNSIGNED_INT, indices, baseID, fillMode,
+                            writeMask, gXformType2GLType[transformsType],
+                            transforms));
         }
+        this->stencilThenCoverStrokePathInstanced(
+                            count, GR_GL_UNSIGNED_INT, indices, baseID, 0xffff, writeMask,
+                            GR_GL_BOUNDING_BOX_OF_BOUNDING_BOXES,
+                            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(
-                                count, GR_GL_UNSIGNED_INT, indices, baseID, 0xffff,
-                                writeMask, gXformType2GLType[transformsType],
-                                transforms));
-        }
-
-        GrDrawState* drawState = fGpu->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)) {
-            vmi.mapRect(&bounds);
-            // theoretically could set bloat = 0, instead leave it because of matrix inversion
-            // precision.
-            SkScalar bloat = drawState->getViewMatrix().getMaxScale() * SK_ScalarHalf;
-            bounds.outset(bloat, bloat);
-        } else {
-            avmr.setIdentity(drawState);
-        }
-
-        fGpu->drawSimpleRect(bounds);
+        this->stencilThenCoverFillPathInstanced(
+                            count, GR_GL_UNSIGNED_INT, indices, baseID, fillMode, writeMask,
+                            GR_GL_BOUNDING_BOX_OF_BOUNDING_BOXES,
+                            gXformType2GLType[transformsType], transforms);
     }
 }
 
 void GrGLPathRendering::enablePathTexGen(int unitIdx, PathTexGenComponents components,
                                          const GrGLfloat* coefficients) {
     SkASSERT(components >= kS_PathTexGenComponents &&
              components <= kSTR_PathTexGenComponents);
     SkASSERT(fGpu->glCaps().maxFixedFunctionTextureCoords() >= unitIdx);
 
     if (GR_GL_OBJECT_LINEAR == fHWPathTexGenSettings[unitIdx].fMode &&
@@ skipping 153 matching lines @@
         // generated by the GenPaths fallback (or else was never allocated).
         GL_CALL(DeletePaths(path, 1));
         return;
     }
 
     // Make the path empty to save memory, but don't free the name in the driver.
     GL_CALL(PathCommands(path, 0, NULL, 0, GR_GL_FLOAT, NULL));
     fPathNameAllocator->free(path);
 }
 
-void GrGLPathRendering::flushPathStencilSettings(SkPath::FillType fill) {
-    GrStencilSettings pathStencilSettings;
-    fGpu->getPathStencilSettingsForFillType(fill, &pathStencilSettings);
-    if (fHWPathStencilSettings != pathStencilSettings) {
+void GrGLPathRendering::flushPathStencilSettings(const GrStencilSettings& stencilSettings) {
+    if (fHWPathStencilSettings != stencilSettings) {
         // 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 =
-            GrToGLStencilFunc(pathStencilSettings.func(GrStencilSettings::kFront_Face));
-        GL_CALL(PathStencilFunc(func, pathStencilSettings.funcRef(GrStencilSettings::kFront_Face),
-                                pathStencilSettings.funcMask(GrStencilSettings::kFront_Face)));
+            GrToGLStencilFunc(stencilSettings.func(GrStencilSettings::kFront_Face));
+        GL_CALL(PathStencilFunc(func, stencilSettings.funcRef(GrStencilSettings::kFront_Face),
+                                stencilSettings.funcMask(GrStencilSettings::kFront_Face)));
 
-        fHWPathStencilSettings = pathStencilSettings;
+        fHWPathStencilSettings = stencilSettings;
     }
 }
 
 inline void GrGLPathRendering::stencilThenCoverFillPath(GrGLuint path, GrGLenum fillMode,
                                                      GrGLuint mask, GrGLenum coverMode) {
     if (caps().stencilThenCoverSupport) {
         GL_CALL(StencilThenCoverFillPath(path, fillMode, mask, coverMode));
         return;
     }
     GL_CALL(StencilFillPath(path, fillMode, mask));
@@ skipping 34 matching lines @@
                                                     reference, mask, coverMode, transformType,
                                                     transformValues));
         return;
     }
 
     GL_CALL(StencilStrokePathInstanced(numPaths, pathNameType, paths, pathBase,
                                        reference, mask, transformType, transformValues));
     GL_CALL(CoverStrokePathInstanced(numPaths, pathNameType, paths, pathBase,
                                      coverMode, transformType, transformValues));
 }