Implement path cover with nv_path_rendering

src/gpu/GrGpu.cpp

 
 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "GrGpu.h"
@@ skipping 180 matching lines @@
     this->handleDirtyContext();
     return this->onCreateVertexBuffer(size, dynamic);
 }
 
 GrIndexBuffer* GrGpu::createIndexBuffer(uint32_t size, bool dynamic) {
     this->handleDirtyContext();
     return this->onCreateIndexBuffer(size, dynamic);
 }
 
 GrPath* GrGpu::createPath(const SkPath& path) {
-    SkASSERT(this->caps()->pathStencilingSupport());
+    SkASSERT(this->caps()->pathRenderingSupport());
     this->handleDirtyContext();
     return this->onCreatePath(path);
 }
 
 void GrGpu::clear(const SkIRect* rect,
                   GrColor color,
                   GrRenderTarget* renderTarget) {
     GrDrawState::AutoRenderTargetRestore art;
     if (NULL != renderTarget) {
         art.set(this->drawState(), renderTarget);
@@ skipping 130 matching lines @@
                                       info.getDstCopy(),
                                       &are)) {
         return;
     }
     this->onGpuDraw(info);
 }
 
 void GrGpu::onStencilPath(const GrPath* path, const SkStrokeRec&, SkPath::FillType fill) {
     this->handleDirtyContext();
 
-    // TODO: make this more efficient (don't copy and copy back)
-    GrAutoTRestore<GrStencilSettings> asr(this->drawState()->stencil());
+    // This function might be called during clip flush of path fill.  We need to restore the fill
+    // type afterwards.
+    GrAutoTRestore<SkPath::FillType> apsr(this->drawState()->pathStencilFillType());

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

Now I see why you added the ptr getter. :/

Maybe we don't need to add anything to the draw state at all? Could we just pass
the fill type to stencilPath/onStencilPath drawPath/onDrawPath and just document
that it is used to override the stencil settings on the GrDrawState?

[Kimmo Kinnunen, 2013/09/20 12:20:58]

I try to see if I can figure out a way. I was struggling to maintain the
structure where state modifications would happen in the "flush" methods. The
state modification for the path stencil happens now during stencil flush.

+    this->drawState()->setPathStencilFillType(fill);
 
-    this->setStencilPathSettings(*path, fill, this->drawState()->stencil());
     GrDrawState::AutoRestoreEffects are;
     if (!this->setupClipAndFlushState(kStencilPath_DrawType, NULL, &are)) {
         return;
     }
 
     this->onGpuStencilPath(path, fill);
 }
 
+void GrGpu::onFillPath(const GrPath* path, const SkStrokeRec& stroke, SkPath::FillType fill) {
+    this->handleDirtyContext();
+
+    this->drawState()->setPathStencilFillType(fill);
+
+    GrDrawState::AutoRestoreEffects are;
+    // TODO: Some blending effects require destination texture, see onDraw
+    if (!this->setupClipAndFlushState(kFillPath_DrawType, NULL, &are)) {
+        return;
+    }
+
+    this->onGpuFillPath(path, fill);
+}
+
 void GrGpu::finalizeReservedVertices() {
     SkASSERT(NULL != fVertexPool);
     fVertexPool->unlock();
 }
 
 void GrGpu::finalizeReservedIndices() {
     SkASSERT(NULL != fIndexPool);
     fIndexPool->unlock();
 }
 
@@ skipping 117 matching lines @@
 }
 
 void GrGpu::releaseIndexArray() {
     // if index source was array, we stowed data in the pool
     const GeometrySrcState& geoSrc = this->getGeomSrc();
     SkASSERT(kArray_GeometrySrcType == geoSrc.fIndexSrc);
     size_t bytes = geoSrc.fIndexCount * sizeof(uint16_t);
     fIndexPool->putBack(bytes);
     --fIndexPoolUseCnt;
 }