Implement path cover with nv_path_rendering

src/gpu/GrGpu.h

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrGpu_DEFINED
 #define GrGpu_DEFINED
 
@@ skipping 317 matching lines @@
     virtual void clearStencilClip(const SkIRect& rect, bool insideClip) = 0;
 
     enum PrivateDrawStateStateBits {
         kFirstBit = (GrDrawState::kLastPublicStateBit << 1),
 
         kModifyStencilClip_StateBit = kFirstBit, // allows draws to modify
                                                  // stencil bits used for
                                                  // clipping.
     };
 
+    void setPathStencilSettings(const GrStencilSettings& settings) {
+        fPathStencilSettings = settings;
+    }
+
+    // overridden by backend-specific derived class to perform the path stenciling.
+    virtual const GrStencilSettings& getPathStencilSettingsForFillType(SkPath::FillType) = 0;

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

I wonder if this needs to be virtual. It seems like if D3D or some other API had
path stenciling the rules would probably be the same. Maybe we can make it a
static func on GrGpu for now and virtualize only if a need arises?

+
 protected:
     enum DrawType {
         kDrawPoints_DrawType,
         kDrawLines_DrawType,
         kDrawTriangles_DrawType,
         kStencilPath_DrawType,
+        kFillPath_DrawType,
     };
 
     DrawType PrimTypeToDrawType(GrPrimitiveType type) {
         switch (type) {
             case kTriangles_GrPrimitiveType:
             case kTriangleStrip_GrPrimitiveType:
             case kTriangleFan_GrPrimitiveType:
                 return kDrawTriangles_DrawType;
             case kPoints_GrPrimitiveType:
                 return kDrawPoints_DrawType;
@@ skipping 36 matching lines @@
     }
 
     // The state of the scissor is controlled by the clip manager
     struct ScissorState {
         bool    fEnabled;
         SkIRect fRect;
     } fScissorState;
 
     // The final stencil settings to use as determined by the clip manager.
     GrStencilSettings fStencilSettings;
+    // The final stencil setting to use when stenciling a path with stencilPath.
+    GrStencilSettings fPathStencilSettings;
 
     // Derived classes need access to this so they can fill it out in their
     // constructors
     bool    fConfigRenderSupport[kGrPixelConfigCnt];
 
     // Helpers for setting up geometry state
     void finalizeReservedVertices();
     void finalizeReservedIndices();
 
 private:
@@ skipping 23 matching lines @@
     virtual GrVertexBuffer* onCreateVertexBuffer(uint32_t size, bool dynamic) = 0;
     virtual GrIndexBuffer* onCreateIndexBuffer(uint32_t size, bool dynamic) = 0;
     virtual GrPath* onCreatePath(const SkPath& path) = 0;
 
     // overridden by backend-specific derived class to perform the clear and
     // clearRect. NULL rect means clear whole target.
     virtual void onClear(const SkIRect* rect, GrColor color) = 0;
 
     // overridden by backend-specific derived class to perform the draw call.
     virtual void onGpuDraw(const DrawInfo&) = 0;
-    // when GrDrawTarget::stencilPath is called the draw state's current stencil
-    // settings are ignored. Instead the GrGpu decides the stencil rules
-    // necessary to stencil the path. These are still subject to filtering by
-    // the clip mask manager.
-    virtual void setStencilPathSettings(const GrPath&,
-                                        SkPath::FillType,
-                                        GrStencilSettings* settings) = 0;
+
     // overridden by backend-specific derived class to perform the path stenciling.
     virtual void onGpuStencilPath(const GrPath*, SkPath::FillType) = 0;
+    virtual void onGpuFillPath(const GrPath*, SkPath::FillType) = 0;
 
     // overridden by backend-specific derived class to perform flush
     virtual void onForceRenderTargetFlush() = 0;
 
     // overridden by backend-specific derived class to perform the read pixels.
     virtual bool onReadPixels(GrRenderTarget* target,
                               int left, int top, int width, int height,
                               GrPixelConfig,
                               void* buffer,
                               size_t rowBytes) = 0;
@@ skipping 25 matching lines @@
     virtual void clearStencil() = 0;
 
     // Given a rt, find or create a stencil buffer and attach it
     bool attachStencilBufferToRenderTarget(GrRenderTarget* target);
 
     // GrDrawTarget overrides
     virtual void onDraw(const DrawInfo&) SK_OVERRIDE;
     virtual void onStencilPath(const GrPath* path, const SkStrokeRec& stroke,
                                SkPath::FillType) SK_OVERRIDE;
 
+    virtual void onFillPath(const GrPath* path, const SkStrokeRec& stroke,
+                               SkPath::FillType) SK_OVERRIDE;
+
     // readies the pools to provide vertex/index data.
     void prepareVertexPool();
     void prepareIndexPool();
 
     void resetContext() {
         // We call this because the client may have messed with the
         // stencil buffer. Perhaps we should detect whether it is a
         // internally created stencil buffer and if so skip the invalidate.
         fClipMaskManager.invalidateStencilMask();
         this->onResetContext(fResetBits);
@@ skipping 22 matching lines @@
     // these are mutable so they can be created on-demand
     mutable GrIndexBuffer*                                              fQuadIndexBuffer;
     // Used to abandon/release all resources created by this GrGpu. TODO: Move this
     // functionality to GrResourceCache.
     ResourceList                                                        fResourceList;
 
     typedef GrDrawTarget INHERITED;
 };
 
 #endif