Implement path cover with nv_path_rendering

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 1662 matching lines @@
     return *GR_CONST_STENCIL_SETTINGS_PTR_FROM_STRUCT_PTR(&gSettings);
 }
 const GrStencilSettings& even_odd_nv_path_stencil_settings() {
     GR_STATIC_CONST_SAME_STENCIL_STRUCT(gSettings,
         kInvert_StencilOp,
         kInvert_StencilOp,
         kAlwaysIfInClip_StencilFunc,
         kOnes16, kOnes16, kOnes16);
     return *GR_CONST_STENCIL_SETTINGS_PTR_FROM_STRUCT_PTR(&gSettings);
 }
+
+GrGLenum sk_path_fill_type_to_gl_fill_mode(SkPath::FillType fill) {
+    switch (fill) {
+        default:
+            GrCrash("Unexpected path fill.");
+            /* fallthrough */;
+        case SkPath::kWinding_FillType:
+            return GR_GL_COUNT_UP;
+        case SkPath::kEvenOdd_FillType:
+            return GR_GL_INVERT;
+    }
+}
 }
 
-void GrGpuGL::setStencilPathSettings(const GrPath&,
-                                     SkPath::FillType fill,
-                                     GrStencilSettings* settings) {
+const GrStencilSettings& GrGpuGL::getStencilPathSettings(const GrPath&, SkPath::FillType fill) {
     switch (fill) {
-        case SkPath::kEvenOdd_FillType:
-            *settings = even_odd_nv_path_stencil_settings();
-            return;
-        case SkPath::kWinding_FillType:
-            *settings = winding_nv_path_stencil_settings();
-            return;
         default:
             GrCrash("Unexpected path fill.");
+            /* fallthrough */;
+        case SkPath::kWinding_FillType:
+            return winding_nv_path_stencil_settings();
+        case SkPath::kEvenOdd_FillType:
+            return even_odd_nv_path_stencil_settings();
     }
 }
 
 void GrGpuGL::onGpuStencilPath(const GrPath* path, SkPath::FillType fill) {
     SkASSERT(this->caps()->pathStencilingSupport());
 
     GrGLuint id = static_cast<const GrGLPath*>(path)->pathID();
     GrDrawState* drawState = this->drawState();
     SkASSERT(NULL != drawState->getRenderTarget());
     if (NULL == drawState->getRenderTarget()->getStencilBuffer()) {
         return;
     }
 
     // Decide how to manipulate the stencil buffer based on the fill rule.
-    // Also, assert that the stencil settings we set in setStencilPathSettings
-    // are present.
     SkASSERT(!fStencilSettings.isTwoSided());
-    GrGLenum fillMode;
-    switch (fill) {
-        case SkPath::kWinding_FillType:
-            fillMode = GR_GL_COUNT_UP;
-            SkASSERT(kIncClamp_StencilOp ==
-                     fStencilSettings.passOp(GrStencilSettings::kFront_Face));
-            SkASSERT(kIncClamp_StencilOp ==
-                     fStencilSettings.failOp(GrStencilSettings::kFront_Face));
-            break;
-        case SkPath::kEvenOdd_FillType:
-            fillMode = GR_GL_INVERT;
-            SkASSERT(kInvert_StencilOp ==
-                     fStencilSettings.passOp(GrStencilSettings::kFront_Face));
-            SkASSERT(kInvert_StencilOp ==
-                fStencilSettings.failOp(GrStencilSettings::kFront_Face));
-            break;
-        default:
-            // Only the above two fill rules are allowed.
-            GrCrash("Unexpected path fill.");
-            return; // suppress unused var warning.
-    }
-    GrGLint writeMask = fStencilSettings.writeMask(GrStencilSettings::kFront_Face);
+    GrGLenum fillMode = sk_path_fill_type_to_gl_fill_mode(fill);
+    GrGLint writeMask = fStencilPathSettings.writeMask(GrStencilSettings::kFront_Face);
     GL_CALL(StencilFillPath(id, fillMode, writeMask));
 }
 
+void GrGpuGL::onGpuDrawPath(const GrPath* path, SkPath::FillType fill) {
+    SkASSERT(this->caps()->pathStencilingSupport());
+
+    GrGLuint id = static_cast<const GrGLPath*>(path)->pathID();
+    GrDrawState* drawState = this->drawState();
+    SkASSERT(NULL != drawState->getRenderTarget());
+    if (NULL == drawState->getRenderTarget()->getStencilBuffer()) {

[Mark Kilgard, 2013/09/13 15:42:24]

Do we really expect to get here without a stencil buffer?

Could we simply assert that getStencilBuffer() returns NULL here?

I think you'd want to notice with an assert or bad drawing that you got here
accidently.

If we did the actual glStencilFillPathNV/glCoverFillPathNV and there was no
stencil buffer, neither command would generate an OpenGL error.  But the cover
would render the conservative cover geometry (there would be no stencil buffer
so the stencil test would never fail).  This is honestly probably what you (as a
developer) want so you'll notice "hey, this isn't what I expect; I wonder if I
don't have a stencil buffer!"

[bsalomon, 2013/09/13 20:25:28]

It's not illegal for a caller to give us an FBO without a stencil to draw into.
But maybe this should be handled in GrStencilAndCoverPathRenderer::canDrawPath
and then an assertion here.

[Kimmo Kinnunen, 2013/09/18 07:52:38]

Done.

+        return;
+    }
+
+    SkASSERT(!fStencilSettings.isTwoSided());
+    GrGLenum fillMode = sk_path_fill_type_to_gl_fill_mode(fill);
+    GrGLint writeMask = fStencilPathSettings.writeMask(GrStencilSettings::kFront_Face);
+    GL_CALL(StencilFillPath(id, fillMode, writeMask));
+    if (!fCurrentProgram->hasVertexShader()) {
+        GL_CALL(CoverFillPath(id, GR_GL_CONVEX_HULL));

[Chris Dalton, 2013/09/13 19:49:58]

I'd suggest using BOUNDING_BOX here.

Mark, thoughts?

[Kimmo Kinnunen, 2013/09/18 07:52:38]

Done.

+    } else {

[Mark Kilgard, 2013/09/13 15:42:24]

Is there a reason we would ever want to get into this else clause?

I'm not clear what it would be.

Is this really the "old" (pre-glCoverFillPathNV code) that could be deleted now?

[Chris Dalton, 2013/09/13 19:49:58]

Yes, the contract is that every time we draw a path there is no vertex shader.
This block of code should be very simple:

  SkASSERT(!fStencilSettings.isTwoSided());
  SkAssert(!fCurrentProgram->hasVertexShader());
  GrGLenum fillMode = sk_path_fill_type_to_gl_fill_mode(fill);
  GrGLint writeMask =
fStencilPathSettings.writeMask(GrStencilSettings::kFront_Face);
  GL_CALL(StencilFillPath(id, fillMode, writeMask));
  GL_CALL(CoverFillPath(id, GR_GL_BOUNDING_BOX));

[bsalomon, 2013/09/13 20:25:28]

agreed

[Kimmo Kinnunen, 2013/09/18 07:52:38]

I'm not sure I follow. I thought an effect can force the use of vertex shaders.

If I understand correctly, currently resolving the need for vertex shader is
done at the program flush stage. At this point the algorithm to draw the path
has already been selected.

[bsalomon, 2013/09/18 14:24:22]

Effects that require vertex shaders are only installed internally (that is below
GrContext). This will become actually enforced by the refactor Chris is doing
but it is true in practice today. So if we chose to use NVPR then we shouldn't
have an effect that requires a VS. The effects that require a VS implement
alternative ways of doing anti-aliasing in the absence of MSAA.

+        GrDrawState::AutoViewMatrixRestore avmr;
+        SkMatrix vmi;
+        SkRect bounds = SkRect::MakeLTRB(0, 0,
+                                         SkIntToScalar(drawState->getRenderTarget()->width()),
+                                         SkIntToScalar(drawState->getRenderTarget()->height()));
+
+        // 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().getMaxStretch() * SK_ScalarHalf;
+            bounds.outset(bloat, bloat);
+        } else {
+            avmr.setIdentity(drawState);
+        }
+
+        this->drawSimpleRect(bounds, NULL);
+    }
+}
+
 void GrGpuGL::onResolveRenderTarget(GrRenderTarget* target) {
     GrGLRenderTarget* rt = static_cast<GrGLRenderTarget*>(target);
     if (rt->needsResolve()) {
         // Some extensions automatically resolves the texture when it is read.
         if (this->glCaps().usesMSAARenderBuffers()) {
             SkASSERT(rt->textureFBOID() != rt->renderFBOID());
             GL_CALL(BindFramebuffer(GR_GL_READ_FRAMEBUFFER, rt->renderFBOID()));
             GL_CALL(BindFramebuffer(GR_GL_DRAW_FRAMEBUFFER, rt->textureFBOID()));
             // make sure we go through flushRenderTarget() since we've modified
             // the bound DRAW FBO ID.
@@ skipping 101 matching lines @@
         GR_GL_CALL(gl, StencilOp(glFailOp, glPassOp, glPassOp));
     } else {
         GR_GL_CALL(gl, StencilFuncSeparate(glFace, glFunc, ref, mask));
         GR_GL_CALL(gl, StencilMaskSeparate(glFace, writeMask));
         GR_GL_CALL(gl, StencilOpSeparate(glFace, glFailOp, glPassOp, glPassOp));
     }
 }
 }
 
 void GrGpuGL::flushStencil(DrawType type) {
-    if (kStencilPath_DrawType == type) {
-        SkASSERT(!fStencilSettings.isTwoSided());
+    if ((kStencilPath_DrawType == type || kDrawPath_DrawType == type) &&
+        fHWStencilPathSettings != fStencilPathSettings) {
+        SkASSERT(!fStencilPathSettings.isTwoSided());
         // 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(fStencilSettings.func(GrStencilSettings::kFront_Face));
+            gr_to_gl_stencil_func(fStencilPathSettings.func(GrStencilSettings::kFront_Face));
         GL_CALL(PathStencilFunc(func,
-                                fStencilSettings.funcRef(GrStencilSettings::kFront_Face),
-                                fStencilSettings.funcMask(GrStencilSettings::kFront_Face)));
-    } else if (fHWStencilSettings != fStencilSettings) {
+                                fStencilPathSettings.funcRef(GrStencilSettings::kFront_Face),
+                                fStencilPathSettings.funcMask(GrStencilSettings::kFront_Face)));
+        fHWStencilPathSettings = fStencilPathSettings;
+    }
+
+    if (kStencilPath_DrawType != type && fHWStencilSettings != fStencilSettings) {
         if (fStencilSettings.isDisabled()) {
             if (kNo_TriState != fHWStencilTestEnabled) {
                 GL_CALL(Disable(GR_GL_STENCIL_TEST));
                 fHWStencilTestEnabled = kNo_TriState;
             }
         } else {
             if (kYes_TriState != fHWStencilTestEnabled) {
                 GL_CALL(Enable(GR_GL_STENCIL_TEST));
                 fHWStencilTestEnabled = kYes_TriState;
             }
@@ skipping 827 matching lines @@
             this->setVertexArrayID(gpu, 0);
         }
         int attrCount = gpu->glCaps().maxVertexAttributes();
         if (fDefaultVertexArrayAttribState.count() != attrCount) {
             fDefaultVertexArrayAttribState.resize(attrCount);
         }
         attribState = &fDefaultVertexArrayAttribState;
     }
     return attribState;
 }