src/gpu/ops/GrOp.h - platform/external/skia - Gitiles

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */

 #ifndef GrOp_DEFINED
 #define GrOp_DEFINED

 #include "GrGpuResource.h"
 #include "GrNonAtomicRef.h"
 #include "GrTracing.h"
 #include "GrXferProcessor.h"
 #include "SkMatrix.h"
 #include "SkRect.h"
 #include "SkString.h"
 #include <atomic>
 #include <new>

 class GrCaps;
 class GrGpuCommandBuffer;
 class GrOpFlushState;
 class GrRenderTargetOpList;

 /**
  * GrOp is the base class for all Ganesh deferred GPU operations. To facilitate reordering and to
  * minimize draw calls, Ganesh does not generate geometry inline with draw calls. Instead, it
  * captures the arguments to the draw and then generates the geometry when flushing. This gives GrOp
  * subclasses complete freedom to decide how/when to combine in order to produce fewer draw calls
  * and minimize state changes.
  *
  * Ops of the same subclass may be merged or chained using combineIfPossible. When two ops merge,
  * one takes on the union of the data and the other is left empty. The merged op becomes responsible
  * for drawing the data from both the original ops. When ops are chained each op maintains its own
  * data but they are linked in a list and the head op becomes responsible for executing the work for
  * the chain.
  *
  * It is required that chainability is transitive. Moreover, if op A is able to merge with B then
  * it must be the case that any op that can chain with A will either merge or chain with any op
  * that can chain to B.
  *
  * The bounds of the op must contain all the vertices in device space *irrespective* of the clip.
  * The bounds are used in determining which clip elements must be applied and thus the bounds cannot
  * in turn depend upon the clip.
  */
 #define GR_OP_SPEW 0
 #if GR_OP_SPEW
     #define GrOP_SPEW(code) code
     #define GrOP_INFO(...) SkDebugf(__VA_ARGS__)
 #else
     #define GrOP_SPEW(code)
     #define GrOP_INFO(...)
 #endif

 // Print out op information at flush time
 #define GR_FLUSH_TIME_OP_SPEW 0

 // A helper macro to generate a class static id
 #define DEFINE_OP_CLASS_ID \
     static uint32_t ClassID() { \
         static uint32_t kClassID = GenOpClassID(); \
         return kClassID; \
     }

 class GrOp : private SkNoncopyable {
 public:
     virtual ~GrOp() = default;

     virtual const char* name() const = 0;

     typedef std::function<void(GrSurfaceProxy*)> VisitProxyFunc;

     /**
      * Knowning the type of visitor may enable an op to be more efficient by skipping irrelevant
      * proxies on visitProxies.
      */
     enum class VisitorType : unsigned {
         /**
          * Ops *may* skip proxy visitation for allocation for proxies that have the
          * canSkipResourceAllocator() property.
          */
         kAllocatorGather,
         /**
          * Ops should visit all proxies.
          */
         kOther,
     };
     virtual void visitProxies(const VisitProxyFunc&, VisitorType = VisitorType::kOther) const {
         // This default implementation assumes the op has no proxies
     }

     enum class CombineResult {
         /**
          * The op that combineIfPossible was called on now represents its own work plus that of
          * the passed op. The passed op should be destroyed without being flushed. Currently it
          * is not legal to merge an op passed to combineIfPossible() the passed op is already in a
          * chain (though the op on which combineIfPossible() was called may be).
          */
         kMerged,
         /**
          * The caller *may* (but is not required) to chain these ops together. If they are chained
          * then prepare() and execute() will be called on the head op but not the other ops in the
          * chain. The head op will prepare and execute on behalf of all the ops in the chain.
          */
         kMayChain,
         /**
          * The ops cannot be combined.
          */
         kCannotCombine
     };

     CombineResult combineIfPossible(GrOp* that, const GrCaps& caps);

     const SkRect& bounds() const {
         SkASSERT(kUninitialized_BoundsFlag != fBoundsFlags);
         return fBounds;
     }

     void setClippedBounds(const SkRect& clippedBounds) {
         fBounds = clippedBounds;
         // The clipped bounds already incorporate any effect of the bounds flags.
         fBoundsFlags = 0;
     }

     bool hasAABloat() const {
         SkASSERT(fBoundsFlags != kUninitialized_BoundsFlag);
         return SkToBool(fBoundsFlags & kAABloat_BoundsFlag);
     }

     bool hasZeroArea() const {
         SkASSERT(fBoundsFlags != kUninitialized_BoundsFlag);
         return SkToBool(fBoundsFlags & kZeroArea_BoundsFlag);
     }

 #ifdef SK_DEBUG
     // All GrOp-derived classes should be allocated in and deleted from a GrMemoryPool
     void* operator new(size_t size);
     void operator delete(void* target);

     void* operator new(size_t size, void* placement) {
         return ::operator new(size, placement);
     }
     void operator delete(void* target, void* placement) {
         ::operator delete(target, placement);
     }
 #endif

     /**
      * Helper for safely down-casting to a GrOp subclass
      */
     template <typename T> const T& cast() const {
         SkASSERT(T::ClassID() == this->classID());
         return *static_cast<const T*>(this);
     }

     template <typename T> T* cast() {
         SkASSERT(T::ClassID() == this->classID());
         return static_cast<T*>(this);
     }

     uint32_t classID() const { SkASSERT(kIllegalOpID != fClassID); return fClassID; }

     // We lazily initialize the uniqueID because currently the only user is GrAuditTrail
     uint32_t uniqueID() const {
         if (kIllegalOpID == fUniqueID) {
             fUniqueID = GenOpID();
         }
         return fUniqueID;
     }

     /**
      * Called prior to executing. The op should perform any resource creation or data transfers
      * necessary before execute() is called.
      */
     void prepare(GrOpFlushState* state) { this->onPrepare(state); }

     /** Issues the op's commands to GrGpu. */
     void execute(GrOpFlushState* state, const SkRect& chainBounds) {
         TRACE_EVENT0("skia", name());
         this->onExecute(state, chainBounds);
     }

     /** Used for spewing information about ops when debugging. */
 #ifdef SK_DEBUG
     virtual SkString dumpInfo() const {
         SkString string;
         string.appendf("OpBounds: [L: %.2f, T: %.2f, R: %.2f, B: %.2f]\n",
                        fBounds.fLeft, fBounds.fTop, fBounds.fRight, fBounds.fBottom);
         return string;
     }
 #else
     SkString dumpInfo() const { return SkString("<Op information unavailable>"); }
 #endif

     /**
      * A helper for iterating over an op chain in a range for loop that also downcasts to a GrOp
      * subclass. E.g.:
      *     for (MyOpSubClass& op : ChainRange<MyOpSubClass>(this)) {
      *         // ...
      *     }
      */
     template <typename OpSubclass = GrOp> class ChainRange {
     private:
         class Iter {
         public:
             explicit Iter(const OpSubclass* head) : fCurr(head) {}
             inline Iter& operator++() {
                 return *this = Iter(static_cast<const OpSubclass*>(fCurr->nextInChain()));
             }
             const OpSubclass& operator*() const { return *fCurr; }
             bool operator!=(const Iter& that) const { return fCurr != that.fCurr; }

         private:
             const OpSubclass* fCurr;
         };
         const OpSubclass* fHead;

     public:
         explicit ChainRange(const OpSubclass* head) : fHead(head) {}
         Iter begin() { return Iter(fHead); }
         Iter end() { return Iter(nullptr); }
     };

     /**
      * Concatenates two op chains. This op must be a tail and the passed op must be a head. The ops
      * must be of the same subclass.
      */
     void chainConcat(std::unique_ptr<GrOp>);
     /** Returns true if this is the head of a chain (including a length 1 chain). */
     bool isChainHead() const { return !fPrevInChain; }
     /** Returns true if this is the tail of a chain (including a length 1 chain). */
     bool isChainTail() const { return !fNextInChain; }
     /** The next op in the chain. */
     GrOp* nextInChain() const { return fNextInChain.get(); }
     /** The previous op in the chain. */
     GrOp* prevInChain() const { return fPrevInChain; }
     /**
      * Cuts the chain after this op. The returned op is the op that was previously next in the
      * chain or null if this was already a tail.
      */
     std::unique_ptr<GrOp> cutChain();
     SkDEBUGCODE(void validateChain(GrOp* expectedTail = nullptr) const);

 #ifdef SK_DEBUG
     virtual void validate() const {}
 #endif

 protected:
     GrOp(uint32_t classID);

     /**
      * Indicates that the op will produce geometry that extends beyond its bounds for the
      * purpose of ensuring that the fragment shader runs on partially covered pixels for
      * non-MSAA antialiasing.
      */
     enum class HasAABloat : bool {
         kNo = false,
         kYes = true
     };
     /**
      * Indicates that the geometry represented by the op has zero area (e.g. it is hairline or
      * points).
      */
     enum class IsZeroArea : bool {
         kNo = false,
         kYes = true
     };

     void setBounds(const SkRect& newBounds, HasAABloat aabloat, IsZeroArea zeroArea) {
         fBounds = newBounds;
         this->setBoundsFlags(aabloat, zeroArea);
     }
     void setTransformedBounds(const SkRect& srcBounds, const SkMatrix& m,
                               HasAABloat aabloat, IsZeroArea zeroArea) {
         m.mapRect(&fBounds, srcBounds);
         this->setBoundsFlags(aabloat, zeroArea);
     }
     void makeFullScreen(GrSurfaceProxy* proxy) {
         this->setBounds(SkRect::MakeIWH(proxy->width(), proxy->height()),
                         HasAABloat::kNo, IsZeroArea::kNo);
     }

     static uint32_t GenOpClassID() { return GenID(&gCurrOpClassID); }

 private:
     void joinBounds(const GrOp& that) {
         if (that.hasAABloat()) {
             fBoundsFlags |= kAABloat_BoundsFlag;
         }
         if (that.hasZeroArea()) {
             fBoundsFlags |= kZeroArea_BoundsFlag;
         }
         return fBounds.joinPossiblyEmptyRect(that.fBounds);
     }

     virtual CombineResult onCombineIfPossible(GrOp*, const GrCaps&) {
         return CombineResult::kCannotCombine;
     }

     virtual void onPrepare(GrOpFlushState*) = 0;
     // If this op is chained then chainBounds is the union of the bounds of all ops in the chain.
     // Otherwise, this op's bounds.
     virtual void onExecute(GrOpFlushState*, const SkRect& chainBounds) = 0;

     static uint32_t GenID(std::atomic<uint32_t>* idCounter) {
         uint32_t id = (*idCounter)++;
         if (id == 0) {
             SK_ABORT("This should never wrap as it should only be called once for each GrOp "
                    "subclass.");
         }
         return id;
     }

     void setBoundsFlags(HasAABloat aabloat, IsZeroArea zeroArea) {
         fBoundsFlags = 0;
         fBoundsFlags |= (HasAABloat::kYes == aabloat) ? kAABloat_BoundsFlag : 0;
         fBoundsFlags |= (IsZeroArea ::kYes == zeroArea) ? kZeroArea_BoundsFlag : 0;
     }

     enum {
         kIllegalOpID = 0,
     };

     enum BoundsFlags {
         kAABloat_BoundsFlag                     = 0x1,
         kZeroArea_BoundsFlag                    = 0x2,
         SkDEBUGCODE(kUninitialized_BoundsFlag   = 0x4)
     };

     std::unique_ptr<GrOp>               fNextInChain;
     GrOp*                               fPrevInChain = nullptr;
     const uint16_t                      fClassID;
     uint16_t                            fBoundsFlags;

     static uint32_t GenOpID() { return GenID(&gCurrOpUniqueID); }
     mutable uint32_t                    fUniqueID = SK_InvalidUniqueID;
     SkRect                              fBounds;

     static std::atomic<uint32_t> gCurrOpUniqueID;
     static std::atomic<uint32_t> gCurrOpClassID;
 };

 #endif
	/*
	* Copyright 2015 Google Inc.
	*
	* Use of this source code is governed by a BSD-style license that can be
	* found in the LICENSE file.
	*/

	#ifndef GrOp_DEFINED
	#define GrOp_DEFINED

	#include "GrGpuResource.h"
	#include "GrNonAtomicRef.h"
	#include "GrTracing.h"
	#include "GrXferProcessor.h"
	#include "SkMatrix.h"
	#include "SkRect.h"
	#include "SkString.h"
	#include <atomic>
	#include <new>

	class GrCaps;
	class GrGpuCommandBuffer;
	class GrOpFlushState;
	class GrRenderTargetOpList;

	/**
	* GrOp is the base class for all Ganesh deferred GPU operations. To facilitate reordering and to
	* minimize draw calls, Ganesh does not generate geometry inline with draw calls. Instead, it
	* captures the arguments to the draw and then generates the geometry when flushing. This gives GrOp
	* subclasses complete freedom to decide how/when to combine in order to produce fewer draw calls
	* and minimize state changes.
	*
	* Ops of the same subclass may be merged or chained using combineIfPossible. When two ops merge,
	* one takes on the union of the data and the other is left empty. The merged op becomes responsible
	* for drawing the data from both the original ops. When ops are chained each op maintains its own
	* data but they are linked in a list and the head op becomes responsible for executing the work for
	* the chain.
	*
	* It is required that chainability is transitive. Moreover, if op A is able to merge with B then
	* it must be the case that any op that can chain with A will either merge or chain with any op
	* that can chain to B.
	*
	* The bounds of the op must contain all the vertices in device space irrespective of the clip.
	* The bounds are used in determining which clip elements must be applied and thus the bounds cannot
	* in turn depend upon the clip.
	*/
	#define GR_OP_SPEW 0
	#if GR_OP_SPEW
	#define GrOP_SPEW(code) code
	#define GrOP_INFO(...) SkDebugf(__VA_ARGS__)
	#else
	#define GrOP_SPEW(code)
	#define GrOP_INFO(...)
	#endif

	// Print out op information at flush time
	#define GR_FLUSH_TIME_OP_SPEW 0

	// A helper macro to generate a class static id
	#define DEFINE_OP_CLASS_ID \
	static uint32_t ClassID() { \
	static uint32_t kClassID = GenOpClassID(); \
	return kClassID; \
	}

	class GrOp : private SkNoncopyable {
	public:
	virtual ~GrOp() = default;

	virtual const char* name() const = 0;

	typedef std::function<void(GrSurfaceProxy*)> VisitProxyFunc;

	/**
	* Knowning the type of visitor may enable an op to be more efficient by skipping irrelevant
	* proxies on visitProxies.
	*/
	enum class VisitorType : unsigned {
	/**
	* Ops may skip proxy visitation for allocation for proxies that have the
	* canSkipResourceAllocator() property.
	*/
	kAllocatorGather,
	/**
	* Ops should visit all proxies.
	*/
	kOther,
	};
	virtual void visitProxies(const VisitProxyFunc&, VisitorType = VisitorType::kOther) const {
	// This default implementation assumes the op has no proxies
	}

	enum class CombineResult {
	/**
	* The op that combineIfPossible was called on now represents its own work plus that of
	* the passed op. The passed op should be destroyed without being flushed. Currently it
	* is not legal to merge an op passed to combineIfPossible() the passed op is already in a
	* chain (though the op on which combineIfPossible() was called may be).
	*/
	kMerged,
	/**
	* The caller may (but is not required) to chain these ops together. If they are chained
	* then prepare() and execute() will be called on the head op but not the other ops in the
	* chain. The head op will prepare and execute on behalf of all the ops in the chain.
	*/
	kMayChain,
	/**
	* The ops cannot be combined.
	*/
	kCannotCombine
	};

	CombineResult combineIfPossible(GrOp* that, const GrCaps& caps);

	const SkRect& bounds() const {
	SkASSERT(kUninitialized_BoundsFlag != fBoundsFlags);
	return fBounds;
	}

	void setClippedBounds(const SkRect& clippedBounds) {
	fBounds = clippedBounds;
	// The clipped bounds already incorporate any effect of the bounds flags.
	fBoundsFlags = 0;
	}

	bool hasAABloat() const {
	SkASSERT(fBoundsFlags != kUninitialized_BoundsFlag);
	return SkToBool(fBoundsFlags & kAABloat_BoundsFlag);
	}

	bool hasZeroArea() const {
	SkASSERT(fBoundsFlags != kUninitialized_BoundsFlag);
	return SkToBool(fBoundsFlags & kZeroArea_BoundsFlag);
	}

	#ifdef SK_DEBUG
	// All GrOp-derived classes should be allocated in and deleted from a GrMemoryPool
	void* operator new(size_t size);
	void operator delete(void* target);

	void* operator new(size_t size, void* placement) {
	return ::operator new(size, placement);
	}
	void operator delete(void* target, void* placement) {
	::operator delete(target, placement);
	}
	#endif

	/**
	* Helper for safely down-casting to a GrOp subclass
	*/
	template <typename T> const T& cast() const {
	SkASSERT(T::ClassID() == this->classID());
	return static_cast<const T>(this);
	}

	template <typename T> T* cast() {
	SkASSERT(T::ClassID() == this->classID());
	return static_cast<T*>(this);
	}

	uint32_t classID() const { SkASSERT(kIllegalOpID != fClassID); return fClassID; }

	// We lazily initialize the uniqueID because currently the only user is GrAuditTrail
	uint32_t uniqueID() const {
	if (kIllegalOpID == fUniqueID) {
	fUniqueID = GenOpID();
	}
	return fUniqueID;
	}

	/**
	* Called prior to executing. The op should perform any resource creation or data transfers
	* necessary before execute() is called.
	*/
	void prepare(GrOpFlushState* state) { this->onPrepare(state); }

	/** Issues the op's commands to GrGpu. */
	void execute(GrOpFlushState* state, const SkRect& chainBounds) {
	TRACE_EVENT0("skia", name());
	this->onExecute(state, chainBounds);
	}

	/** Used for spewing information about ops when debugging. */
	#ifdef SK_DEBUG
	virtual SkString dumpInfo() const {
	SkString string;
	string.appendf("OpBounds: [L: %.2f, T: %.2f, R: %.2f, B: %.2f]\n",
	fBounds.fLeft, fBounds.fTop, fBounds.fRight, fBounds.fBottom);
	return string;
	}
	#else
	SkString dumpInfo() const { return SkString("<Op information unavailable>"); }
	#endif

	/**
	* A helper for iterating over an op chain in a range for loop that also downcasts to a GrOp
	* subclass. E.g.:
	* for (MyOpSubClass& op : ChainRange<MyOpSubClass>(this)) {
	* // ...
	* }
	*/
	template <typename OpSubclass = GrOp> class ChainRange {
	private:
	class Iter {
	public:
	explicit Iter(const OpSubclass* head) : fCurr(head) {}
	inline Iter& operator++() {
	return this = Iter(static_cast<const OpSubclass>(fCurr->nextInChain()));
	}
	const OpSubclass& operator() const { return fCurr; }
	bool operator!=(const Iter& that) const { return fCurr != that.fCurr; }

	private:
	const OpSubclass* fCurr;
	};
	const OpSubclass* fHead;

	public:
	explicit ChainRange(const OpSubclass* head) : fHead(head) {}
	Iter begin() { return Iter(fHead); }
	Iter end() { return Iter(nullptr); }
	};

	/**
	* Concatenates two op chains. This op must be a tail and the passed op must be a head. The ops
	* must be of the same subclass.
	*/
	void chainConcat(std::unique_ptr<GrOp>);
	/** Returns true if this is the head of a chain (including a length 1 chain). */
	bool isChainHead() const { return !fPrevInChain; }
	/** Returns true if this is the tail of a chain (including a length 1 chain). */
	bool isChainTail() const { return !fNextInChain; }
	/** The next op in the chain. */
	GrOp* nextInChain() const { return fNextInChain.get(); }
	/** The previous op in the chain. */
	GrOp* prevInChain() const { return fPrevInChain; }
	/**
	* Cuts the chain after this op. The returned op is the op that was previously next in the
	* chain or null if this was already a tail.
	*/
	std::unique_ptr<GrOp> cutChain();
	SkDEBUGCODE(void validateChain(GrOp* expectedTail = nullptr) const);

	#ifdef SK_DEBUG
	virtual void validate() const {}
	#endif

	protected:
	GrOp(uint32_t classID);

	/**
	* Indicates that the op will produce geometry that extends beyond its bounds for the
	* purpose of ensuring that the fragment shader runs on partially covered pixels for
	* non-MSAA antialiasing.
	*/
	enum class HasAABloat : bool {
	kNo = false,
	kYes = true
	};
	/**
	* Indicates that the geometry represented by the op has zero area (e.g. it is hairline or
	* points).
	*/
	enum class IsZeroArea : bool {
	kNo = false,
	kYes = true
	};

	void setBounds(const SkRect& newBounds, HasAABloat aabloat, IsZeroArea zeroArea) {
	fBounds = newBounds;
	this->setBoundsFlags(aabloat, zeroArea);
	}
	void setTransformedBounds(const SkRect& srcBounds, const SkMatrix& m,
	HasAABloat aabloat, IsZeroArea zeroArea) {
	m.mapRect(&fBounds, srcBounds);
	this->setBoundsFlags(aabloat, zeroArea);
	}
	void makeFullScreen(GrSurfaceProxy* proxy) {
	this->setBounds(SkRect::MakeIWH(proxy->width(), proxy->height()),
	HasAABloat::kNo, IsZeroArea::kNo);
	}

	static uint32_t GenOpClassID() { return GenID(&gCurrOpClassID); }

	private:
	void joinBounds(const GrOp& that) {
	if (that.hasAABloat()) {
	fBoundsFlags \|= kAABloat_BoundsFlag;
	}
	if (that.hasZeroArea()) {
	fBoundsFlags \|= kZeroArea_BoundsFlag;
	}
	return fBounds.joinPossiblyEmptyRect(that.fBounds);
	}

	virtual CombineResult onCombineIfPossible(GrOp*, const GrCaps&) {
	return CombineResult::kCannotCombine;
	}

	virtual void onPrepare(GrOpFlushState*) = 0;
	// If this op is chained then chainBounds is the union of the bounds of all ops in the chain.
	// Otherwise, this op's bounds.
	virtual void onExecute(GrOpFlushState*, const SkRect& chainBounds) = 0;

	static uint32_t GenID(std::atomic<uint32_t>* idCounter) {
	uint32_t id = (*idCounter)++;
	if (id == 0) {
	SK_ABORT("This should never wrap as it should only be called once for each GrOp "
	"subclass.");
	}
	return id;
	}

	void setBoundsFlags(HasAABloat aabloat, IsZeroArea zeroArea) {
	fBoundsFlags = 0;
	fBoundsFlags \|= (HasAABloat::kYes == aabloat) ? kAABloat_BoundsFlag : 0;
	fBoundsFlags \|= (IsZeroArea ::kYes == zeroArea) ? kZeroArea_BoundsFlag : 0;
	}

	enum {
	kIllegalOpID = 0,
	};

	enum BoundsFlags {
	kAABloat_BoundsFlag = 0x1,
	kZeroArea_BoundsFlag = 0x2,
	SkDEBUGCODE(kUninitialized_BoundsFlag = 0x4)
	};

	std::unique_ptr<GrOp> fNextInChain;
	GrOp* fPrevInChain = nullptr;
	const uint16_t fClassID;
	uint16_t fBoundsFlags;

	static uint32_t GenOpID() { return GenID(&gCurrOpUniqueID); }
	mutable uint32_t fUniqueID = SK_InvalidUniqueID;
	SkRect fBounds;

	static std::atomic<uint32_t> gCurrOpUniqueID;
	static std::atomic<uint32_t> gCurrOpClassID;
	};

	#endif