scissor state on optstate

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 98 matching lines @@
     struct Cmd : ::SkNoncopyable {
         Cmd(uint8_t type) : fType(type) {}
         virtual ~Cmd() {}
 
         virtual void execute(GrInOrderDrawBuffer*, const GrOptDrawState*) = 0;
 
         uint8_t fType;
     };
 
     struct Draw : public Cmd {
-        Draw(const DrawInfo& info, const ScissorState& scissorState)
-            : Cmd(kDraw_Cmd)
-            , fInfo(info)
-            , fScissorState(scissorState){}
+        Draw(const DrawInfo& info) : Cmd(kDraw_Cmd), fInfo(info) {}
 
         virtual void execute(GrInOrderDrawBuffer*, const GrOptDrawState*);
 
         DrawInfo     fInfo;
-        ScissorState fScissorState;
     };
 
     struct StencilPath : public Cmd {
         StencilPath(const GrPath* path) : Cmd(kStencilPath_Cmd), fPath(path) {}
 
         const GrPath* path() const { return fPath.get(); }
 
         virtual void execute(GrInOrderDrawBuffer*, const GrOptDrawState*);
 
-        ScissorState      fScissorState;
         GrStencilSettings fStencilSettings;
 
     private:
         GrPendingIOResource<const GrPath, kRead_GrIOType>   fPath;
     };
 
     struct DrawPath : public Cmd {
         DrawPath(const GrPath* path) : Cmd(kDrawPath_Cmd), fPath(path) {}
 
         const GrPath* path() const { return fPath.get(); }
 
         virtual void execute(GrInOrderDrawBuffer*, const GrOptDrawState*);
 
         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) {}
 
         const GrPathRange* pathRange() const { return fPathRange.get();  }
 
         virtual void execute(GrInOrderDrawBuffer*, const GrOptDrawState*);
 
         int                     fIndicesLocation;
         size_t                  fCount;
         int                     fTransformsLocation;
         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) {}
 
@@ skipping 49 matching lines @@
         GrGpu::DrawType                     fDrawType;
         GrDeviceCoordTexture                fDstCopy;
     };
 
     typedef void* TCmdAlign; // This wouldn't be enough align if a command used long double.
     typedef GrTRecorder<Cmd, TCmdAlign> CmdBuffer;
 
     // overrides from GrDrawTarget
     void onDraw(const GrDrawState&,
                 const DrawInfo&,
-                const GrClipMaskManager::ScissorState&) SK_OVERRIDE;
+                const ScissorState&) SK_OVERRIDE;
     void onDrawRect(GrDrawState*,
                     const SkRect& rect,
                     const SkRect* localRect,
                     const SkMatrix* localMatrix) SK_OVERRIDE;
 
     void onStencilPath(const GrDrawState&,
                        const GrPath*,
-                       const GrClipMaskManager::ScissorState&,
+                       const ScissorState&,
                        const GrStencilSettings&) SK_OVERRIDE;
     void onDrawPath(const GrDrawState&,
                     const GrPath*,
-                    const GrClipMaskManager::ScissorState&,
+                    const ScissorState&,
                     const GrStencilSettings&,
                     const GrDeviceCoordTexture* dstCopy) SK_OVERRIDE;
     void onDrawPaths(const GrDrawState&,
                      const GrPathRange*,
                      const uint32_t indices[],
                      int count,
                      const float transforms[],
                      PathTransformType,
-                     const GrClipMaskManager::ScissorState&,
+                     const ScissorState&,
                      const GrStencilSettings&,
                      const GrDeviceCoordTexture*) SK_OVERRIDE;
     void onClear(const SkIRect* rect,
                  GrColor color,
                  bool canIgnoreRect,
                  GrRenderTarget* renderTarget) SK_OVERRIDE;
     void setDrawBuffers(DrawInfo*) SK_OVERRIDE;
 
     bool onReserveVertexSpace(size_t vertexSize, int vertexCount, void** vertices) SK_OVERRIDE;
     bool onReserveIndexSpace(int indexCount, void** indices) SK_OVERRIDE;
     void releaseReservedVertexSpace() SK_OVERRIDE;
     void releaseReservedIndexSpace() SK_OVERRIDE;
     void geometrySourceWillPush() SK_OVERRIDE;
     void geometrySourceWillPop(const GeometrySrcState& restoredState) SK_OVERRIDE;
     void willReserveVertexAndIndexSpace(int vertexCount,
                                         size_t vertexStride,
                                         int indexCount) 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 GrDrawState&,
-                            const DrawInfo&,
-                            const GrClipMaskManager::ScissorState&);
+    int concatInstancedDraw(const GrDrawState&, const DrawInfo&);
 
     // Determines whether the current draw operation requires a new GrOptDrawState and if so
     // records it. If the draw can be skipped false is returned and no new GrOptDrawState is
     // recorded.
     bool SK_WARN_UNUSED_RESULT recordStateAndShouldDraw(const GrDrawState&,
                                                         GrGpu::DrawType,
+                                                        const GrClipMaskManager::ScissorState&,
                                                         const GrDeviceCoordTexture*);
     // 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 {
@@ skipping 26 matching lines @@
     SkTDArray<uint32_t>                 fPathIndexBuffer;
     SkTDArray<float>                    fPathTransformBuffer;
     GeoPoolStateStack                   fGeoPoolStateStack;
     bool                                fFlushing;
     uint32_t                            fDrawID;
 
     typedef GrClipTarget INHERITED;
 };
 
 #endif