AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

APIs which took colorPOI / coveragePOI pairs updated to take a GrPipelineOptimizations struct

Browse Source 
TBR=bsalomon@google.com

Review URL: https://codereview.chromium.org/1480353002
This commit is contained in:
ethannicholas 2015-11-30 08:57:38 -08:00 committed by Commit bot
parent e066df9673
commit de4166a3b4
17 changed files with 166 additions and 198 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
include/gpu/GrXferProcessor.h
View File

@ -19,6 +19,7 @@ class GrShaderCaps;
class GrGLSLCaps;
class GrGLSLXferProcessor;
class GrProcOptInfo;
struct GrPipelineOptimizations;
/**
* Barriers for blending. When a shader reads the dst directly, an Xfer barrier is sometimes
@ -141,8 +142,7 @@ public:
* 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,
OptFlags getOptimizations(const GrPipelineOptimizations& optimizations,
bool doesStencilWrite,
GrColor* overrideColor,
const GrCaps& caps);
@ -246,8 +246,7 @@ protected:
private:
void notifyRefCntIsZero() const final {}
virtual OptFlags onGetOptimizations(const GrProcOptInfo& colorPOI,
const GrProcOptInfo& coveragePOI,
virtual OptFlags onGetOptimizations(const GrPipelineOptimizations& optimizations,
bool doesStencilWrite,
GrColor* overrideColor,
const GrCaps& caps) = 0;
@ -311,8 +310,7 @@ GR_MAKE_BITFIELD_OPS(GrXferProcessor::OptFlags);
class GrXPFactory : public SkRefCnt {
public:
typedef GrXferProcessor::DstTexture DstTexture;
GrXferProcessor* createXferProcessor(const GrProcOptInfo& colorPOI,
const GrProcOptInfo& coveragePOI,
GrXferProcessor* createXferProcessor(const GrPipelineOptimizations& optimizations,
bool hasMixedSamples,
const DstTexture*,
const GrCaps& caps) const;
@ -334,8 +332,8 @@ public:
virtual void getInvariantBlendedColor(const GrProcOptInfo& colorPOI,
InvariantBlendedColor*) const = 0;
bool willNeedDstTexture(const GrCaps& caps, const GrProcOptInfo& colorPOI,
const GrProcOptInfo& coveragePOI, bool hasMixedSamples) const;
bool willNeedDstTexture(const GrCaps& caps, const GrPipelineOptimizations& optimizations,
bool hasMixedSamples) const;
bool isEqual(const GrXPFactory& that) const {
if (this->classID() != that.classID()) {
@ -363,8 +361,7 @@ protected:
private:
virtual GrXferProcessor* onCreateXferProcessor(const GrCaps& caps,
const GrProcOptInfo& colorPOI,
const GrProcOptInfo& coveragePOI,
const GrPipelineOptimizations& optimizations,
bool hasMixedSamples,
const DstTexture*) const = 0;
/**
@ -372,8 +369,7 @@ private:
* shader.
*/
virtual bool willReadDstColor(const GrCaps& caps,
const GrProcOptInfo& colorPOI,
const GrProcOptInfo& coveragePOI,
const GrPipelineOptimizations& optimizations,
bool hasMixedSamples) const = 0;
virtual bool onIsEqual(const GrXPFactory&) const = 0;

6
include/gpu/effects/GrCoverageSetOpXP.h
View File

@ -30,14 +30,12 @@ private:
GrCoverageSetOpXPFactory(SkRegion::Op regionOp, bool invertCoverage);
GrXferProcessor* onCreateXferProcessor(const GrCaps& caps,
const GrProcOptInfo& colorPOI,
const GrProcOptInfo& coveragePOI,
const GrPipelineOptimizations& optimizations,
bool hasMixedSamples,
const DstTexture*) const override;
bool willReadDstColor(const GrCaps& /*caps*/,
const GrProcOptInfo& /*colorPOI*/,
const GrProcOptInfo& /*coveragePOI*/,
const GrPipelineOptimizations& /*optimizations*/,
bool /*hasMixedSamples*/) const override {
return false;
}

12
include/gpu/effects/GrPorterDuffXferProcessor.h
View File

