Clip in grdrawtarget

src/gpu/GrInOrderDrawBuffer.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 GrInOrderDrawBuffer_DEFINED
 #define GrInOrderDrawBuffer_DEFINED
 
@@ skipping 81 matching lines @@
                        GrRenderTarget* renderTarget) SK_OVERRIDE;
 
     virtual void clearStencilClip(const SkIRect& rect,
                                   bool insideClip,
                                   GrRenderTarget* renderTarget) SK_OVERRIDE;
 
     virtual void discard(GrRenderTarget*) SK_OVERRIDE;
 
     virtual void initCopySurfaceDstDesc(const GrSurface* src, GrSurfaceDesc* desc) SK_OVERRIDE;
 
-protected:
-    virtual void clipWillBeSet(const GrClipData* newClip) SK_OVERRIDE;
-
 private:
+    typedef GrClipMaskManager::ScissorState ScissorState;
     enum {
         kDraw_Cmd           = 1,
         kStencilPath_Cmd    = 2,
         kSetState_Cmd       = 3,
-        kSetClip_Cmd        = 4,
-        kClear_Cmd          = 5,
-        kCopySurface_Cmd    = 6,
-        kDrawPath_Cmd       = 7,
-        kDrawPaths_Cmd      = 8,
+        kClear_Cmd          = 4,
+        kCopySurface_Cmd    = 5,
+        kDrawPath_Cmd       = 6,
+        kDrawPaths_Cmd      = 7,
     };
 
     struct Cmd : ::SkNoncopyable {
         Cmd(uint8_t type) : fType(type) {}
         virtual ~Cmd() {}
 
         virtual void execute(GrClipTarget*) = 0;
 
         uint8_t fType;
     };
 
     struct Draw : public Cmd {
-        Draw(const DrawInfo& info, const GrVertexBuffer* vb, const GrIndexBuffer* ib)
+        Draw(const DrawInfo& info, const ScissorState& scissorState,
+             const GrVertexBuffer* vb, const GrIndexBuffer* ib)
             : Cmd(kDraw_Cmd)
             , fInfo(info)
+            , fScissorState(scissorState)
             , fVertexBuffer(vb)
             , fIndexBuffer(ib) {}
 
         const GrVertexBuffer* vertexBuffer() const { return fVertexBuffer.get(); }
         const GrIndexBuffer* indexBuffer() const { return fIndexBuffer.get(); }
 
         virtual void execute(GrClipTarget*);
 
-        DrawInfo fInfo;
+        DrawInfo     fInfo;
+        ScissorState fScissorState;
 
     private:
         GrPendingIOResource<const GrVertexBuffer, kRead_GrIOType>    fVertexBuffer;
         GrPendingIOResource<const GrIndexBuffer, kRead_GrIOType>     fIndexBuffer;
     };
 
     struct StencilPath : public Cmd {
-        StencilPath(const GrPath* path) : Cmd(kStencilPath_Cmd), fPath(path) {}
+        StencilPath(const GrPath* path)
+            : Cmd(kStencilPath_Cmd), fPath(path) {}
 
         const GrPath* path() const { return fPath.get(); }
 
         virtual void execute(GrClipTarget*);
 
-        GrPathRendering::FillType fFill;
+        ScissorState      fScissorState;
+        GrStencilSettings fStencilSettings;
 
     private:
         GrPendingIOResource<const GrPath, kRead_GrIOType>   fPath;
     };
 
     struct DrawPath : public Cmd {
-        DrawPath(const GrPath* path) : Cmd(kDrawPath_Cmd), fPath(path) {}
+        DrawPath(const GrPath* path)
+            : Cmd(kDrawPath_Cmd), fPath(path) {}
 
         const GrPath* path() const { return fPath.get(); }
 
         virtual void execute(GrClipTarget*);
 
-        GrPathRendering::FillType fFill;
-        GrDeviceCoordTexture      fDstCopy;
+        GrDeviceCoordTexture    fDstCopy;
+        ScissorState            fScissorState;
+        GrStencilSettings       fStencilSettings;
 
     private:
         GrPendingIOResource<const GrPath, kRead_GrIOType> fPath;
     };
 
     struct DrawPaths : public Cmd {
-        DrawPaths(const GrPathRange* pathRange) : Cmd(kDrawPaths_Cmd), fPathRange(pathRange) {}
+        DrawPaths(const GrPathRange* pathRange)
+            : Cmd(kDrawPaths_Cmd), fPathRange(pathRange) {}
 
         const GrPathRange* pathRange() const { return fPathRange.get();  }
         uint32_t* indices() { return reinterpret_cast<uint32_t*>(CmdBuffer::GetDataForItem(this)); }
         float* transforms() { return reinterpret_cast<float*>(&this->indices()[fCount]); }
 
         virtual void execute(GrClipTarget*);
 
-        size_t                    fCount;
-        PathTransformType         fTransformsType;
-        GrPathRendering::FillType fFill;
-        GrDeviceCoordTexture      fDstCopy;
+        size_t                  fCount;
+        PathTransformType       fTransformsType;
+        GrDeviceCoordTexture    fDstCopy;
+        ScissorState            fScissorState;
+        GrStencilSettings       fStencilSettings;
 
     private:
         GrPendingIOResource<const GrPathRange, kRead_GrIOType> fPathRange;
     };
 
     // This is also used to record a discard by setting the color to GrColor_ILLEGAL
     struct Clear : public Cmd {
         Clear(GrRenderTarget* rt) : Cmd(kClear_Cmd), fRenderTarget(rt) {}
 
         GrRenderTarget* renderTarget() const { return fRenderTarget.get(); }
@@ skipping 40 matching lines @@
     };
 
     struct SetState : public Cmd {
         SetState(const GrDrawState& state) : Cmd(kSetState_Cmd), fState(state) {}
 
         virtual void execute(GrClipTarget*);
 
         GrDrawState fState;
     };
 
