Add GrOpList and rename GrDrawTarget to GrRenderTargetOpList

GOLD_TRYBOT_URL= https://gold.skia.org/search?issue=3910

Change-Id: I026aa26ecc61a0d002e98892dca728536259e8b1
Reviewed-on: https://skia-review.googlesource.com/3910
Reviewed-by: Brian Osman <brianosman@google.com>
Commit-Queue: Robert Phillips <robertphillips@google.com>

1 files changed, 175 insertions, 0 deletions

diff --git a/src/gpu/GrRenderTargetOpList.h b/src/gpu/GrRenderTargetOpList.h
new file mode 100644
index 0000000000..080ff69ce4
--- /dev/null
+++ b/src/gpu/GrRenderTargetOpList.h
@@ -0,0 +1,175 @@
+/*
+ * 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 GrRenderTargetOpList_DEFINED
+#define GrRenderTargetOpList_DEFINED
+
+#include "GrClip.h"
+#include "GrContext.h"
+#include "GrOpList.h"
+#include "GrPathProcessor.h"
+#include "GrPrimitiveProcessor.h"
+#include "GrPathRendering.h"
+#include "GrXferProcessor.h"
+
+#include "batches/GrDrawBatch.h"
+
+#include "SkClipStack.h"
+#include "SkMatrix.h"
+#include "SkPath.h"
+#include "SkStringUtils.h"
+#include "SkStrokeRec.h"
+#include "SkTArray.h"
+#include "SkTLazy.h"
+#include "SkTypes.h"
+#include "SkXfermode.h"
+
+class GrAuditTrail;
+class GrBatch;
+class GrClearBatch;
+class GrClip;
+class GrCaps;
+class GrPath;
+class GrDrawPathBatchBase;
+class GrPipelineBuilder;
+
+class GrRenderTargetOpList final : public GrOpList {
+public:
+    /** Options for GrRenderTargetOpList behavior. */
+    struct Options {
+        Options ()
+            : fClipBatchToBounds(false)
+            , fDrawBatchBounds(false)
+            , fMaxBatchLookback(-1)
+            , fMaxBatchLookahead(-1) {}
+        bool fClipBatchToBounds;
+        bool fDrawBatchBounds;
+        int  fMaxBatchLookback;
+        int  fMaxBatchLookahead;
+    };
+
+    GrRenderTargetOpList(GrRenderTarget*, GrGpu*, GrResourceProvider*,
+                         GrAuditTrail*, const Options&);
+
+    ~GrRenderTargetOpList() override;
+
+    void makeClosed() override {
+        INHERITED::makeClosed();
+
+        fLastFullClearBatch = nullptr;
+        this->forwardCombine();
+    }
+
+    /**
+     * Empties the draw buffer of any queued up draws.
+     */
+    void reset() override;
+
+    void abandonGpuResources() override;
+    void freeGpuResources() override;
+
+    /**
+     * Together these two functions flush all queued up draws to GrCommandBuffer. The return value
+     * of drawBatches() indicates whether any commands were actually issued to the GPU.
+     */
+    void prepareBatches(GrBatchFlushState* flushState) override;
+    bool drawBatches(GrBatchFlushState* flushState) override;
+
+    /**
+     * Gets the capabilities of the draw target.
+     */
+    const GrCaps* caps() const { return fGpu->caps(); }
+
+    void drawBatch(const GrPipelineBuilder&, GrDrawContext*, const GrClip&, GrDrawBatch*);
+
+    void addBatch(sk_sp<GrBatch>);
+
+    /**
+     * Draws the path into user stencil bits. Upon return, all user stencil values
+     * inside the path will be nonzero. The path's fill must be either even/odd or
+     * winding (notnverse or hairline).It will respect the HW antialias boolean (if
+     * possible in the 3D API).  Note, we will never have an inverse fill with
+     * stencil path.
+     */
+    void stencilPath(GrDrawContext*,
+                     const GrClip&,
+                     bool useHWAA,
+                     const SkMatrix& viewMatrix,
+                     const GrPath*);
+
+    /** Clears the entire render target */
+    void fullClear(GrRenderTarget*, GrColor color);
+
+    /** Discards the contents render target. */
+    void discard(GrRenderTarget*);
+
+    /**
+     * Copies a pixel rectangle from one surface to another. This call may finalize
+     * reserved vertex/index data (as though a draw call was made). The src pixels
+     * copied are specified by srcRect. They are copied to a rect of the same
+     * size in dst with top left at dstPoint. If the src rect is clipped by the
+     * src bounds then  pixel values in the dst rect corresponding to area clipped
+     * by the src rect are not overwritten. This method is not guaranteed to succeed
+     * depending on the type of surface, configs, etc, and the backend-specific
+     * limitations.
+     */
+    bool copySurface(GrSurface* dst,
+                     GrSurface* src,
+                     const SkIRect& srcRect,
+                     const SkIPoint& dstPoint);
+
+    gr_instanced::InstancedRendering* instancedRendering() const {
+        SkASSERT(fInstancedRendering);
+        return fInstancedRendering;
+    }
+
+    SkDEBUGCODE(void dump() const override;)
+
+private:
+    friend class GrDrawContextPriv; // for clearStencilClip
+
+    // Returns the batch that the input batch was combined with or the input batch if it wasn't
+    // combined.
+    GrBatch* recordBatch(GrBatch*, const SkRect& clippedBounds);
+    void forwardCombine();
+
+    // Makes a copy of the dst if it is necessary for the draw. Returns false if a copy is required
+    // but couldn't be made. Otherwise, returns true.  This method needs to be protected because it
+    // needs to be accessed by GLPrograms to setup a correct drawstate
+    bool setupDstReadIfNecessary(const GrPipelineBuilder&,
+                                 GrRenderTarget*,
+                                 const GrClip&,
+                                 const GrPipelineOptimizations& optimizations,
+                                 GrXferProcessor::DstTexture*,
+                                 const SkRect& batchBounds);
+
+    // Used only by drawContextPriv.
+    void clearStencilClip(const GrFixedClip&, bool insideStencilMask, GrRenderTarget*);
+
+    struct RecordedBatch {
+        sk_sp<GrBatch> fBatch;
+        SkRect         fClippedBounds;
+    };
+    SkSTArray<256, RecordedBatch, true>             fRecordedBatches;
+    GrClearBatch*                                   fLastFullClearBatch;
+    // The context is only in service of the GrClip, remove once it doesn't need this.
+    GrContext*                                      fContext;
+    GrGpu*                                          fGpu;
+    GrResourceProvider*                             fResourceProvider;
+    GrAuditTrail*                                   fAuditTrail;
+
+    bool                                            fClipBatchToBounds;
+    bool                                            fDrawBatchBounds;
+    int                                             fMaxBatchLookback;
+    int                                             fMaxBatchLookahead;
+
+    SkAutoTDelete<gr_instanced::InstancedRendering> fInstancedRendering;
+
+    typedef GrOpList INHERITED;
+};
+
+#endif