@ -22,8 +22,7 @@ public:
GrXPFactory::InvariantBlendedColor*) const override;
static GrXferProcessor* CreateSrcOverXferProcessor(const GrCaps& caps,
const GrProcOptInfo& colorPOI,
const GrProcOptInfo& coveragePOI,
const GrPipelineOptimizations& optimizations,
bool hasMixedSamples,
const GrXferProcessor::DstTexture*);
@ -44,22 +43,19 @@ public:
}
static bool SrcOverWillNeedDstTexture(const GrCaps& caps,
const GrProcOptInfo& colorPOI,
const GrProcOptInfo& coveragePOI,
const GrPipelineOptimizations& optimizations,
bool hasMixedSamples);
private:
GrPorterDuffXPFactory(SkXfermode::Mode);
GrXferProcessor* onCreateXferProcessor(const GrCaps& caps,
const GrProcOptInfo& colorPOI,
const GrProcOptInfo& coveragePOI,
const GrPipelineOptimizations& optimizations,
bool hasMixedSamples,
const DstTexture*) const override;
bool willReadDstColor(const GrCaps& caps,
const GrProcOptInfo& colorPOI,
const GrProcOptInfo& coveragePOI,
const GrPipelineOptimizations& optimizations,
bool hasMixedSamples) const override;
bool onIsEqual(const GrXPFactory& xpfBase) const override {

16
src/effects/SkArithmeticMode_gpu.cpp
View File

@ -167,8 +167,7 @@ public:
bool enforcePMColor() const { return fEnforcePMColor; }
private:
GrXferProcessor::OptFlags onGetOptimizations(const GrProcOptInfo& colorPOI,
const GrProcOptInfo& coveragePOI,
GrXferProcessor::OptFlags onGetOptimizations(const GrPipelineOptimizations& optimizations,
bool doesStencilWrite,
GrColor* overrideColor,
const GrCaps& caps) override;
@ -257,11 +256,11 @@ void ArithmeticXP::onGetGLSLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyB
GrGLSLXferProcessor* ArithmeticXP::createGLSLInstance() const { return new GLArithmeticXP(*this); }
GrXferProcessor::OptFlags ArithmeticXP::onGetOptimizations(const GrProcOptInfo& colorPOI,
const GrProcOptInfo& coveragePOI,
bool doesStencilWrite,
GrColor* overrideColor,
const GrCaps& caps) {
GrXferProcessor::OptFlags ArithmeticXP::onGetOptimizations(
const GrPipelineOptimizations& optimizations,
bool doesStencilWrite,
GrColor* overrideColor,
const GrCaps& caps) {
return GrXferProcessor::kNone_OptFlags;
}
@ -275,8 +274,7 @@ GrArithmeticXPFactory::GrArithmeticXPFactory(float k1, float k2, float k3, float
GrXferProcessor*
GrArithmeticXPFactory::onCreateXferProcessor(const GrCaps& caps,
const GrProcOptInfo& colorPOI,
const GrProcOptInfo& coveragePOI,
const GrPipelineOptimizations& optimizations,
bool hasMixedSamples,
const DstTexture* dstTexture) const {
return new ArithmeticXP(dstTexture, hasMixedSamples, fK1, fK2, fK3, fK4, fEnforcePMColor);

6
src/effects/SkArithmeticMode_gpu.h
View File

@ -88,14 +88,12 @@ private:
GrArithmeticXPFactory(float k1, float k2, float k3, float k4, bool enforcePMColor);
GrXferProcessor* onCreateXferProcessor(const GrCaps& caps,
const GrProcOptInfo& colorPOI,
const GrProcOptInfo& coveragePOI,
const GrPipelineOptimizations& optimizations,
bool hasMixedSamples,
const DstTexture*) const override;
bool willReadDstColor(const GrCaps& caps,
const GrProcOptInfo& colorPOI,
const GrProcOptInfo& coveragePOI,
const GrPipelineOptimizations& optimizations,
bool hasMixedSamples) const override {
return true;
}

8
src/gpu/GrDrawTarget.cpp
View File

@ -113,14 +113,13 @@ void GrDrawTarget::dump() const {
#endif
bool GrDrawTarget::setupDstReadIfNecessary(const GrPipelineBuilder& pipelineBuilder,
const GrProcOptInfo& colorPOI,
const GrProcOptInfo& coveragePOI,
const GrPipelineOptimizations& optimizations,
GrXferProcessor::DstTexture* dstTexture,
const SkRect& batchBounds) {
SkRect bounds = batchBounds;
bounds.outset(0.5f, 0.5f);
if (!pipelineBuilder.willXPNeedDstTexture(*this->caps(), colorPOI, coveragePOI)) {
if (!pipelineBuilder.willXPNeedDstTexture(*this->caps(), optimizations)) {
return true;
}
@ -545,8 +544,7 @@ bool GrDrawTarget::installPipelineInDrawBatch(const GrPipelineBuilder* pipelineB
args.fOpts.fCoveragePOI.completeCalculations(
pipelineBuilder->fCoverageFragmentProcessors.begin(),
pipelineBuilder->numCoverageFragmentProcessors());
if (!this->setupDstReadIfNecessary(*pipelineBuilder, args.fOpts.fColorPOI,
args.fOpts.fCoveragePOI, &args.fDstTexture,
if (!this->setupDstReadIfNecessary(*pipelineBuilder, args.fOpts, &args.fDstTexture,
batch->bounds())) {
return false;
}

3
src/gpu/GrDrawTarget.h
View File

@ -279,8 +279,7 @@ private:
// 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&,
const GrProcOptInfo& colorPOI,
const GrProcOptInfo& coveragePOI,
const GrPipelineOptimizations& optimizations,
GrXferProcessor::DstTexture*,
const SkRect& batchBounds);

9
src/gpu/GrPipeline.cpp
View File

@ -24,16 +24,14 @@ GrPipeline* GrPipeline::CreateAt(void* memory, const CreateArgs& args,
const GrXPFactory* xpFactory = builder.getXPFactory();
SkAutoTUnref<GrXferProcessor> xferProcessor;
if (xpFactory) {
xferProcessor.reset(xpFactory->createXferProcessor(args.fOpts.fColorPOI,
args.fOpts.fCoveragePOI,
xferProcessor.reset(xpFactory->createXferProcessor(args.fOpts,
builder.hasMixedSamples(),
&args.fDstTexture,
*args.fCaps));
} else {
xferProcessor.reset(GrPorterDuffXPFactory::CreateSrcOverXferProcessor(
*args.fCaps,
args.fOpts.fColorPOI,
args.fOpts.fCoveragePOI,
args.fOpts,
builder.hasMixedSamples(),
&args.fDstTexture));
}
@ -49,8 +47,7 @@ GrPipeline* GrPipeline::CreateAt(void* memory, const CreateArgs& args,
GrXferProcessor::OptFlags optFlags = GrXferProcessor::kNone_OptFlags;
optFlags = xferProcessor->getOptimizations(args.fOpts.fColorPOI,
args.fOpts.fCoveragePOI,
optFlags = xferProcessor->getOptimizations(args.fOpts,
builder.getStencil().doesWrite(),
&overrideColor,
*args.fCaps);

7
src/gpu/GrPipelineBuilder.cpp
View File

@ -49,13 +49,12 @@ GrPipelineBuilder::GrPipelineBuilder(const GrPaint& paint, GrRenderTarget* rt, c
//////////////////////////////////////////////////////////////////////////////s
bool GrPipelineBuilder::willXPNeedDstTexture(const GrCaps& caps,
const GrProcOptInfo& colorPOI,
const GrProcOptInfo& coveragePOI) const {
const GrPipelineOptimizations& optimizations) const {
if (this->getXPFactory()) {
return this->getXPFactory()->willNeedDstTexture(caps, colorPOI, coveragePOI,
return this->getXPFactory()->willNeedDstTexture(caps, optimizations,
this->hasMixedSamples());
}
return GrPorterDuffXPFactory::SrcOverWillNeedDstTexture(caps, colorPOI, coveragePOI,
return GrPorterDuffXPFactory::SrcOverWillNeedDstTexture(caps, optimizations,
this->hasMixedSamples());
}

4
src/gpu/GrPipelineBuilder.h
View File

@ -177,8 +177,8 @@ public:
/**
* Checks whether the xp will need destination in a texture to correctly blend.
*/
bool willXPNeedDstTexture(const GrCaps& caps, const GrProcOptInfo& colorPOI,
const GrProcOptInfo& coveragePOI) const;
bool willXPNeedDstTexture(const GrCaps& caps,
const GrPipelineOptimizations& optimizations) const;
/// @}

28
src/gpu/GrXferProcessor.cpp
View File

@ -6,6 +6,7 @@
*/
#include "GrXferProcessor.h"
#include "GrPipeline.h"
#include "GrPipelineBuilder.h"
#include "GrProcOptInfo.h"
#include "gl/GrGLCaps.h"
@ -33,13 +34,12 @@ GrXferProcessor::GrXferProcessor(const DstTexture* dstTexture,
}
}
GrXferProcessor::OptFlags GrXferProcessor::getOptimizations(const GrProcOptInfo& colorPOI,
const GrProcOptInfo& coveragePOI,
bool doesStencilWrite,
GrColor* overrideColor,
const GrCaps& caps) {
GrXferProcessor::OptFlags flags = this->onGetOptimizations(colorPOI,
coveragePOI,
GrXferProcessor::OptFlags GrXferProcessor::getOptimizations(
const GrPipelineOptimizations& optimizations,
bool doesStencilWrite,
GrColor* overrideColor,
const GrCaps& caps) {
GrXferProcessor::OptFlags flags = this->onGetOptimizations(optimizations,
doesStencilWrite,
overrideColor,
caps);
@ -47,7 +47,7 @@ GrXferProcessor::OptFlags GrXferProcessor::getOptimizations(const GrProcOptInfo&
if (this->willReadDstColor()) {
// When performing a dst read we handle coverage in the base class.
SkASSERT(!(flags & GrXferProcessor::kIgnoreCoverage_OptFlag));
if (coveragePOI.isSolidWhite()) {
if (optimizations.fCoveragePOI.isSolidWhite()) {
flags |= GrXferProcessor::kIgnoreCoverage_OptFlag;
}
}
@ -200,13 +200,12 @@ SkString GrXferProcessor::BlendInfo::dump() const {
///////////////////////////////////////////////////////////////////////////////
GrXferProcessor* GrXPFactory::createXferProcessor(const GrProcOptInfo& colorPOI,
const GrProcOptInfo& coveragePOI,
GrXferProcessor* GrXPFactory::createXferProcessor(const GrPipelineOptimizations& optimizations,
bool hasMixedSamples,
const DstTexture* dstTexture,
const GrCaps& caps) const {
#ifdef SK_DEBUG
if (this->willReadDstColor(caps, colorPOI, coveragePOI, hasMixedSamples)) {
if (this->willReadDstColor(caps, optimizations, hasMixedSamples)) {
if (!caps.shaderCaps()->dstReadInShaderSupport()) {
SkASSERT(dstTexture && dstTexture->texture());
} else {
@ -217,13 +216,12 @@ GrXferProcessor* GrXPFactory::createXferProcessor(const GrProcOptInfo& colorPOI,
}
SkASSERT(!hasMixedSamples || caps.shaderCaps()->dualSourceBlendingSupport());
#endif
return this->onCreateXferProcessor(caps, colorPOI, coveragePOI, hasMixedSamples, dstTexture);
return this->onCreateXferProcessor(caps, optimizations, hasMixedSamples, dstTexture);
}
bool GrXPFactory::willNeedDstTexture(const GrCaps& caps,
const GrProcOptInfo& colorPOI,
const GrProcOptInfo& coveragePOI,
const GrPipelineOptimizations& optimizations,
bool hasMixedSamples) const {
return (this->willReadDstColor(caps, colorPOI, coveragePOI, hasMixedSamples) &&
return (this->willReadDstColor(caps, optimizations, hasMixedSamples) &&
!caps.shaderCaps()->dstReadInShaderSupport());
}

9
src/gpu/effects/GrCoverageSetOpXP.cpp
View File

@ -32,8 +32,7 @@ public:
private:
CoverageSetOpXP(SkRegion::Op regionOp, bool fInvertCoverage);
GrXferProcessor::OptFlags onGetOptimizations(const GrProcOptInfo& colorPOI,
const GrProcOptInfo& coveragePOI,
GrXferProcessor::OptFlags onGetOptimizations(const GrPipelineOptimizations& optimizations,
bool doesStencilWrite,
GrColor* color,
const GrCaps& caps) override;
@ -107,8 +106,7 @@ GrGLSLXferProcessor* CoverageSetOpXP::createGLSLInstance() const {
}
GrXferProcessor::OptFlags
CoverageSetOpXP::onGetOptimizations(const GrProcOptInfo& colorPOI,
const GrProcOptInfo& coveragePOI,
CoverageSetOpXP::onGetOptimizations(const GrPipelineOptimizations& optimizations,
bool doesStencilWrite,
GrColor* color,
const GrCaps& caps) {
@ -223,8 +221,7 @@ GrXPFactory* GrCoverageSetOpXPFactory::Create(SkRegion::Op regionOp, bool invert
GrXferProcessor*
GrCoverageSetOpXPFactory::onCreateXferProcessor(const GrCaps& caps,
const GrProcOptInfo& colorPOI,
const GrProcOptInfo& covPOI,
const GrPipelineOptimizations& optimizations,
bool hasMixedSamples,
const DstTexture* dst) const {
// We don't support inverting coverage with mixed samples. We don't expect to ever want this in

27
src/gpu/effects/GrCustomXfermode.cpp
View File

@ -11,6 +11,7 @@
#include "GrContext.h"
#include "GrFragmentProcessor.h"
#include "GrInvariantOutput.h"
#include "GrPipeline.h"
#include "GrProcessor.h"
#include "GrTexture.h"
#include "GrTextureAccess.h"
@ -99,8 +100,7 @@ public:
}
private:
GrXferProcessor::OptFlags onGetOptimizations(const GrProcOptInfo& colorPOI,
const GrProcOptInfo& coveragePOI,
GrXferProcessor::OptFlags onGetOptimizations(const GrPipelineOptimizations& optimizations,
bool doesStencilWrite,
GrColor* overrideColor,
const GrCaps& caps) override;
@ -192,8 +192,7 @@ bool CustomXP::onIsEqual(const GrXferProcessor& other) const {
return fMode == s.fMode && fHWBlendEquation == s.fHWBlendEquation;
}
GrXferProcessor::OptFlags CustomXP::onGetOptimizations(const GrProcOptInfo& colorPOI,
const GrProcOptInfo& coveragePOI,
GrXferProcessor::OptFlags CustomXP::onGetOptimizations(const GrPipelineOptimizations& optimizations,
bool doesStencilWrite,
GrColor* overrideColor,
const GrCaps& caps) {
@ -294,10 +293,10 @@ GrXferProcessor::OptFlags CustomXP::onGetOptimizations(const GrProcOptInfo& colo
*/
OptFlags flags = kNone_OptFlags;
if (colorPOI.allStagesMultiplyInput()) {
if (optimizations.fColorPOI.allStagesMultiplyInput()) {
flags |= kCanTweakAlphaForCoverage_OptFlag;
}
if (this->hasHWBlendEquation() && coveragePOI.isSolidWhite()) {
if (this->hasHWBlendEquation() && optimizations.fCoveragePOI.isSolidWhite()) {
flags |= kIgnoreCoverage_OptFlag;
}
return flags;
@ -326,14 +325,12 @@ public:
private:
GrXferProcessor* onCreateXferProcessor(const GrCaps& caps,
const GrProcOptInfo& colorPOI,
const GrProcOptInfo& coveragePOI,
const GrPipelineOptimizations& optimizations,
bool hasMixedSamples,
const DstTexture*) const override;
bool willReadDstColor(const GrCaps& caps,
const GrProcOptInfo& colorPOI,
const GrProcOptInfo& coveragePOI,
const GrPipelineOptimizations& optimizations,
bool hasMixedSamples) const override;
bool onIsEqual(const GrXPFactory& xpfBase) const override {
@ -357,11 +354,10 @@ CustomXPFactory::CustomXPFactory(SkXfermode::Mode mode)
}
GrXferProcessor* CustomXPFactory::onCreateXferProcessor(const GrCaps& caps,
const GrProcOptInfo& colorPOI,
const GrProcOptInfo& coveragePOI,
const GrPipelineOptimizations& opt,
bool hasMixedSamples,
const DstTexture* dstTexture) const {
if (can_use_hw_blend_equation(fHWBlendEquation, coveragePOI, caps)) {
if (can_use_hw_blend_equation(fHWBlendEquation, opt.fCoveragePOI, caps)) {
SkASSERT(!dstTexture || !dstTexture->texture());
return new CustomXP(fMode, fHWBlendEquation);
}
@ -369,10 +365,9 @@ GrXferProcessor* CustomXPFactory::onCreateXferProcessor(const GrCaps& caps,
}
bool CustomXPFactory::willReadDstColor(const GrCaps& caps,
const GrProcOptInfo& colorPOI,
const GrProcOptInfo& coveragePOI,
const GrPipelineOptimizations& optimizations,
bool hasMixedSamples) const {
return !can_use_hw_blend_equation(fHWBlendEquation, coveragePOI, caps);
return !can_use_hw_blend_equation(fHWBlendEquation, optimizations.fCoveragePOI, caps);
}
void CustomXPFactory::getInvariantBlendedColor(const GrProcOptInfo& colorPOI,

6
src/gpu/effects/GrDisableColorXP.cpp
View File

@ -29,8 +29,7 @@ public:
private:
DisableColorXP();
GrXferProcessor::OptFlags onGetOptimizations(const GrProcOptInfo& colorPOI,
const GrProcOptInfo& coveragePOI,
GrXferProcessor::OptFlags onGetOptimizations(const GrPipelineOptimizations& optimizations,
bool doesStencilWrite,
GrColor* color,
const GrCaps& caps) override {
@ -96,8 +95,7 @@ GrDisableColorXPFactory::GrDisableColorXPFactory() {
GrXferProcessor*
GrDisableColorXPFactory::onCreateXferProcessor(const GrCaps& caps,
const GrProcOptInfo& colorPOI,
const GrProcOptInfo& covPOI,
const GrPipelineOptimizations& optimizations,
bool hasMixedSamples,
const DstTexture* dst) const {
return DisableColorXP::Create();

6
src/gpu/effects/GrDisableColorXP.h
View File

@ -27,14 +27,12 @@ private:
GrDisableColorXPFactory();
GrXferProcessor* onCreateXferProcessor(const GrCaps& caps,
const GrProcOptInfo& colorPOI,
const GrProcOptInfo& coveragePOI,
const GrPipelineOptimizations& optimizations,
bool hasMixedSamples,
const DstTexture* dstTexture) const override;
bool willReadDstColor(const GrCaps& caps,
const GrProcOptInfo& colorPOI,
const GrProcOptInfo& coveragePOI,
const GrPipelineOptimizations& optimizations,
bool hasMixedSamples) const override {
return false;
}

76
src/gpu/effects/GrPorterDuffXferProcessor.cpp
View File

@ -9,6 +9,7 @@
#include "GrBlend.h"
#include "GrCaps.h"
#include "GrPipeline.h"
#include "GrProcessor.h"
#include "GrProcOptInfo.h"
#include "GrTypes.h"
@ -352,8 +353,7 @@ public:
BlendFormula getBlendFormula() const { return fBlendFormula; }
private:
GrXferProcessor::OptFlags onGetOptimizations(const GrProcOptInfo& colorPOI,
const GrProcOptInfo& coveragePOI,
GrXferProcessor::OptFlags onGetOptimizations(const GrPipelineOptimizations& optimizations,
bool doesStencilWrite,
GrColor* overrideColor,
const GrCaps& caps) override;
@ -469,8 +469,7 @@ GrGLSLXferProcessor* PorterDuffXferProcessor::createGLSLInstance() const {
}
GrXferProcessor::OptFlags
PorterDuffXferProcessor::onGetOptimizations(const GrProcOptInfo& colorPOI,
const GrProcOptInfo& coveragePOI,
PorterDuffXferProcessor::onGetOptimizations(const GrPipelineOptimizations& optimizations,
bool doesStencilWrite,
GrColor* overrideColor,
const GrCaps& caps) {
@ -486,12 +485,12 @@ PorterDuffXferProcessor::onGetOptimizations(const GrProcOptInfo& colorPOI,
if (!fBlendFormula.usesInputColor()) {
optFlags |= GrXferProcessor::kIgnoreColor_OptFlag;
}
if (coveragePOI.isSolidWhite()) {
if (optimizations.fCoveragePOI.isSolidWhite()) {
optFlags |= GrXferProcessor::kIgnoreCoverage_OptFlag;
}
if (colorPOI.allStagesMultiplyInput() &&
if (optimizations.fColorPOI.allStagesMultiplyInput() &&
fBlendFormula.canTweakAlphaForCoverage() &&
!coveragePOI.isFourChannelOutput()) {
!optimizations.fCoveragePOI.isFourChannelOutput()) {
optFlags |= GrXferProcessor::kCanTweakAlphaForCoverage_OptFlag;
}
}
@ -517,8 +516,8 @@ public:
SkXfermode::Mode getXfermode() const { return fXfermode; }
private:
GrXferProcessor::OptFlags onGetOptimizations(const GrProcOptInfo&, const GrProcOptInfo&,
bool, GrColor*, const GrCaps&) override {
GrXferProcessor::OptFlags onGetOptimizations(const GrPipelineOptimizations&, bool, GrColor*,
const GrCaps&) override {
return kNone_OptFlags;
}
@ -586,8 +585,7 @@ public:
private:
PDLCDXferProcessor(GrColor blendConstant, uint8_t alpha);
GrXferProcessor::OptFlags onGetOptimizations(const GrProcOptInfo& colorPOI,
const GrProcOptInfo& coveragePOI,
GrXferProcessor::OptFlags onGetOptimizations(const GrPipelineOptimizations& optimizations,
bool doesStencilWrite,
GrColor* overrideColor,
const GrCaps& caps) override;
@ -676,8 +674,7 @@ GrGLSLXferProcessor* PDLCDXferProcessor::createGLSLInstance() const {
}
GrXferProcessor::OptFlags
PDLCDXferProcessor::onGetOptimizations(const GrProcOptInfo& colorPOI,
const GrProcOptInfo& coveragePOI,
PDLCDXferProcessor::onGetOptimizations(const GrPipelineOptimizations& optimizations,
bool doesStencilWrite,
GrColor* overrideColor,
const GrCaps& caps) {
@ -729,24 +726,24 @@ GrXPFactory* GrPorterDuffXPFactory::Create(SkXfermode::Mode xfermode) {
GrXferProcessor*
GrPorterDuffXPFactory::onCreateXferProcessor(const GrCaps& caps,
const GrProcOptInfo& colorPOI,
const GrProcOptInfo& covPOI,
const GrPipelineOptimizations& optimizations,
bool hasMixedSamples,
const DstTexture* dstTexture) const {
BlendFormula blendFormula;
if (covPOI.isFourChannelOutput()) {
if (optimizations.fCoveragePOI.isFourChannelOutput()) {
if (SkXfermode::kSrcOver_Mode == fXfermode &&
kRGBA_GrColorComponentFlags == colorPOI.validFlags() &&
kRGBA_GrColorComponentFlags == optimizations.fColorPOI.validFlags() &&
!caps.shaderCaps()->dualSourceBlendingSupport() &&
!caps.shaderCaps()->dstReadInShaderSupport()) {
// If we don't have dual source blending or in shader dst reads, we fall back to this
// trick for rendering SrcOver LCD text instead of doing a dst copy.
SkASSERT(!dstTexture || !dstTexture->texture());
return PDLCDXferProcessor::Create(fXfermode, colorPOI);
return PDLCDXferProcessor::Create(fXfermode, optimizations.fColorPOI);
}
blendFormula = get_lcd_blend_formula(covPOI, fXfermode);
blendFormula = get_lcd_blend_formula(optimizations.fCoveragePOI, fXfermode);
} else {
blendFormula = get_blend_formula(colorPOI, covPOI, hasMixedSamples, fXfermode);
blendFormula = get_blend_formula(optimizations.fColorPOI, optimizations.fCoveragePOI,
hasMixedSamples, fXfermode);
}
if (blendFormula.hasSecondaryOutput() && !caps.shaderCaps()->dualSourceBlendingSupport()) {
@ -789,8 +786,7 @@ void GrPorterDuffXPFactory::getInvariantBlendedColor(const GrProcOptInfo& colorP
}
bool GrPorterDuffXPFactory::willReadDstColor(const GrCaps& caps,
const GrProcOptInfo& colorPOI,
const GrProcOptInfo& covPOI,
const GrPipelineOptimizations& optimizations,
bool hasMixedSamples) const {
if (caps.shaderCaps()->dualSourceBlendingSupport()) {
return false;
@ -799,17 +795,18 @@ bool GrPorterDuffXPFactory::willReadDstColor(const GrCaps& caps,
// When we have four channel coverage we always need to read the dst in order to correctly
// blend. The one exception is when we are using srcover mode and we know the input color into
// the XP.
if (covPOI.isFourChannelOutput()) {
if (optimizations.fCoveragePOI.isFourChannelOutput()) {
if (SkXfermode::kSrcOver_Mode == fXfermode &&
kRGBA_GrColorComponentFlags == colorPOI.validFlags() &&
kRGBA_GrColorComponentFlags == optimizations.fColorPOI.validFlags() &&
!caps.shaderCaps()->dstReadInShaderSupport()) {
return false;
}
return get_lcd_blend_formula(covPOI, fXfermode).hasSecondaryOutput();
return get_lcd_blend_formula(optimizations.fCoveragePOI, fXfermode).hasSecondaryOutput();
}
// We fallback on the shader XP when the blend formula would use dual source blending but we
// don't have support for it.
return get_blend_formula(colorPOI, covPOI, hasMixedSamples, fXfermode).hasSecondaryOutput();
return get_blend_formula(optimizations.fColorPOI, optimizations.fCoveragePOI, hasMixedSamples,
fXfermode).hasSecondaryOutput();
}
GR_DEFINE_XP_FACTORY_TEST(GrPorterDuffXPFactory);
@ -838,25 +835,24 @@ void GrPorterDuffXPFactory::TestGetXPOutputTypes(const GrXferProcessor* xp,
GrXferProcessor* GrPorterDuffXPFactory::CreateSrcOverXferProcessor(
const GrCaps& caps,
const GrProcOptInfo& colorPOI,
const GrProcOptInfo& covPOI,
const GrPipelineOptimizations& optimizations,
bool hasMixedSamples,
const GrXferProcessor::DstTexture* dstTexture) {
BlendFormula blendFormula;
if (covPOI.isFourChannelOutput()) {
if (kRGBA_GrColorComponentFlags == colorPOI.validFlags() &&
if (optimizations.fCoveragePOI.isFourChannelOutput()) {
if (kRGBA_GrColorComponentFlags == optimizations.fColorPOI.validFlags() &&
!caps.shaderCaps()->dualSourceBlendingSupport() &&
!caps.shaderCaps()->dstReadInShaderSupport()) {
// If we don't have dual source blending or in shader dst reads, we fall
// back to this trick for rendering SrcOver LCD text instead of doing a
// dst copy.
SkASSERT(!dstTexture || !dstTexture->texture());
return PDLCDXferProcessor::Create(SkXfermode::kSrcOver_Mode, colorPOI);
return PDLCDXferProcessor::Create(SkXfermode::kSrcOver_Mode, optimizations.fColorPOI);
}
blendFormula = get_lcd_blend_formula(covPOI, SkXfermode::kSrcOver_Mode);
blendFormula = get_lcd_blend_formula(optimizations.fCoveragePOI, SkXfermode::kSrcOver_Mode);
} else {
blendFormula = get_blend_formula(colorPOI, covPOI, hasMixedSamples,
SkXfermode::kSrcOver_Mode);
blendFormula = get_blend_formula(optimizations.fColorPOI, optimizations.fCoveragePOI,
hasMixedSamples, SkXfermode::kSrcOver_Mode);
}
if (blendFormula.hasSecondaryOutput() && !caps.shaderCaps()->dualSourceBlendingSupport()) {
@ -868,8 +864,7 @@ GrXferProcessor* GrPorterDuffXPFactory::CreateSrcOverXferProcessor(
}
bool GrPorterDuffXPFactory::SrcOverWillNeedDstTexture(const GrCaps& caps,
const GrProcOptInfo& colorPOI,
const GrProcOptInfo& covPOI,
const GrPipelineOptimizations& optimizations,
bool hasMixedSamples) {
if (caps.shaderCaps()->dstReadInShaderSupport() ||
caps.shaderCaps()->dualSourceBlendingSupport()) {
@ -879,16 +874,17 @@ bool GrPorterDuffXPFactory::SrcOverWillNeedDstTexture(const GrCaps& caps,
// When we have four channel coverage we always need to read the dst in order to correctly
// blend. The one exception is when we are using srcover mode and we know the input color
// into the XP.
if (covPOI.isFourChannelOutput()) {
if (kRGBA_GrColorComponentFlags == colorPOI.validFlags() &&
if (optimizations.fCoveragePOI.isFourChannelOutput()) {
if (kRGBA_GrColorComponentFlags == optimizations.fColorPOI.validFlags() &&
!caps.shaderCaps()->dstReadInShaderSupport()) {
return false;
}
return get_lcd_blend_formula(covPOI, SkXfermode::kSrcOver_Mode).hasSecondaryOutput();
return get_lcd_blend_formula(optimizations.fCoveragePOI,
SkXfermode::kSrcOver_Mode).hasSecondaryOutput();
}
// We fallback on the shader XP when the blend formula would use dual source blending but we
// don't have support for it.
return get_blend_formula(colorPOI, covPOI,
return get_blend_formula(optimizations.fColorPOI, optimizations.fCoveragePOI,
hasMixedSamples, SkXfermode::kSrcOver_Mode).hasSecondaryOutput();
}

121
tests/GrPorterDuffTest.cpp
View File

@ -76,13 +76,13 @@ class GrPorterDuffTest {
public:
struct XPInfo {
XPInfo(skiatest::Reporter* reporter, SkXfermode::Mode xfermode, const GrCaps& caps,
const GrProcOptInfo& colorPOI, const GrProcOptInfo& covPOI) {
const GrPipelineOptimizations& optimizations) {
SkAutoTUnref<GrXPFactory> xpf(GrPorterDuffXPFactory::Create(xfermode));
SkAutoTUnref<GrXferProcessor> xp(
xpf->createXferProcessor(colorPOI, covPOI, false, nullptr, caps));
TEST_ASSERT(!xpf->willNeedDstTexture(caps, colorPOI, covPOI, false));
xpf->getInvariantBlendedColor(colorPOI, &fBlendedColor);
fOptFlags = xp->getOptimizations(colorPOI, covPOI, false, nullptr, caps);
xpf->createXferProcessor(optimizations, false, nullptr, caps));
TEST_ASSERT(!xpf->willNeedDstTexture(caps, optimizations, false));
xpf->getInvariantBlendedColor(optimizations.fColorPOI, &fBlendedColor);
fOptFlags = xp->getOptimizations(optimizations, false, nullptr, caps);
GetXPOutputTypes(xp, &fPrimaryOutputType, &fSecondaryOutputType);
xp->getBlendInfo(&fBlendInfo);
TEST_ASSERT(!xp->willReadDstColor());
@ -102,19 +102,19 @@ public:
};
static void test_lcd_coverage(skiatest::Reporter* reporter, const GrCaps& caps) {
GrProcOptInfo colorPOI, covPOI;
colorPOI.calcWithInitialValues(NULL, 0, 0, kNone_GrColorComponentFlags, false);
GrPipelineOptimizations opt;
opt.fColorPOI.calcWithInitialValues(NULL, 0, 0, kNone_GrColorComponentFlags, false);
// Setting 2nd to last value to false and last to true will force covPOI to LCD coverage.
covPOI.calcWithInitialValues(NULL, 0, 0, kNone_GrColorComponentFlags, false, true);
opt.fCoveragePOI.calcWithInitialValues(NULL, 0, 0, kNone_GrColorComponentFlags, false, true);
SkASSERT(!colorPOI.isOpaque());
SkASSERT(!colorPOI.isSolidWhite());
SkASSERT(!covPOI.isSolidWhite());
SkASSERT(covPOI.isFourChannelOutput());
SkASSERT(!opt.fColorPOI.isOpaque());
SkASSERT(!opt.fColorPOI.isSolidWhite());
SkASSERT(!opt.fCoveragePOI.isSolidWhite());
SkASSERT(opt.fCoveragePOI.isFourChannelOutput());
for (int m = 0; m <= SkXfermode::kLastCoeffMode; m++) {
SkXfermode::Mode xfermode = static_cast<SkXfermode::Mode>(m);
const GrPorterDuffTest::XPInfo xpi(reporter, xfermode, caps, colorPOI, covPOI);
const GrPorterDuffTest::XPInfo xpi(reporter, xfermode, caps, opt);
switch (xfermode) {
case SkXfermode::kClear_Mode:
@ -293,18 +293,20 @@ static void test_lcd_coverage(skiatest::Reporter* reporter, const GrCaps& caps)
}
}
static void test_color_unknown_with_coverage(skiatest::Reporter* reporter, const GrCaps& caps) {
GrProcOptInfo colorPOI, covPOI;
colorPOI.calcWithInitialValues(nullptr, 0, 0, kNone_GrColorComponentFlags, false);
covPOI.calcWithInitialValues(nullptr, 0, 0, kNone_GrColorComponentFlags, true);
GrPipelineOptimizations optimizations;
optimizations.fColorPOI.calcWithInitialValues(nullptr, 0, 0, kNone_GrColorComponentFlags,
false);
optimizations.fCoveragePOI.calcWithInitialValues(nullptr, 0, 0, kNone_GrColorComponentFlags,
true);
SkASSERT(!colorPOI.isOpaque());
SkASSERT(!colorPOI.isSolidWhite());
SkASSERT(!covPOI.isSolidWhite());
SkASSERT(!covPOI.isFourChannelOutput());
SkASSERT(!optimizations.fColorPOI.isOpaque());
SkASSERT(!optimizations.fColorPOI.isSolidWhite());
SkASSERT(!optimizations.fCoveragePOI.isSolidWhite());
SkASSERT(!optimizations.fCoveragePOI.isFourChannelOutput());
for (int m = 0; m <= SkXfermode::kLastCoeffMode; m++) {
SkXfermode::Mode xfermode = static_cast<SkXfermode::Mode>(m);
const GrPorterDuffTest::XPInfo xpi(reporter, xfermode, caps, colorPOI, covPOI);
const GrPorterDuffTest::XPInfo xpi(reporter, xfermode, caps, optimizations);
switch (xfermode) {
@ -485,19 +487,20 @@ static void test_color_unknown_with_coverage(skiatest::Reporter* reporter, const
}
static void test_color_unknown_no_coverage(skiatest::Reporter* reporter, const GrCaps& caps) {
GrProcOptInfo colorPOI, covPOI;
colorPOI.calcWithInitialValues(nullptr, 0, GrColorPackRGBA(229, 0, 154, 0),
GrPipelineOptimizations optimizations;
optimizations.fColorPOI.calcWithInitialValues(nullptr, 0, GrColorPackRGBA(229, 0, 154, 0),
kR_GrColorComponentFlag | kB_GrColorComponentFlag, false);
covPOI.calcWithInitialValues(nullptr, 0, GrColorPackA4(255), kRGBA_GrColorComponentFlags, true);
optimizations.fCoveragePOI.calcWithInitialValues(nullptr, 0, GrColorPackA4(255),
kRGBA_GrColorComponentFlags, true);
SkASSERT(!colorPOI.isOpaque());
SkASSERT(!colorPOI.isSolidWhite());
SkASSERT(covPOI.isSolidWhite());
SkASSERT(!covPOI.isFourChannelOutput());
SkASSERT(!optimizations.fColorPOI.isOpaque());
SkASSERT(!optimizations.fColorPOI.isSolidWhite());
SkASSERT(optimizations.fCoveragePOI.isSolidWhite());
SkASSERT(!optimizations.fCoveragePOI.isFourChannelOutput());
for (int m = 0; m <= SkXfermode::kLastCoeffMode; m++) {
SkXfermode::Mode xfermode = static_cast<SkXfermode::Mode>(m);
const GrPorterDuffTest::XPInfo xpi(reporter, xfermode, caps, colorPOI, covPOI);
const GrPorterDuffTest::XPInfo xpi(reporter, xfermode, caps, optimizations);
switch (xfermode) {
case SkXfermode::kClear_Mode:
@ -688,18 +691,20 @@ static void test_color_unknown_no_coverage(skiatest::Reporter* reporter, const G
}
static void test_color_opaque_with_coverage(skiatest::Reporter* reporter, const GrCaps& caps) {
GrProcOptInfo colorPOI, covPOI;
colorPOI.calcWithInitialValues(nullptr, 0, GrColorPackA4(255), kA_GrColorComponentFlag, false);
covPOI.calcWithInitialValues(nullptr, 0, 0, kNone_GrColorComponentFlags, true);
GrPipelineOptimizations optimizations;
optimizations.fColorPOI.calcWithInitialValues(nullptr, 0, GrColorPackA4(255),
kA_GrColorComponentFlag, false);
optimizations.fCoveragePOI.calcWithInitialValues(nullptr, 0, 0, kNone_GrColorComponentFlags,
true);
SkASSERT(colorPOI.isOpaque());
SkASSERT(!colorPOI.isSolidWhite());
SkASSERT(!covPOI.isSolidWhite());
SkASSERT(!covPOI.isFourChannelOutput());
SkASSERT(optimizations.fColorPOI.isOpaque());
SkASSERT(!optimizations.fColorPOI.isSolidWhite());
SkASSERT(!optimizations.fCoveragePOI.isSolidWhite());
SkASSERT(!optimizations.fCoveragePOI.isFourChannelOutput());
for (int m = 0; m <= SkXfermode::kLastCoeffMode; m++) {
SkXfermode::Mode xfermode = static_cast<SkXfermode::Mode>(m);
const GrPorterDuffTest::XPInfo xpi(reporter, xfermode, caps, colorPOI, covPOI);
const GrPorterDuffTest::XPInfo xpi(reporter, xfermode, caps, optimizations);
switch (xfermode) {
case SkXfermode::kClear_Mode:
@ -885,19 +890,20 @@ static void test_color_opaque_with_coverage(skiatest::Reporter* reporter, const
}
static void test_color_opaque_no_coverage(skiatest::Reporter* reporter, const GrCaps& caps) {
GrProcOptInfo colorPOI, covPOI;
colorPOI.calcWithInitialValues(nullptr, 0, GrColorPackRGBA(0, 82, 0, 255),
GrPipelineOptimizations optimizations;
optimizations.fColorPOI.calcWithInitialValues(nullptr, 0, GrColorPackRGBA(0, 82, 0, 255),
kG_GrColorComponentFlag | kA_GrColorComponentFlag, false);
covPOI.calcWithInitialValues(nullptr, 0, GrColorPackA4(255), kRGBA_GrColorComponentFlags, true);
optimizations.fCoveragePOI.calcWithInitialValues(nullptr, 0, GrColorPackA4(255),
kRGBA_GrColorComponentFlags, true);
SkASSERT(colorPOI.isOpaque());
SkASSERT(!colorPOI.isSolidWhite());
SkASSERT(covPOI.isSolidWhite());
SkASSERT(!covPOI.isFourChannelOutput());
SkASSERT(optimizations.fColorPOI.isOpaque());
SkASSERT(!optimizations.fColorPOI.isSolidWhite());
SkASSERT(optimizations.fCoveragePOI.isSolidWhite());
SkASSERT(!optimizations.fCoveragePOI.isFourChannelOutput());
for (int m = 0; m <= SkXfermode::kLastCoeffMode; m++) {
SkXfermode::Mode xfermode = static_cast<SkXfermode::Mode>(m);
const GrPorterDuffTest::XPInfo xpi(reporter, xfermode, caps, colorPOI, covPOI);
const GrPorterDuffTest::XPInfo xpi(reporter, xfermode, caps, optimizations);
switch (xfermode) {
case SkXfermode::kClear_Mode:
@ -1126,10 +1132,10 @@ static void test_lcd_coverage_fallback_case(skiatest::Reporter* reporter, const
SkASSERT(covPOI.isFourChannelOutput());
SkAutoTUnref<GrXPFactory> xpf(GrPorterDuffXPFactory::Create(SkXfermode::kSrcOver_Mode));
TEST_ASSERT(!xpf->willNeedDstTexture(caps, colorPOI, covPOI, false));
TEST_ASSERT(!xpf->willNeedDstTexture(caps, opts, false));
SkAutoTUnref<GrXferProcessor> xp(
xpf->createXferProcessor(colorPOI, covPOI, false, nullptr, caps));
xpf->createXferProcessor(opts, false, nullptr, caps));
if (!xp) {
ERRORF(reporter, "Failed to create an XP with LCD coverage.");
return;
@ -1141,7 +1147,7 @@ static void test_lcd_coverage_fallback_case(skiatest::Reporter* reporter, const
TEST_ASSERT(kNone_GrColorComponentFlags == blendedColor.fKnownColorFlags);
GrColor overrideColor;
xp->getOptimizations(colorPOI, covPOI, false, &overrideColor, caps);
xp->getOptimizations(opts, false, &overrideColor, caps);
GrXferProcessor::BlendInfo blendInfo;
xp->getBlendInfo(&blendInfo);
@ -1189,29 +1195,30 @@ static void test_no_dual_source_blending(skiatest::Reporter* reporter) {
GR_STATIC_ASSERT(SK_ARRAY_COUNT(testColors) == SK_ARRAY_COUNT(testColorFlags));
for (size_t c = 0; c < SK_ARRAY_COUNT(testColors); c++) {
GrProcOptInfo colorPOI;
colorPOI.calcWithInitialValues(nullptr, 0, testColors[c], testColorFlags[c], false);
GrPipelineOptimizations optimizations;
optimizations.fColorPOI.calcWithInitialValues(nullptr, 0, testColors[c], testColorFlags[c],
false);
for (int f = 0; f <= 1; f++) {
GrProcOptInfo covPOI;
if (!f) {
covPOI.calcWithInitialValues(nullptr, 0, 0, kNone_GrColorComponentFlags, true);
optimizations.fCoveragePOI.calcWithInitialValues(nullptr, 0, 0,
kNone_GrColorComponentFlags, true);
} else {
covPOI.calcWithInitialValues(nullptr, 0, GrColorPackA4(255),
kRGBA_GrColorComponentFlags, true);
optimizations.fCoveragePOI.calcWithInitialValues(nullptr, 0, GrColorPackA4(255),
kRGBA_GrColorComponentFlags, true);
}
for (int m = 0; m <= SkXfermode::kLastCoeffMode; m++) {
SkXfermode::Mode xfermode = static_cast<SkXfermode::Mode>(m);
SkAutoTUnref<GrXPFactory> xpf(GrPorterDuffXPFactory::Create(xfermode));
GrXferProcessor::DstTexture* dstTexture =
xpf->willNeedDstTexture(caps, colorPOI, covPOI, false) ? &fakeDstTexture : 0;
xpf->willNeedDstTexture(caps, optimizations, false) ? &fakeDstTexture : 0;
SkAutoTUnref<GrXferProcessor> xp(
xpf->createXferProcessor(colorPOI, covPOI, false, dstTexture, caps));
xpf->createXferProcessor(optimizations, false, dstTexture, caps));
if (!xp) {
ERRORF(reporter, "Failed to create an XP without dual source blending.");
return;
}
TEST_ASSERT(!xp->hasSecondaryOutput());
xp->getOptimizations(colorPOI, covPOI, false, 0, caps);
xp->getOptimizations(optimizations, false, 0, caps);
TEST_ASSERT(!xp->hasSecondaryOutput());
}
}