src/gpu/GrRenderTargetOpList.h - skia.git - Git at Google


            
            /*

            
             * 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 "GrAppliedClip.h"

            
            #include "GrOpList.h"

            
            #include "GrPathRendering.h"

            
            #include "GrPrimitiveProcessor.h"

            
            #include "ops/GrOp.h"

            
            #include "ops/GrDrawOp.h"

            
            #include "SkArenaAlloc.h"

            
            #include "SkClipStack.h"

            
            #include "SkMatrix.h"

            
            #include "SkStringUtils.h"

            
            #include "SkStrokeRec.h"

            
            #include "SkTArray.h"

            
            #include "SkTLazy.h"

            
            #include "SkTypes.h"


            class GrAuditTrail;

            
            class GrClearOp;

            
            class GrCaps;

            
            class GrRenderTargetProxy;


            class GrRenderTargetOpList final : public GrOpList {

            
            private:

            
                using DstProxy = GrXferProcessor::DstProxy;


            public:

            
                GrRenderTargetOpList(GrResourceProvider*, sk_sp<GrOpMemoryPool>,

            
                                     GrRenderTargetProxy*, GrAuditTrail*);


                ~GrRenderTargetOpList() override;


                void makeClosed(const GrCaps& caps) override {

            
                    if (this->isClosed()) {

            
                        return;

            
                    }


                    this->forwardCombine(caps);


                    INHERITED::makeClosed(caps);

            
                }


                bool isEmpty() const { return fOpChains.empty(); }


                /**

            
                 * Empties the draw buffer of any queued up draws.

            
                 */

            
                void endFlush() override;


                /**

            
                 * Together these two functions flush all queued up draws to GrCommandBuffer. The return value

            
                 * of executeOps() indicates whether any commands were actually issued to the GPU.

            
                 */

            
                void onPrepare(GrOpFlushState* flushState) override;

            
                bool onExecute(GrOpFlushState* flushState) override;


                void addOp(std::unique_ptr<GrOp> op, const GrCaps& caps) {

            
                    auto addDependency = [ &caps, this ] (GrSurfaceProxy* p) {

            
                        this->addDependency(p, caps);

            
                    };


                    op->visitProxies(addDependency);


                    this->recordOp(std::move(op), GrProcessorSet::EmptySetAnalysis(), nullptr, nullptr, caps);

            
                }


                void addWaitOp(std::unique_ptr<GrOp> op, const GrCaps& caps) {

            
                    fHasWaitOp= true;

            
                    this->addOp(std::move(op), caps);

            
                }


                void addDrawOp(std::unique_ptr<GrDrawOp> op, const GrProcessorSet::Analysis& processorAnalysis,

            
                               GrAppliedClip&& clip, const DstProxy& dstProxy, const GrCaps& caps) {

            
                    auto addDependency = [ &caps, this ] (GrSurfaceProxy* p) {

            
                        this->addDependency(p, caps);

            
                    };


                    op->visitProxies(addDependency);

            
                    clip.visitProxies(addDependency);

            
                    if (dstProxy.proxy()) {

            
                        addDependency(dstProxy.proxy());

            
                    }


                    this->recordOp(std::move(op), processorAnalysis, clip.doesClip() ? &clip : nullptr,

            
                                   &dstProxy, caps);

            
                }


                void discard();


                /**

            
                 * 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(GrRecordingContext*,

            
                                 GrSurfaceProxy* dst,

            
                                 GrSurfaceProxy* src,

            
                                 const SkIRect& srcRect,

            
                                 const SkIPoint& dstPoint) override;


                GrRenderTargetOpList* asRenderTargetOpList() override { return this; }


                SkDEBUGCODE(void dump(bool printDependencies) const override;)

            
                SkDEBUGCODE(int numClips() const override { return fNumClips; })

            
                SkDEBUGCODE(void visitProxies_debugOnly(const GrOp::VisitProxyFunc&) const;)


            private:

            
                friend class GrRenderTargetContextPriv; // for stencil clip state. TODO: this is invasive


                // The RTC and RTOpList have to work together to handle buffer clears. In most cases, buffer

            
                // clearing can be done natively, in which case the op list's load ops are sufficient. In other

            
                // cases, draw ops must be used, which makes the RTC the best place for those decisions. This,

            
                // however, requires that the RTC be able to coordinate with the op list to achieve similar ends

            
                friend class GrRenderTargetContext;


                // Must only be called if native stencil buffer clearing is enabled

            
                void setStencilLoadOp(GrLoadOp op);

            
                // Must only be called if native color buffer clearing is enabled.

            
                void setColorLoadOp(GrLoadOp op, const SkPMColor4f& color);

            
                // Sets the clear color to transparent black

            
                void setColorLoadOp(GrLoadOp op) {

            
                    static const SkPMColor4f kDefaultClearColor = {0.f, 0.f, 0.f, 0.f};

            
                    this->setColorLoadOp(op, kDefaultClearColor);

            
                }


                // Perform book-keeping for a fullscreen clear, regardless of how the clear is implemented later

            
                // (i.e. setColorLoadOp(), adding a ClearOp, or adding a GrFillRectOp that covers the device).

            
                // Returns true if the clear can be converted into a load op (barring device caps).

            
                bool resetForFullscreenClear();


                void deleteOps();


                class OpChain {

            
                public:

            
                    OpChain(const OpChain&) = delete;

            
                    OpChain& operator=(const OpChain&) = delete;

            
                    OpChain(std::unique_ptr<GrOp>, GrProcessorSet::Analysis, GrAppliedClip*, const DstProxy*);


                    ~OpChain() {

            
                        // The ops are stored in a GrMemoryPool and must be explicitly deleted via the pool.

            
                        SkASSERT(fList.empty());

            
                    }


                    void visitProxies(const GrOp::VisitProxyFunc&, GrOp::VisitorType) const;


                    GrOp* head() const { return fList.head(); }


                    GrAppliedClip* appliedClip() const { return fAppliedClip; }

            
                    const DstProxy& dstProxy() const { return fDstProxy; }

            
                    const SkRect& bounds() const { return fBounds; }


                    // Deletes all the ops in the chain via the pool.

            
                    void deleteOps(GrOpMemoryPool* pool);


                    // Attempts to move the ops from the passed chain to this chain at the head. Also attempts

            
                    // to merge ops between the chains. Upon success the passed chain is empty.

            
                    // Fails when the chains aren't of the same op type, have different clips or dst proxies.

            
                    bool prependChain(OpChain*, const GrCaps&, GrOpMemoryPool*, GrAuditTrail*);


                    // Attempts to add 'op' to this chain either by merging or adding to the tail. Returns

            
                    // 'op' to the caller upon failure, otherwise null. Fails when the op and chain aren't of

            
                    // the same op type, have different clips or dst proxies.

            
                    std::unique_ptr<GrOp> appendOp(std::unique_ptr<GrOp> op, GrProcessorSet::Analysis,

            
                                                   const DstProxy*, const GrAppliedClip*, const GrCaps&,

            
                                                   GrOpMemoryPool*, GrAuditTrail*);


                private:

            
                    class List {

            
                    public:

            
                        List() = default;

            
                        List(std::unique_ptr<GrOp>);

            
                        List(List&&);

            
                        List& operator=(List&& that);


                        bool empty() const { return !SkToBool(fHead); }

            
                        GrOp* head() const { return fHead.get(); }

            
                        GrOp* tail() const { return fTail; }


                        std::unique_ptr<GrOp> popHead();

            
                        std::unique_ptr<GrOp> removeOp(GrOp* op);

            
                        void pushHead(std::unique_ptr<GrOp> op);

            
                        void pushTail(std::unique_ptr<GrOp>);


                        void validate() const;


                    private:

            
                        std::unique_ptr<GrOp> fHead;

            
                        GrOp* fTail = nullptr;

            
                    };


                    void validate() const;


                    bool tryConcat(List*, GrProcessorSet::Analysis, const DstProxy&, const GrAppliedClip*,

            
                                   const SkRect& bounds, const GrCaps&, GrOpMemoryPool*, GrAuditTrail*);

            
                    static List DoConcat(List, List, const GrCaps&, GrOpMemoryPool*, GrAuditTrail*);


                    List fList;

            
                    GrProcessorSet::Analysis fProcessorAnalysis;

            
                    DstProxy fDstProxy;

            
                    GrAppliedClip* fAppliedClip;

            
                    SkRect fBounds;

            
                };


                void purgeOpsWithUninstantiatedProxies() override;


                void gatherProxyIntervals(GrResourceAllocator*) const override;


                void recordOp(std::unique_ptr<GrOp>, GrProcessorSet::Analysis, GrAppliedClip*, const DstProxy*,

            
                              const GrCaps& caps);


                void forwardCombine(const GrCaps&);


                uint32_t                       fLastClipStackGenID;

            
                SkIRect                        fLastDevClipBounds;

            
                int                            fLastClipNumAnalyticFPs;


                // We must track if we have a wait op so that we don't delete the op when we have a full clear.

            
                bool fHasWaitOp = false;;


                // For ops/opList we have mean: 5 stdDev: 28

            
                SkSTArray<25, OpChain, true> fOpChains;


                // MDB TODO: 4096 for the first allocation of the clip space will be huge overkill.

            
                // Gather statistics to determine the correct size.

            
                SkArenaAlloc                   fClipAllocator{4096};

            
                SkDEBUGCODE(int                fNumClips;)


                typedef GrOpList INHERITED;

            
            };


            #endif
	/*
	* 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 "GrAppliedClip.h"
	#include "GrOpList.h"
	#include "GrPathRendering.h"
	#include "GrPrimitiveProcessor.h"
	#include "ops/GrOp.h"
	#include "ops/GrDrawOp.h"
	#include "SkArenaAlloc.h"
	#include "SkClipStack.h"
	#include "SkMatrix.h"
	#include "SkStringUtils.h"
	#include "SkStrokeRec.h"
	#include "SkTArray.h"
	#include "SkTLazy.h"
	#include "SkTypes.h"

	class GrAuditTrail;
	class GrClearOp;
	class GrCaps;
	class GrRenderTargetProxy;

	class GrRenderTargetOpList final : public GrOpList {
	private:
	using DstProxy = GrXferProcessor::DstProxy;

	public:
	GrRenderTargetOpList(GrResourceProvider*, sk_sp<GrOpMemoryPool>,
	GrRenderTargetProxy, GrAuditTrail);

	~GrRenderTargetOpList() override;

	void makeClosed(const GrCaps& caps) override {
	if (this->isClosed()) {
	return;
	}

	this->forwardCombine(caps);

	INHERITED::makeClosed(caps);
	}

	bool isEmpty() const { return fOpChains.empty(); }

	/**
	* Empties the draw buffer of any queued up draws.
	*/
	void endFlush() override;

	/**
	* Together these two functions flush all queued up draws to GrCommandBuffer. The return value
	* of executeOps() indicates whether any commands were actually issued to the GPU.
	*/
	void onPrepare(GrOpFlushState* flushState) override;
	bool onExecute(GrOpFlushState* flushState) override;

	void addOp(std::unique_ptr<GrOp> op, const GrCaps& caps) {
	auto addDependency = [ &caps, this ] (GrSurfaceProxy* p) {
	this->addDependency(p, caps);
	};

	op->visitProxies(addDependency);

	this->recordOp(std::move(op), GrProcessorSet::EmptySetAnalysis(), nullptr, nullptr, caps);
	}

	void addWaitOp(std::unique_ptr<GrOp> op, const GrCaps& caps) {
	fHasWaitOp= true;
	this->addOp(std::move(op), caps);
	}

	void addDrawOp(std::unique_ptr<GrDrawOp> op, const GrProcessorSet::Analysis& processorAnalysis,
	GrAppliedClip&& clip, const DstProxy& dstProxy, const GrCaps& caps) {
	auto addDependency = [ &caps, this ] (GrSurfaceProxy* p) {
	this->addDependency(p, caps);
	};

	op->visitProxies(addDependency);
	clip.visitProxies(addDependency);
	if (dstProxy.proxy()) {
	addDependency(dstProxy.proxy());
	}

	this->recordOp(std::move(op), processorAnalysis, clip.doesClip() ? &clip : nullptr,
	&dstProxy, caps);
	}

	void discard();

	/**
	* 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(GrRecordingContext*,
	GrSurfaceProxy* dst,
	GrSurfaceProxy* src,
	const SkIRect& srcRect,
	const SkIPoint& dstPoint) override;

	GrRenderTargetOpList* asRenderTargetOpList() override { return this; }

	SkDEBUGCODE(void dump(bool printDependencies) const override;)
	SkDEBUGCODE(int numClips() const override { return fNumClips; })
	SkDEBUGCODE(void visitProxies_debugOnly(const GrOp::VisitProxyFunc&) const;)

	private:
	friend class GrRenderTargetContextPriv; // for stencil clip state. TODO: this is invasive

	// The RTC and RTOpList have to work together to handle buffer clears. In most cases, buffer
	// clearing can be done natively, in which case the op list's load ops are sufficient. In other
	// cases, draw ops must be used, which makes the RTC the best place for those decisions. This,
	// however, requires that the RTC be able to coordinate with the op list to achieve similar ends
	friend class GrRenderTargetContext;

	// Must only be called if native stencil buffer clearing is enabled
	void setStencilLoadOp(GrLoadOp op);
	// Must only be called if native color buffer clearing is enabled.
	void setColorLoadOp(GrLoadOp op, const SkPMColor4f& color);
	// Sets the clear color to transparent black
	void setColorLoadOp(GrLoadOp op) {
	static const SkPMColor4f kDefaultClearColor = {0.f, 0.f, 0.f, 0.f};
	this->setColorLoadOp(op, kDefaultClearColor);
	}

	// Perform book-keeping for a fullscreen clear, regardless of how the clear is implemented later
	// (i.e. setColorLoadOp(), adding a ClearOp, or adding a GrFillRectOp that covers the device).
	// Returns true if the clear can be converted into a load op (barring device caps).
	bool resetForFullscreenClear();

	void deleteOps();

	class OpChain {
	public:
	OpChain(const OpChain&) = delete;
	OpChain& operator=(const OpChain&) = delete;
	OpChain(std::unique_ptr<GrOp>, GrProcessorSet::Analysis, GrAppliedClip, const DstProxy);

	~OpChain() {
	// The ops are stored in a GrMemoryPool and must be explicitly deleted via the pool.
	SkASSERT(fList.empty());
	}

	void visitProxies(const GrOp::VisitProxyFunc&, GrOp::VisitorType) const;

	GrOp* head() const { return fList.head(); }

	GrAppliedClip* appliedClip() const { return fAppliedClip; }
	const DstProxy& dstProxy() const { return fDstProxy; }
	const SkRect& bounds() const { return fBounds; }

	// Deletes all the ops in the chain via the pool.
	void deleteOps(GrOpMemoryPool* pool);

	// Attempts to move the ops from the passed chain to this chain at the head. Also attempts
	// to merge ops between the chains. Upon success the passed chain is empty.
	// Fails when the chains aren't of the same op type, have different clips or dst proxies.
	bool prependChain(OpChain, const GrCaps&, GrOpMemoryPool, GrAuditTrail*);

	// Attempts to add 'op' to this chain either by merging or adding to the tail. Returns
	// 'op' to the caller upon failure, otherwise null. Fails when the op and chain aren't of
	// the same op type, have different clips or dst proxies.
	std::unique_ptr<GrOp> appendOp(std::unique_ptr<GrOp> op, GrProcessorSet::Analysis,
	const DstProxy, const GrAppliedClip, const GrCaps&,
	GrOpMemoryPool, GrAuditTrail);

	private:
	class List {
	public:
	List() = default;
	List(std::unique_ptr<GrOp>);
	List(List&&);
	List& operator=(List&& that);

	bool empty() const { return !SkToBool(fHead); }
	GrOp* head() const { return fHead.get(); }
	GrOp* tail() const { return fTail; }

	std::unique_ptr<GrOp> popHead();
	std::unique_ptr<GrOp> removeOp(GrOp* op);
	void pushHead(std::unique_ptr<GrOp> op);
	void pushTail(std::unique_ptr<GrOp>);

	void validate() const;

	private:
	std::unique_ptr<GrOp> fHead;
	GrOp* fTail = nullptr;
	};

	void validate() const;

	bool tryConcat(List, GrProcessorSet::Analysis, const DstProxy&, const GrAppliedClip,
	const SkRect& bounds, const GrCaps&, GrOpMemoryPool, GrAuditTrail);
	static List DoConcat(List, List, const GrCaps&, GrOpMemoryPool, GrAuditTrail);

	List fList;
	GrProcessorSet::Analysis fProcessorAnalysis;
	DstProxy fDstProxy;
	GrAppliedClip* fAppliedClip;
	SkRect fBounds;
	};

	void purgeOpsWithUninstantiatedProxies() override;

	void gatherProxyIntervals(GrResourceAllocator*) const override;

	void recordOp(std::unique_ptr<GrOp>, GrProcessorSet::Analysis, GrAppliedClip, const DstProxy,
	const GrCaps& caps);

	void forwardCombine(const GrCaps&);

	uint32_t fLastClipStackGenID;
	SkIRect fLastDevClipBounds;
	int fLastClipNumAnalyticFPs;

	// We must track if we have a wait op so that we don't delete the op when we have a full clear.
	bool fHasWaitOp = false;;

	// For ops/opList we have mean: 5 stdDev: 28
	SkSTArray<25, OpChain, true> fOpChains;

	// MDB TODO: 4096 for the first allocation of the clip space will be huge overkill.
	// Gather statistics to determine the correct size.
	SkArenaAlloc fClipAllocator{4096};
	SkDEBUGCODE(int fNumClips;)

	typedef GrOpList INHERITED;
	};

	#endif