Clip in grdrawtarget

src/gpu/GrDrawTarget.h

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrDrawTarget_DEFINED
 #define GrDrawTarget_DEFINED
 
@@ skipping 445 matching lines @@
 
     /**
      * Release any resources that are cached but not currently in use. This
      * is intended to give an application some recourse when resources are low.
      */
     virtual void purgeResources() {};
 
     /**
      * For subclass internal use to invoke a call to onDraw(). See DrawInfo below.
      */
-    void executeDraw(const DrawInfo& info) { this->onDraw(info); }
+    void executeDraw(const DrawInfo& info,
+                     const GrClipMaskManager::ScissorState& scissorState) {
+        this->onDraw(info, scissorState);
+    }
+
+    /**
+     * For subclass internal use to invoke a call to onStencilPath().
+     */
+    void executeStencilPath(const GrPath* path,
+                            const GrClipMaskManager::ScissorState& scissorState,
+                            const GrStencilSettings& stencilSettings) {
+        this->onStencilPath(path, scissorState, stencilSettings);
+    }
 
     /**
      * For subclass internal use to invoke a call to onDrawPath().
      */
-    void executeDrawPath(const GrPath* path, GrPathRendering::FillType fill,
+    void executeDrawPath(const GrPath* path,
+                         const GrClipMaskManager::ScissorState& scissorState,
+                         const GrStencilSettings& stencilSettings,
                          const GrDeviceCoordTexture* dstCopy) {
-        this->onDrawPath(path, fill, dstCopy);
+        this->onDrawPath(path, scissorState, stencilSettings, dstCopy);
     }
 
     /**
      * For subclass internal use to invoke a call to onDrawPaths().
      */
     void executeDrawPaths(const GrPathRange* pathRange,
-                          const uint32_t indices[], int count,
-                          const float transforms[], PathTransformType transformsType,
-                          GrPathRendering::FillType fill,
+                          const uint32_t indices[],
+                          int count,
+                          const float transforms[],
+                          PathTransformType transformsType,
+                          const GrClipMaskManager::ScissorState& scissorState,
+                          const GrStencilSettings& stencilSettings,
                           const GrDeviceCoordTexture* dstCopy) {
-        this->onDrawPaths(pathRange, indices, count, transforms, transformsType, fill, dstCopy);
+        this->onDrawPaths(pathRange, indices, count, transforms, transformsType,
+                          scissorState, stencilSettings, dstCopy);
     }
 
     ////////////////////////////////////////////////////////////////////////////
 
     /**
      * See AutoStateRestore below.
      */
     enum ASRInit {
         kPreserve_ASRInit,
         kReset_ASRInit
@@ skipping 170 matching lines @@
         bool isIssued() { return fDrawTarget && fDrawTarget->isIssued(fDrawID); }
 
     private:
         GrDrawTarget*  fDrawTarget;
         uint32_t       fDrawID;   // this may wrap, but we're doing direct comparison
                                   // so that should be okay
     };
 
     virtual DrawToken getCurrentDrawToken() { return DrawToken(this, 0); }
 
+
+    bool programUnitTest(int maxStages);
+
 protected:
     // Extend access to GrDrawState::convertToPEndeingExec to subclasses.
     void convertDrawStateToPendingExec(GrDrawState* ds) {
         ds->convertToPendingExec();
     }
 
     enum GeometrySrcType {
         kNone_GeometrySrcType,     //<! src has not been specified
         kReserved_GeometrySrcType, //<! src was set using reserve*Space
         kBuffer_GeometrySrcType    //<! src was set using set*SourceToBuffer
@@ skipping 144 matching lines @@
     // implemented by subclass to allocate space for reserved geom
     virtual bool onReserveVertexSpace(size_t vertexSize, int vertexCount, void** vertices) = 0;
     virtual bool onReserveIndexSpace(int indexCount, void** indices) = 0;
     // implemented by subclass to handle release of reserved geom space
     virtual void releaseReservedVertexSpace() = 0;
     virtual void releaseReservedIndexSpace() = 0;
     // subclass overrides to be notified just before geo src state is pushed/popped.
     virtual void geometrySourceWillPush() = 0;
     virtual void geometrySourceWillPop(const GeometrySrcState& restoredState) = 0;
     // subclass called to perform drawing
-    virtual void onDraw(const DrawInfo&) = 0;
+    virtual void onDraw(const DrawInfo&, const GrClipMaskManager::ScissorState&) = 0;
     // Implementation of drawRect. The geometry src and vertex attribs will already
     // be saved before this is called and restored afterwards. A subclass may override
     // this to perform more optimal rect rendering. Its draws should be funneled through
     // one of the public GrDrawTarget draw methods (e.g. drawNonIndexed,
     // drawIndexedInstances, ...). The base class draws a two triangle fan using
     // drawNonIndexed from reserved vertex space.
     virtual void onDrawRect(const SkRect& rect,
                             const SkRect* localRect,
                             const SkMatrix* localMatrix);
 
-    virtual void onStencilPath(const GrPath*, GrPathRendering::FillType) = 0;
-    virtual void onDrawPath(const GrPath*, GrPathRendering::FillType,
+    virtual void onStencilPath(const GrPath*,
+                               const GrClipMaskManager::ScissorState&,
+                               const GrStencilSettings&) = 0;
+    virtual void onDrawPath(const GrPath*,
+                            const GrClipMaskManager::ScissorState&,
+                            const GrStencilSettings&,
                             const GrDeviceCoordTexture* dstCopy) = 0;
     virtual void onDrawPaths(const GrPathRange*,
-                             const uint32_t indices[], int count,
-                             const float transforms[], PathTransformType,
-                             GrPathRendering::FillType, const GrDeviceCoordTexture*) = 0;
+                             const uint32_t indices[],
+                             int count,
+                             const float transforms[],
+                             PathTransformType,
+                             const GrClipMaskManager::ScissorState&,
+                             const GrStencilSettings&,
+                             const GrDeviceCoordTexture*) = 0;
 
     virtual void onClear(const SkIRect* rect, GrColor color, bool canIgnoreRect,
                          GrRenderTarget* renderTarget) = 0;
 
 
     virtual void didAddGpuTraceMarker() = 0;
     virtual void didRemoveGpuTraceMarker() = 0;
 
     // helpers for reserving vertex and index space.
     bool reserveVertexSpace(size_t vertexSize,
                             int vertexCount,
                             void** vertices);
     bool reserveIndexSpace(int indexCount, void** indices);
 
     // called by drawIndexed and drawNonIndexed. Use a negative indexCount to
     // indicate non-indexed drawing.
     bool checkDraw(GrPrimitiveType type, int startVertex,
                    int startIndex, int vertexCount,
                    int indexCount) const;
     // called when setting a new vert/idx source to unref prev vb/ib
     void releasePreviousVertexSource();
     void releasePreviousIndexSource();
 
     // Check to see if this set of draw commands has been sent out
     virtual bool       isIssued(uint32_t drawID) { return true; }
+    void getPathStencilSettingsForFilltype(GrPathRendering::FillType, GrStencilSettings*);
     virtual GrClipMaskManager* clipMaskManager() = 0;
+    virtual bool setupClip(const SkRect* devBounds,
+                           GrDrawState::AutoRestoreEffects* are,
+                           GrDrawState::AutoRestoreStencil* ars,
+                           GrClipMaskManager::ScissorState* scissorState) = 0;
 
     enum {
         kPreallocGeoSrcStateStackCnt = 4,
     };
     SkSTArray<kPreallocGeoSrcStateStackCnt, GeometrySrcState, true> fGeoSrcStateStack;
     const GrClipData*                                               fClip;
     GrDrawState*                                                    fDrawState;
     GrDrawState                                                     fDefaultDrawState;
     // The context owns us, not vice-versa, so this ptr is not ref'ed by DrawTarget.
     GrContext*                                                      fContext;
@@ skipping 37 matching lines @@
         // get rid of them all.
         fClipMaskManager.purgeResources();
     };
 
 protected:
     GrClipMaskManager           fClipMaskManager;
 
 private:
     GrClipMaskManager* clipMaskManager() { return &fClipMaskManager; }
 
+    virtual bool setupClip(const SkRect* devBounds,
+                           GrDrawState::AutoRestoreEffects* are,
+                           GrDrawState::AutoRestoreStencil* ars,
+                           GrClipMaskManager::ScissorState* scissorState) SK_OVERRIDE;
+
     typedef GrDrawTarget INHERITED;
 };
 
 #endif