-    struct SetClip : public Cmd {
-        SetClip(const GrClipData* clipData)
-            : Cmd(kSetClip_Cmd),
-              fStackStorage(*clipData->fClipStack) {
-            fClipData.fClipStack = &fStackStorage;
-            fClipData.fOrigin = clipData->fOrigin;
-        }
-
-        virtual void execute(GrClipTarget*);
-
-        GrClipData fClipData;
-
-    private:
-        SkClipStack fStackStorage;
-    };
-
     typedef void* TCmdAlign; // This wouldn't be enough align if a command used long double.
     typedef GrTRecorder<Cmd, TCmdAlign> CmdBuffer;
 
     // overrides from GrDrawTarget
-    virtual void onDraw(const DrawInfo&) SK_OVERRIDE;
+    virtual void onDraw(const DrawInfo&, const GrClipMaskManager::ScissorState&) SK_OVERRIDE;
     virtual void onDrawRect(const SkRect& rect,
                             const SkRect* localRect,
                             const SkMatrix* localMatrix) SK_OVERRIDE;
 
-    virtual void onStencilPath(const GrPath*, GrPathRendering::FillType) SK_OVERRIDE;
-    virtual void onDrawPath(const GrPath*, GrPathRendering::FillType,
+    virtual void onStencilPath(const GrPath*,
+                               const GrClipMaskManager::ScissorState&,
+                               const GrStencilSettings&) SK_OVERRIDE;
+    virtual void onDrawPath(const GrPath*,
+                            const GrClipMaskManager::ScissorState&,
+                            const GrStencilSettings&,
                             const GrDeviceCoordTexture* dstCopy) SK_OVERRIDE;
     virtual void onDrawPaths(const GrPathRange*,
-                             const uint32_t indices[], int count,
-                             const float transforms[], PathTransformType,
-                             GrPathRendering::FillType, const GrDeviceCoordTexture*) SK_OVERRIDE;
+                             const uint32_t indices[],
+                             int count,
+                             const float transforms[],
+                             PathTransformType,
+                             const GrClipMaskManager::ScissorState&,
+                             const GrStencilSettings&,
+                             const GrDeviceCoordTexture*) SK_OVERRIDE;
 
     virtual bool onReserveVertexSpace(size_t vertexSize,
                                       int vertexCount,
                                       void** vertices) SK_OVERRIDE;
     virtual bool onReserveIndexSpace(int indexCount,
                                      void** indices) SK_OVERRIDE;
     virtual void releaseReservedVertexSpace() SK_OVERRIDE;
     virtual void releaseReservedIndexSpace() SK_OVERRIDE;
     virtual void onSetVertexSourceToArray(const void* vertexArray,
                                           int vertexCount) SK_OVERRIDE;
     virtual void onSetIndexSourceToArray(const void* indexArray,
                                          int indexCount) SK_OVERRIDE;
     virtual void releaseVertexArray() SK_OVERRIDE;
     virtual void releaseIndexArray() SK_OVERRIDE;
     virtual void geometrySourceWillPush() SK_OVERRIDE;
     virtual void geometrySourceWillPop(const GeometrySrcState& restoredState) SK_OVERRIDE;
     virtual void willReserveVertexAndIndexSpace(int vertexCount,
                                                 int indexCount) SK_OVERRIDE;
 
