Stop creating GrODS for stencilPath commands.

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 1295 matching lines @@
                 this->notifyIndexBufferDelete(desc.fID);
                 return NULL;
             }
             GrIndexBuffer* indexBuffer = SkNEW_ARGS(GrGLIndexBuffer, (this, desc));
             return indexBuffer;
         }
         return NULL;
     }
 }
 
-void GrGLGpu::flushScissor(const GrClipMaskManager::ScissorState& scissorState,
+void GrGLGpu::flushScissor(const GrScissorState& scissorState,
                            const GrGLIRect& rtViewport,
                            GrSurfaceOrigin rtOrigin) {
     if (scissorState.fEnabled) {
         GrGLIRect scissor;
         scissor.setRelativeTo(rtViewport,
                               scissorState.fRect.fLeft,
                               scissorState.fRect.fTop,
                               scissorState.fRect.width(),
                               scissorState.fRect.height(),
                               rtOrigin);
@@ skipping 10 matching lines @@
             }
             return;
         }
     }
 
     // See fall through note above
     this->disableScissor();
 }
 
 bool GrGLGpu::flushGLState(const GrOptDrawState& optState) {
-    SkASSERT(kStencilPath_DrawType != optState.drawType());
-    this->flushMiscFixedFunctionState(optState);
+    this->flushDither(optState.isDitherState());
+    this->flushColorWriteDisable(optState.isColorWriteDisabled());
+    this->flushDrawFace(optState.getDrawFace());
 
     fCurrentProgram.reset(fProgramCache->getProgram(optState));
     if (NULL == fCurrentProgram.get()) {
         SkDEBUGFAIL("Failed to create program!");
         return false;
     }
 
     fCurrentProgram.get()->ref();
 
     GrGLuint programID = fCurrentProgram->programID();
     if (fHWProgramID != programID) {
         GL_CALL(UseProgram(programID));
         fHWProgramID = programID;
     }
 
     this->flushBlend(optState);
 
     fCurrentProgram->setData(optState);
 
     GrGLRenderTarget* glRT = static_cast<GrGLRenderTarget*>(optState.getRenderTarget());
-    this->flushStencil(optState.getStencil(), optState.drawType());
+    this->flushStencil(optState.getStencil());
     this->flushScissor(optState.getScissorState(), glRT->getViewport(), glRT->origin());
-    this->flushAAState(optState);
+    this->flushHWAAState(glRT, optState.isHWAntialiasState(),
+                         kDrawLines_DrawType == optState.drawType());
 
     // This must come after textures are flushed because a texture may need
     // to be msaa-resolved (which will modify bound FBO state).
     this->flushRenderTarget(glRT, NULL);
 
     return true;
 }
 
 void GrGLGpu::setupGeometry(const GrOptDrawState& optState,
                             const GrDrawTarget::DrawInfo& info,
@@ skipping 82 matching lines @@
         clippedRect = *rect;
         SkIRect rtRect = SkIRect::MakeWH(target->width(), target->height());
         if (clippedRect.intersect(rtRect)) {
             rect = &clippedRect;
         } else {
             return;
         }
     }
 
     this->flushRenderTarget(glRT, rect);
-    GrClipMaskManager::ScissorState scissorState;
+    GrScissorState scissorState;
     scissorState.fEnabled = SkToBool(rect);
     if (scissorState.fEnabled) {
         scissorState.fRect = *rect;
     }
     this->flushScissor(scissorState, glRT->getViewport(), glRT->origin());
 
     GrGLfloat r, g, b, a;
     static const GrGLfloat scale255 = 1.f / 255.f;
     a = GrColorUnpackA(color) * scale255;
     GrGLfloat scaleRGB = scale255;
@@ skipping 92 matching lines @@
 #endif
     GrGLint value;
     if (insideClip) {
         value = (1 << (stencilBitCount - 1));
     } else {
         value = 0;
     }
     GrGLRenderTarget* glRT = static_cast<GrGLRenderTarget*>(target);
     this->flushRenderTarget(glRT, &SkIRect::EmptyIRect());
 
-    GrClipMaskManager::ScissorState scissorState;
+    GrScissorState scissorState;
     scissorState.fEnabled = true;
     scissorState.fRect = rect;
     this->flushScissor(scissorState, glRT->getViewport(), glRT->origin());
 
     GL_CALL(StencilMask((uint32_t) clipStencilMask));
     GL_CALL(ClearStencil(value));
     GL_CALL(Clear(GR_GL_STENCIL_BUFFER_BIT));
     fHWStencilSettings.invalidate();
 }
 
