410 lines
15 KiB
C++
410 lines
15 KiB
C++
/*
|
|
* Copyright 2014 Google Inc.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license that can be
|
|
* found in the LICENSE file.
|
|
*/
|
|
|
|
#ifndef GrXferProcessor_DEFINED
|
|
#define GrXferProcessor_DEFINED
|
|
|
|
#include "GrColor.h"
|
|
#include "GrProcessor.h"
|
|
#include "GrTexture.h"
|
|
#include "GrTypes.h"
|
|
#include "SkXfermode.h"
|
|
|
|
class GrShaderCaps;
|
|
class GrGLSLCaps;
|
|
class GrGLXferProcessor;
|
|
class GrProcOptInfo;
|
|
|
|
/**
|
|
* Equations for alpha-blending.
|
|
*/
|
|
enum GrBlendEquation {
|
|
// Basic blend equations.
|
|
kAdd_GrBlendEquation, //<! Cs*S + Cd*D
|
|
kSubtract_GrBlendEquation, //<! Cs*S - Cd*D
|
|
kReverseSubtract_GrBlendEquation, //<! Cd*D - Cs*S
|
|
|
|
// Advanced blend equations. These are described in the SVG and PDF specs.
|
|
kScreen_GrBlendEquation,
|
|
kOverlay_GrBlendEquation,
|
|
kDarken_GrBlendEquation,
|
|
kLighten_GrBlendEquation,
|
|
kColorDodge_GrBlendEquation,
|
|
kColorBurn_GrBlendEquation,
|
|
kHardLight_GrBlendEquation,
|
|
kSoftLight_GrBlendEquation,
|
|
kDifference_GrBlendEquation,
|
|
kExclusion_GrBlendEquation,
|
|
kMultiply_GrBlendEquation,
|
|
kHSLHue_GrBlendEquation,
|
|
kHSLSaturation_GrBlendEquation,
|
|
kHSLColor_GrBlendEquation,
|
|
kHSLLuminosity_GrBlendEquation,
|
|
|
|
kFirstAdvancedGrBlendEquation = kScreen_GrBlendEquation,
|
|
kLast_GrBlendEquation = kHSLLuminosity_GrBlendEquation
|
|
};
|
|
|
|
static const int kGrBlendEquationCnt = kLast_GrBlendEquation + 1;
|
|
|
|
inline bool GrBlendEquationIsAdvanced(GrBlendEquation equation) {
|
|
return equation >= kFirstAdvancedGrBlendEquation;
|
|
}
|
|
|
|
/**
|
|
* Coeffecients for alpha-blending.
|
|
*/
|
|
enum GrBlendCoeff {
|
|
kZero_GrBlendCoeff, //<! 0
|
|
kOne_GrBlendCoeff, //<! 1
|
|
kSC_GrBlendCoeff, //<! src color
|
|
kISC_GrBlendCoeff, //<! one minus src color
|
|
kDC_GrBlendCoeff, //<! dst color
|
|
kIDC_GrBlendCoeff, //<! one minus dst color
|
|
kSA_GrBlendCoeff, //<! src alpha
|
|
kISA_GrBlendCoeff, //<! one minus src alpha
|
|
kDA_GrBlendCoeff, //<! dst alpha
|
|
kIDA_GrBlendCoeff, //<! one minus dst alpha
|
|
kConstC_GrBlendCoeff, //<! constant color
|
|
kIConstC_GrBlendCoeff, //<! one minus constant color
|
|
kConstA_GrBlendCoeff, //<! constant color alpha
|
|
kIConstA_GrBlendCoeff, //<! one minus constant color alpha
|
|
kS2C_GrBlendCoeff,
|
|
kIS2C_GrBlendCoeff,
|
|
kS2A_GrBlendCoeff,
|
|
kIS2A_GrBlendCoeff,
|
|
|
|
kLast_GrBlendCoeff = kIS2A_GrBlendCoeff
|
|
};
|
|
|
|
static const int kGrBlendCoeffCnt = kLast_GrBlendCoeff + 1;
|
|
|
|
/**
|
|
* Barriers for blending. When a shader reads the dst directly, an Xfer barrier is sometimes
|
|
* required after a pixel has been written, before it can be safely read again.
|
|
*/
|
|
enum GrXferBarrierType {
|
|
kTexture_GrXferBarrierType, //<! Required when a shader reads and renders to the same texture.
|
|
kBlend_GrXferBarrierType, //<! Required by certain blend extensions.
|
|
};
|
|
|
|
/**
|
|
* GrXferProcessor is responsible for implementing the xfer mode that blends the src color and dst
|
|
* color. It does this by emitting fragment shader code and controlling the fixed-function blend
|
|
* state. The inputs to its shader code are the final computed src color and fractional pixel
|
|
* coverage. The GrXferProcessor's shader code writes the fragment shader output color that goes
|
|
* into the fixed-function blend. When dual-source blending is available, it may also write a
|
|
* seconday fragment shader output color. When allowed by the backend API, the GrXferProcessor may
|
|
* read the destination color. The GrXferProcessor is responsible for setting the blend coefficients
|
|
* and blend constant color.
|
|
*
|
|
* A GrXferProcessor is never installed directly into our draw state, but instead is created from a
|
|
* GrXPFactory once we have finalized the state of our draw.
|
|
*/
|
|
class GrXferProcessor : public GrProcessor {
|
|
public:
|
|
/**
|
|
* Sets a unique key on the GrProcessorKeyBuilder calls onGetGLProcessorKey(...) to get the
|
|
* specific subclass's key.
|
|
*/
|
|
void getGLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const;
|
|
|
|
/** Returns a new instance of the appropriate *GL* implementation class
|
|
for the given GrXferProcessor; caller is responsible for deleting
|
|
the object. */
|
|
virtual GrGLXferProcessor* createGLInstance() const = 0;
|
|
|
|
/**
|
|
* Optimizations for blending / coverage that an OptDrawState should apply to itself.
|
|
*/
|
|
enum OptFlags {
|
|
/**
|
|
* No optimizations needed
|
|
*/
|
|
kNone_Opt = 0,
|
|
/**
|
|
* The draw can be skipped completely.
|
|
*/
|
|
kSkipDraw_OptFlag = 0x1,
|
|
/**
|
|
* GrXferProcessor will ignore color, thus no need to provide
|
|
*/
|
|
kIgnoreColor_OptFlag = 0x2,
|
|
/**
|
|
* GrXferProcessor will ignore coverage, thus no need to provide
|
|
*/
|
|
kIgnoreCoverage_OptFlag = 0x4,
|
|
/**
|
|
* Clear color stages and override input color to that returned by getOptimizations
|
|
*/
|
|
kOverrideColor_OptFlag = 0x8,
|
|
/**
|
|
* Set CoverageDrawing_StateBit
|
|
*/
|
|
kSetCoverageDrawing_OptFlag = 0x10,
|
|
/**
|
|
* Can tweak alpha for coverage. Currently this flag should only be used by a batch
|
|
*/
|
|
kCanTweakAlphaForCoverage_OptFlag = 0x20,
|
|
};
|
|
|
|
GR_DECL_BITFIELD_OPS_FRIENDS(OptFlags);
|
|
|
|
/**
|
|
* Determines which optimizations (as described by the ptFlags above) can be performed by
|
|
* the draw with this xfer processor. If this function is called, the xfer processor may change
|
|
* its state to reflected the given blend optimizations. If the XP needs to see a specific input
|
|
* color to blend correctly, it will set the OverrideColor flag and the output parameter
|
|
* overrideColor will be the required value that should be passed into the XP.
|
|
* A caller who calls this function on a XP is required to honor the returned OptFlags
|
|
* and color values for its draw.
|
|
*/
|
|
OptFlags getOptimizations(const GrProcOptInfo& colorPOI,
|
|
const GrProcOptInfo& coveragePOI,
|
|
bool doesStencilWrite,
|
|
GrColor* overrideColor,
|
|
const GrCaps& caps);
|
|
|
|
/**
|
|
* Returns whether this XP will require an Xfer barrier on the given rt. If true, outBarrierType
|
|
* is updated to contain the type of barrier needed.
|
|
*/
|
|
bool willNeedXferBarrier(const GrRenderTarget* rt,
|
|
const GrCaps& caps,
|
|
GrXferBarrierType* outBarrierType) const;
|
|
|
|
struct BlendInfo {
|
|
void reset() {
|
|
fEquation = kAdd_GrBlendEquation;
|
|
fSrcBlend = kOne_GrBlendCoeff;
|
|
fDstBlend = kZero_GrBlendCoeff;
|
|
fBlendConstant = 0;
|
|
fWriteColor = true;
|
|
}
|
|
|
|
SkDEBUGCODE(SkString dump() const;)
|
|
|
|
GrBlendEquation fEquation;
|
|
GrBlendCoeff fSrcBlend;
|
|
GrBlendCoeff fDstBlend;
|
|
GrColor fBlendConstant;
|
|
bool fWriteColor;
|
|
};
|
|
|
|
void getBlendInfo(BlendInfo* blendInfo) const {
|
|
blendInfo->reset();
|
|
this->onGetBlendInfo(blendInfo);
|
|
}
|
|
|
|
bool willReadDstColor() const { return fWillReadDstColor; }
|
|
|
|
/**
|
|
* Returns the texture to be used as the destination when reading the dst in the fragment
|
|
* shader. If the returned texture is NULL then the XP is either not reading the dst or we have
|
|
* extentions that support framebuffer fetching and thus don't need a copy of the dst texture.
|
|
*/
|
|
const GrTexture* getDstCopyTexture() const { return fDstCopy.getTexture(); }
|
|
|
|
/**
|
|
* Returns the offset into the DstCopyTexture to use when reading it in the shader. This value
|
|
* is only valid if getDstCopyTexture() != NULL.
|
|
*/
|
|
const SkIPoint& dstCopyTextureOffset() const {
|
|
SkASSERT(this->getDstCopyTexture());
|
|
return fDstCopyTextureOffset;
|
|
}
|
|
|
|
/**
|
|
* Returns whether or not the XP will look at coverage when doing its blending.
|
|
*/
|
|
bool readsCoverage() const { return fReadsCoverage; }
|
|
|
|
/**
|
|
* Returns whether or not this xferProcossor will set a secondary output to be used with dual
|
|
* source blending.
|
|
*/
|
|
virtual bool hasSecondaryOutput() const { return false; }
|
|
|
|
/** Returns true if this and other processor conservatively draw identically. It can only return
|
|
true when the two processor are of the same subclass (i.e. they return the same object from
|
|
from getFactory()).
|
|
|
|
A return value of true from isEqual() should not be used to test whether the processor would
|
|
generate the same shader code. To test for identical code generation use getGLProcessorKey*/
|
|
|
|
bool isEqual(const GrXferProcessor& that) const {
|
|
if (this->classID() != that.classID()) {
|
|
return false;
|
|
}
|
|
if (this->fWillReadDstColor != that.fWillReadDstColor) {
|
|
return false;
|
|
}
|
|
if (this->fReadsCoverage != that.fReadsCoverage) {
|
|
return false;
|
|
}
|
|
if (this->fDstCopy.getTexture() != that.fDstCopy.getTexture()) {
|
|
return false;
|
|
}
|
|
if (this->fDstCopyTextureOffset != that.fDstCopyTextureOffset) {
|
|
return false;
|
|
}
|
|
return this->onIsEqual(that);
|
|
}
|
|
|
|
protected:
|
|
GrXferProcessor();
|
|
GrXferProcessor(const GrDeviceCoordTexture* dstCopy, bool willReadDstColor);
|
|
|
|
private:
|
|
virtual OptFlags onGetOptimizations(const GrProcOptInfo& colorPOI,
|
|
const GrProcOptInfo& coveragePOI,
|
|
bool doesStencilWrite,
|
|
GrColor* overrideColor,
|
|
const GrCaps& caps) = 0;
|
|
|
|
/**
|
|
* Sets a unique key on the GrProcessorKeyBuilder that is directly associated with this xfer
|
|
* processor's GL backend implementation.
|
|
*/
|
|
virtual void onGetGLProcessorKey(const GrGLSLCaps& caps,
|
|
GrProcessorKeyBuilder* b) const = 0;
|
|
|
|
/**
|
|
* If not using a texture barrier, retrieves whether the subclass will require a different type
|
|
* of barrier.
|
|
*/
|
|
virtual bool onWillNeedXferBarrier(const GrRenderTarget*,
|
|
const GrCaps&,
|
|
GrXferBarrierType* outBarrierType SK_UNUSED) const {
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Retrieves the hardware blend state required by this Xfer processor. The BlendInfo struct
|
|
* comes initialized to default values, so the Xfer processor only needs to set the state it
|
|
* needs. It may not even need to override this method at all.
|
|
*/
|
|
virtual void onGetBlendInfo(BlendInfo*) const {}
|
|
|
|
virtual bool onIsEqual(const GrXferProcessor&) const = 0;
|
|
|
|
bool fWillReadDstColor;
|
|
bool fReadsCoverage;
|
|
SkIPoint fDstCopyTextureOffset;
|
|
GrTextureAccess fDstCopy;
|
|
|
|
typedef GrFragmentProcessor INHERITED;
|
|
};
|
|
|
|
GR_MAKE_BITFIELD_OPS(GrXferProcessor::OptFlags);
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
/**
|
|
* We install a GrXPFactory (XPF) early on in the pipeline before all the final draw information is
|
|
* known (e.g. whether there is fractional pixel coverage, will coverage be 1 or 4 channel, is the
|
|
* draw opaque, etc.). Once the state of the draw is finalized, we use the XPF along with all the
|
|
* draw information to create a GrXferProcessor (XP) which can implement the desired blending for
|
|
* the draw.
|
|
*
|
|
* Before the XP is created, the XPF is able to answer queries about what functionality the XPs it
|
|
* creates will have. For example, can it create an XP that supports RGB coverage or will the XP
|
|
* blend with the destination color.
|
|
*/
|
|
class GrXPFactory : public SkRefCnt {
|
|
public:
|
|
GrXferProcessor* createXferProcessor(const GrProcOptInfo& colorPOI,
|
|
const GrProcOptInfo& coveragePOI,
|
|
const GrDeviceCoordTexture* dstCopy,
|
|
const GrCaps& caps) const;
|
|
|
|
/**
|
|
* This function returns true if the GrXferProcessor generated from this factory will be able to
|
|
* correctly blend when using RGB coverage. The knownColor and knownColorFlags represent the
|
|
* final computed color from the color stages.
|
|
*/
|
|
virtual bool supportsRGBCoverage(GrColor knownColor, uint32_t knownColorFlags) const = 0;
|
|
|
|
struct InvariantOutput {
|
|
bool fWillBlendWithDst;
|
|
GrColor fBlendedColor;
|
|
uint32_t fBlendedColorFlags;
|
|
};
|
|
|
|
/**
|
|
* This function returns known information about the output of the xfer processor produced by
|
|
* this xp factory. The invariant color information returned by this function refers to the
|
|
* final color produced after all blending.
|
|
*/
|
|
virtual void getInvariantOutput(const GrProcOptInfo& colorPOI, const GrProcOptInfo& coveragePOI,
|
|
InvariantOutput*) const = 0;
|
|
|
|
bool willNeedDstCopy(const GrCaps& caps, const GrProcOptInfo& colorPOI,
|
|
const GrProcOptInfo& coveragePOI) const;
|
|
|
|
bool isEqual(const GrXPFactory& that) const {
|
|
if (this->classID() != that.classID()) {
|
|
return false;
|
|
}
|
|
return this->onIsEqual(that);
|
|
}
|
|
|
|
/**
|
|
* Helper for down-casting to a GrXPFactory subclass
|
|
*/
|
|
template <typename T> const T& cast() const { return *static_cast<const T*>(this); }
|
|
|
|
uint32_t classID() const { SkASSERT(kIllegalXPFClassID != fClassID); return fClassID; }
|
|
|
|
protected:
|
|
GrXPFactory() : fClassID(kIllegalXPFClassID) {}
|
|
|
|
template <typename XPF_SUBCLASS> void initClassID() {
|
|
static uint32_t kClassID = GenClassID();
|
|
fClassID = kClassID;
|
|
}
|
|
|
|
uint32_t fClassID;
|
|
|
|
private:
|
|
virtual GrXferProcessor* onCreateXferProcessor(const GrCaps& caps,
|
|
const GrProcOptInfo& colorPOI,
|
|
const GrProcOptInfo& coveragePOI,
|
|
const GrDeviceCoordTexture* dstCopy) const = 0;
|
|
/**
|
|
* Returns true if the XP generated by this factory will explicitly read dst in the fragment
|
|
* shader.
|
|
*/
|
|
virtual bool willReadDstColor(const GrCaps& caps,
|
|
const GrProcOptInfo& colorPOI,
|
|
const GrProcOptInfo& coveragePOI) const = 0;
|
|
|
|
virtual bool onIsEqual(const GrXPFactory&) const = 0;
|
|
|
|
static uint32_t GenClassID() {
|
|
// fCurrXPFactoryID has been initialized to kIllegalXPFactoryID. The
|
|
// atomic inc returns the old value not the incremented value. So we add
|
|
// 1 to the returned value.
|
|
uint32_t id = static_cast<uint32_t>(sk_atomic_inc(&gCurrXPFClassID)) + 1;
|
|
if (!id) {
|
|
SkFAIL("This should never wrap as it should only be called once for each GrXPFactory "
|
|
"subclass.");
|
|
}
|
|
return id;
|
|
}
|
|
|
|
enum {
|
|
kIllegalXPFClassID = 0,
|
|
};
|
|
static int32_t gCurrXPFClassID;
|
|
|
|
typedef GrProgramElement INHERITED;
|
|
};
|
|
|
|
#endif
|
|
|