-    bool quickInsideClip(const SkRect& devBounds);
-
     virtual void didAddGpuTraceMarker() SK_OVERRIDE {}
     virtual void didRemoveGpuTraceMarker() SK_OVERRIDE {}
 
     // Attempts to concat instances from info onto the previous draw. info must represent an
     // instanced draw. The caller must have already recorded a new draw state and clip if necessary.
-    int concatInstancedDraw(const DrawInfo& info);
+    int concatInstancedDraw(const DrawInfo& info, const GrClipMaskManager::ScissorState&);
 
     // Determines whether the current draw operation requieres a new drawstate and if so records it.
     void recordStateIfNecessary();
     // We lazily record clip changes in order to skip clips that have no effect.
     void recordClipIfNecessary();
     // Records any trace markers for a command after adding it to the buffer.
     void recordTraceMarkersIfNecessary();
 
     virtual bool isIssued(uint32_t drawID) { return drawID != fDrawID; }
 
     // TODO: Use a single allocator for commands and records
     enum {
         kCmdBufferInitialSizeInBytes = 64 * 1024,
         kGeoPoolStatePreAllocCnt     = 4,
     };
 
     CmdBuffer                         fCmdBuffer;
     GrDrawState*                      fLastState;
-    GrClipData*                       fLastClip;
-
     SkTArray<GrTraceMarkerSet, false> fGpuCmdMarkers;
     GrClipTarget*                     fDstGpu;
-    bool                              fClipSet;
-
-    enum ClipProxyState {
-        kUnknown_ClipProxyState,
-        kValid_ClipProxyState,
-        kInvalid_ClipProxyState
-    };
-
-    ClipProxyState                                      fClipProxyState;
-    SkRect                                              fClipProxy;
-    GrVertexBufferAllocPool&                            fVertexPool;
-    GrIndexBufferAllocPool&                             fIndexPool;
+    GrVertexBufferAllocPool&          fVertexPool;
+    GrIndexBufferAllocPool&           fIndexPool;
 
     struct GeometryPoolState {
         const GrVertexBuffer*   fPoolVertexBuffer;
         int                     fPoolStartVertex;
         const GrIndexBuffer*    fPoolIndexBuffer;
         int                     fPoolStartIndex;
         // caller may conservatively over reserve vertices / indices.
         // we release unused space back to allocator if possible
         // can only do this if there isn't an intervening pushGeometrySource()
         size_t                  fUsedPoolVertexBytes;
         size_t                  fUsedPoolIndexBytes;
     };
 
     typedef SkSTArray<kGeoPoolStatePreAllocCnt, GeometryPoolState> GeoPoolStateStack;
 
     GeoPoolStateStack                                   fGeoPoolStateStack;
     bool                                                fFlushing;
     uint32_t                                            fDrawID;
 
     typedef GrClipTarget INHERITED;
 };
 
 #endif