@@ skipping 256 matching lines @@
         int set_a_break_pt_here = 9;
         aglSwapBuffers(aglGetCurrentContext());
     #elif defined(SK_BUILD_FOR_WIN32)
         SwapBuf();
         int set_a_break_pt_here = 9;
         SwapBuf();
     #endif
 #endif
 }
 
-void GrGLGpu::onStencilPath(const GrOptDrawState& ds,
-                            const GrPath* path,
-                            const GrStencilSettings& stencil) {
-    this->flushMiscFixedFunctionState(ds);
-    GrGLRenderTarget* rt = static_cast<GrGLRenderTarget*>(ds.getRenderTarget());
+void GrGLGpu::onStencilPath(const GrPath* path, const StencilPathState& state) {
+    this->flushColorWriteDisable(true);
+    this->flushDrawFace(GrDrawState::kBoth_DrawFace);
+
+    GrGLRenderTarget* rt = static_cast<GrGLRenderTarget*>(state.fRenderTarget);
     SkISize size = SkISize::Make(rt->width(), rt->height());
-    this->glPathRendering()->setProjectionMatrix(ds.getViewMatrix(), size, rt->origin());
-    this->flushStencil(ds.getStencil(), ds.drawType());
-    this->flushScissor(ds.getScissorState(), rt->getViewport(), rt->origin());
-    this->flushAAState(ds);
+    this->glPathRendering()->setProjectionMatrix(*state.fViewMatrix, size, rt->origin());
+    this->flushScissor(*state.fScissor, rt->getViewport(), rt->origin());
+    this->flushHWAAState(rt, state.fUseHWAA, false);
     this->flushRenderTarget(rt, NULL);
 
-    fPathRendering->stencilPath(path, stencil);
+    fPathRendering->stencilPath(path, *state.fStencil);
 }
 
 void GrGLGpu::onDrawPath(const GrOptDrawState& ds, const GrPath* path,
                          const GrStencilSettings& stencil) {
     if (!this->flushGLState(ds)) {
         return;
     }
     fPathRendering->drawPath(path, stencil);
 }
 
@@ skipping 26 matching lines @@
             // the bound DRAW FBO ID.
             fHWBoundRenderTargetUniqueID = SK_InvalidUniqueID;
             const GrGLIRect& vp = rt->getViewport();
             const SkIRect dirtyRect = rt->getResolveRect();
             GrGLIRect r;
             r.setRelativeTo(vp, dirtyRect.fLeft, dirtyRect.fTop,
                             dirtyRect.width(), dirtyRect.height(), target->origin());
 
             if (GrGLCaps::kES_Apple_MSFBOType == this->glCaps().msFBOType()) {
                 // Apple's extension uses the scissor as the blit bounds.
-                GrClipMaskManager::ScissorState scissorState;
+                GrScissorState scissorState;
                 scissorState.fEnabled = true;
                 scissorState.fRect = dirtyRect;
                 this->flushScissor(scissorState, rt->getViewport(), rt->origin());
                 GL_CALL(ResolveMultisampleFramebuffer());
             } else {
                 int right = r.fLeft + r.fWidth;
                 int top = r.fBottom + r.fHeight;
 
                 // BlitFrameBuffer respects the scissor, so disable it.
                 this->disableScissor();
@@ skipping 52 matching lines @@
         GR_GL_CALL(gl, StencilMask(writeMask));
         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 GrGLGpu::flushStencil(const GrStencilSettings& stencilSettings, DrawType type) {
-    // TODO figure out why we need to flush stencil settings on path draws at all
-    if (kStencilPath_DrawType != type && fHWStencilSettings != stencilSettings) {
+void GrGLGpu::flushStencil(const GrStencilSettings& stencilSettings) {
+    if (fHWStencilSettings != stencilSettings) {
         if (stencilSettings.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 12 matching lines @@
                 set_gl_stencil(this->glInterface(),
                                stencilSettings,
                                GR_GL_FRONT_AND_BACK,
                                GrStencilSettings::kFront_Face);
             }
         }
         fHWStencilSettings = stencilSettings;
     }
 }
 
-void GrGLGpu::flushAAState(const GrOptDrawState& optState) {
+void GrGLGpu::flushHWAAState(GrRenderTarget* rt, bool useHWAA, bool isLineDraw) {
 // At least some ATI linux drivers will render GL_LINES incorrectly when MSAA state is enabled but
 // the target is not multisampled. Single pixel wide lines are rendered thicker than 1 pixel wide.
 #if 0
     // Replace RT_HAS_MSAA with this definition once this driver bug is no longer a relevant concern
     #define RT_HAS_MSAA rt->isMultisampled()
 #else
-    #define RT_HAS_MSAA (rt->isMultisampled() || kDrawLines_DrawType == optState.drawType())
+    #define RT_HAS_MSAA (rt->isMultisampled() || isLineDraw)
 #endif
 
-    const GrRenderTarget* rt = optState.getRenderTarget();
     if (kGL_GrGLStandard == this->glStandard()) {
         if (RT_HAS_MSAA) {
-            bool enableMSAA = optState.isHWAntialiasState();
-            if (enableMSAA) {
+            if (useHWAA) {
                 if (kYes_TriState != fMSAAEnabled) {
                     GL_CALL(Enable(GR_GL_MULTISAMPLE));
                     fMSAAEnabled = kYes_TriState;
                 }
             } else {
                 if (kNo_TriState != fMSAAEnabled) {
                     GL_CALL(Disable(GR_GL_MULTISAMPLE));
                     fMSAAEnabled = kNo_TriState;
                 }
             }
@@ skipping 147 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 GrGLGpu::flushMiscFixedFunctionState(const GrOptDrawState& optState) {
-    if (optState.isDitherState()) {
+void GrGLGpu::flushDither(bool dither) {
+    if (dither) {
         if (kYes_TriState != fHWDitherEnabled) {
             GL_CALL(Enable(GR_GL_DITHER));
             fHWDitherEnabled = kYes_TriState;
         }
     } else {
         if (kNo_TriState != fHWDitherEnabled) {
             GL_CALL(Disable(GR_GL_DITHER));
             fHWDitherEnabled = kNo_TriState;
         }
     }
+}
 
-    if (optState.isColorWriteDisabled()) {
+void GrGLGpu::flushColorWriteDisable(bool disableColorWrites) {
+    if (disableColorWrites) {
         if (kNo_TriState != fHWWriteToColor) {
             GL_CALL(ColorMask(GR_GL_FALSE, GR_GL_FALSE,
                               GR_GL_FALSE, GR_GL_FALSE));
             fHWWriteToColor = kNo_TriState;
         }
     } else {
         if (kYes_TriState != fHWWriteToColor) {
             GL_CALL(ColorMask(GR_GL_TRUE, GR_GL_TRUE, GR_GL_TRUE, GR_GL_TRUE));
             fHWWriteToColor = kYes_TriState;
         }
     }
+}
 
-    if (fHWDrawFace != optState.getDrawFace()) {
-        switch (optState.getDrawFace()) {
+void GrGLGpu::flushDrawFace(GrDrawState::DrawFace face) {
+    if (fHWDrawFace != face) {
+        switch (face) {
             case GrDrawState::kCCW_DrawFace:
                 GL_CALL(Enable(GR_GL_CULL_FACE));
                 GL_CALL(CullFace(GR_GL_BACK));
                 break;
             case GrDrawState::kCW_DrawFace:
                 GL_CALL(Enable(GR_GL_CULL_FACE));
                 GL_CALL(CullFace(GR_GL_FRONT));
                 break;
             case GrDrawState::kBoth_DrawFace:
                 GL_CALL(Disable(GR_GL_CULL_FACE));
                 break;
             default:
                 SkFAIL("Unknown draw face.");
         }
-        fHWDrawFace = optState.getDrawFace();
+        fHWDrawFace = face;
     }
 }
 
 bool GrGLGpu::configToGLFormats(GrPixelConfig config,
                                 bool getSizedInternalFormat,
                                 GrGLenum* internalFormat,
                                 GrGLenum* externalFormat,
                                 GrGLenum* externalType) {
     GrGLenum dontCare;
     if (NULL == internalFormat) {
@@ skipping 461 matching lines @@
             this->setVertexArrayID(gpu, 0);
         }
         int attrCount = gpu->glCaps().maxVertexAttributes();
         if (fDefaultVertexArrayAttribState.count() != attrCount) {
             fDefaultVertexArrayAttribState.resize(attrCount);
         }
         attribState = &fDefaultVertexArrayAttribState;
     }
     return attribState;
 }