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

Revert of Add isSingleComponent bool to getConstantColorComponent (patchset #6 id:100001 of https://codereview.chromium.org/608253002/)

Browse Source 
Reason for revert:
Changing some GMs

Original issue's description:
> Add isSingleComponent bool to getConstantColorComponent
>
> Initial step to allowing effects to use/output 1 or 4 color/coverage components. This cl doesn't change any current logic and all effects still assume they are working with 4 components.
>
> BUG=skia:
>
> Committed: https://skia.googlesource.com/skia/+/3b8af078281a5a20f951b9fd84f38d92b8f6217b

TBR=joshualitt@chromium.org,bsalomon@google.com,reed@google.com,egdaniel@google.com
NOTREECHECKS=true
NOTRY=true
BUG=skia:

Review URL: https://codereview.chromium.org/617853003
This commit is contained in:
robertphillips 2014-10-02 12:12:48 -07:00 committed by Commit bot
parent 85d3427d49
commit b4b7a4c9ea
47 changed files with 331 additions and 440 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

49
include/gpu/GrProcessor.h
View File

@ -37,49 +37,14 @@ public:
virtual ~GrProcessor();
struct InvariantOutput{
GrColor fColor;
uint32_t fValidFlags;
bool fIsSingleComponent;
bool isOpaque() const {
return ((fValidFlags & kA_GrColorComponentFlag) && 0xFF == GrColorUnpackA(fColor));
}
bool isSolidWhite() const {
return (fValidFlags == kRGBA_GrColorComponentFlags &&
0xFFFFFFFF == GrColorUnpackA(fColor));
}
/**
* If isSingleComponent is true, then the flag values for r, g, b, and a must all be the
* same. If the flags are all set then all color components must be equal.
*/
SkDEBUGCODE(void validate() const;)
private:
SkDEBUGCODE(bool colorComponentsAllEqual() const;)
/**
* If alpha is valid, check that any valid R,G,B values are <= A
*/
SkDEBUGCODE(bool validPreMulColor() const;)
};
/**
* This function is used to perform optimizations. When called the invarientOuput param
* This function is used to perform optimizations. When called the color and validFlags params
* indicate whether the input components to this effect in the FS will have known values.
* In inout the validFlags member is a bitfield of GrColorComponentFlags. The isSingleComponent
* member indicates whether the input will be 1 or 4 bytes. The function updates the members of
* inout to indicate known values of its output. A component of the color member only has
* meaning if the corresponding bit in validFlags is set.
* validFlags is a bitfield of GrColorComponentFlags. The function updates both params to
* indicate known values of its output. A component of the color param only has meaning if the
* corresponding bit in validFlags is set.
*/
void computeInvariantOutput(InvariantOutput* inout) const {
this->onComputeInvariantOutput(inout);
#ifdef SK_DEBUG
inout->validate();
#endif
}
virtual void getConstantColorComponents(GrColor* color, uint32_t* validFlags) const = 0;
/** This object, besides creating back-end-specific helper objects, is used for run-time-type-
identification. The factory should be an instance of templated class,
@ -193,10 +158,6 @@ private:
getFactory()).*/
virtual bool onIsEqual(const GrProcessor& other) const = 0;
/**
* Subclass implements this to support getConstantColorComponents(...).
*/
virtual void onComputeInvariantOutput(InvariantOutput* inout) const = 0;
friend class GrGeometryProcessor; // to set fRequiresVertexShader and build fVertexAttribTypes.
SkSTArray<4, const GrCoordTransform*, true> fCoordTransforms;

10
src/core/SkXfermode.cpp
View File

@ -799,6 +799,11 @@ public:
}
}
virtual void getConstantColorComponents(GrColor* color,
uint32_t* validFlags) const SK_OVERRIDE {
*validFlags = 0;
}
virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE {
return GrTBackendFragmentProcessorFactory<XferEffect>::getInstance();
}
@ -1212,11 +1217,6 @@ private:
fBackgroundAccess.getTexture() == s.fBackgroundAccess.getTexture();
}
virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE {
inout->fValidFlags = 0;
inout->fIsSingleComponent = false;
}
SkXfermode::Mode fMode;
GrCoordTransform fBackgroundTransform;
GrTextureAccess fBackgroundAccess;

14
src/effects/SkAlphaThresholdFilter.cpp
View File

@ -76,6 +76,8 @@ public:
static const char* Name() { return "Alpha Threshold"; }
virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
virtual void getConstantColorComponents(GrColor* color, uint32_t* validFlags) const SK_OVERRIDE;
float innerThreshold() const { return fInnerThreshold; }
float outerThreshold() const { return fOuterThreshold; }
@ -102,8 +104,6 @@ private:
virtual bool onIsEqual(const GrProcessor&) const SK_OVERRIDE;
virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE;
GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
float fInnerThreshold;
@ -228,13 +228,13 @@ bool AlphaThresholdEffect::onIsEqual(const GrProcessor& sBase) const {
this->fOuterThreshold == s.fOuterThreshold);
}
void AlphaThresholdEffect::onComputeInvariantOutput(InvariantOutput* inout) const {
if (inout->isOpaque() && GrPixelConfigIsOpaque(this->texture(0)->config())) {
inout->fValidFlags = kA_GrColorComponentFlag;
void AlphaThresholdEffect::getConstantColorComponents(GrColor* color, uint32_t* validFlags) const {
if ((*validFlags & kA_GrColorComponentFlag) && 0xFF == GrColorUnpackA(*color) &&
GrPixelConfigIsOpaque(this->texture(0)->config())) {
*validFlags = kA_GrColorComponentFlag;
} else {
inout->fValidFlags = 0;
*validFlags = 0;
}
inout->fIsSingleComponent = false;
}
#endif

9
src/effects/SkArithmeticMode.cpp
View File

@ -289,6 +289,8 @@ public:
static const char* Name() { return "Arithmetic"; }
GrTexture* backgroundTexture() const { return fBackgroundAccess.getTexture(); }
virtual void getConstantColorComponents(GrColor* color, uint32_t* validFlags) const SK_OVERRIDE;
float k1() const { return fK1; }
float k2() const { return fK2; }
float k3() const { return fK3; }
@ -298,8 +300,6 @@ public:
private:
virtual bool onIsEqual(const GrProcessor&) const SK_OVERRIDE;
virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE;
GrArithmeticEffect(float k1, float k2, float k3, float k4, bool enforcePMColor,
GrTexture* background);
float fK1, fK2, fK3, fK4;
@ -344,10 +344,9 @@ const GrBackendFragmentProcessorFactory& GrArithmeticEffect::getFactory() const
return GrTBackendFragmentProcessorFactory<GrArithmeticEffect>::getInstance();
}
void GrArithmeticEffect::onComputeInvariantOutput(InvariantOutput* inout) const {
void GrArithmeticEffect::getConstantColorComponents(GrColor* color, uint32_t* validFlags) const {
// TODO: optimize this
inout->fValidFlags = 0;
inout->fIsSingleComponent = false;
*validFlags = 0;
}
///////////////////////////////////////////////////////////////////////////////

19
src/effects/SkBlurMaskFilter.cpp
View File

@ -563,6 +563,8 @@ public:
typedef GrGLRectBlurEffect GLProcessor;
virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
virtual void getConstantColorComponents(GrColor* color, uint32_t* validFlags) const SK_OVERRIDE;
/**
* Create a simple filter effect with custom bicubic coefficients.
*/
@ -592,8 +594,6 @@ private:
GrRectBlurEffect(const SkRect& rect, float sigma, GrTexture *blur_profile);
virtual bool onIsEqual(const GrProcessor&) const SK_OVERRIDE;
virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE;
static bool CreateBlurProfileTexture(GrContext *context, float sigma,
GrTexture **blurProfileTexture);
@ -765,9 +765,9 @@ bool GrRectBlurEffect::onIsEqual(const GrProcessor& sBase) const {
return this->getSigma() == s.getSigma() && this->getRect() == s.getRect();
}
void GrRectBlurEffect::onComputeInvariantOutput(InvariantOutput* inout) const {
inout->fValidFlags = 0;
inout->fIsSingleComponent = false;
void GrRectBlurEffect::getConstantColorComponents(GrColor* color, uint32_t* validFlags) const {
*validFlags = 0;
return;
}
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrRectBlurEffect);
@ -837,6 +837,8 @@ public:
typedef GrGLRRectBlurEffect GLProcessor;
virtual void getConstantColorComponents(GrColor* color, uint32_t* validFlags) const SK_OVERRIDE;
virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
private:
@ -844,8 +846,6 @@ private:
virtual bool onIsEqual(const GrProcessor& other) const SK_OVERRIDE;
virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE;
SkRRect fRRect;
float fSigma;
GrTextureAccess fNinePatchAccess;
@ -929,9 +929,8 @@ GrFragmentProcessor* GrRRectBlurEffect::Create(GrContext* context, float sigma,
return SkNEW_ARGS(GrRRectBlurEffect, (sigma, rrect, blurNinePatchTexture));
}
void GrRRectBlurEffect::onComputeInvariantOutput(InvariantOutput* inout) const {
inout->fValidFlags = 0;
inout->fIsSingleComponent = false;
void GrRRectBlurEffect::getConstantColorComponents(GrColor* color, uint32_t* validFlags) const {
*validFlags = 0;
}
const GrBackendFragmentProcessorFactory& GrRRectBlurEffect::getFactory() const {

15
src/effects/SkColorFilters.cpp
View File

@ -195,6 +195,8 @@ public:
return SkNEW_ARGS(ModeColorFilterEffect, (c, mode));
}
virtual void getConstantColorComponents(GrColor* color, uint32_t* validFlags) const SK_OVERRIDE;
bool willUseFilterColor() const {
SkXfermode::Coeff dstCoeff;
SkXfermode::Coeff srcCoeff;
@ -291,8 +293,6 @@ private:
return fMode == s.fMode && fColor == s.fColor;
}
virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE;
SkXfermode::Mode fMode;
GrColor fColor;
@ -382,19 +382,18 @@ private:
}
void ModeColorFilterEffect::onComputeInvariantOutput(InvariantOutput* inout) const {
void ModeColorFilterEffect::getConstantColorComponents(GrColor* color, uint32_t* validFlags) const {
float inputColor[4];
GrColorToRGBAFloat(inout->fColor, inputColor);
GrColorToRGBAFloat(*color, inputColor);
float filterColor[4];
GrColorToRGBAFloat(fColor, filterColor);
MaskedColorExpr result =
color_filter_expression(fMode,
MaskedColorExpr(filterColor, kRGBA_GrColorComponentFlags),
MaskedColorExpr(inputColor, inout->fValidFlags));
MaskedColorExpr(inputColor, *validFlags));
inout->fColor = result.getColor();
inout->fValidFlags = result.getValidComponents();
inout->fIsSingleComponent = false;
*color = result.getColor();
*validFlags = result.getValidComponents();
}
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(ModeColorFilterEffect);

90
src/effects/SkColorMatrixFilter.cpp
View File

@ -349,6 +349,51 @@ public:
return GrTBackendFragmentProcessorFactory<ColorMatrixEffect>::getInstance();
}
virtual void getConstantColorComponents(GrColor* color,
uint32_t* validFlags) const SK_OVERRIDE {
// We only bother to check whether the alpha channel will be constant. If SkColorMatrix had
// type flags it might be worth checking the other components.
// The matrix is defined such the 4th row determines the output alpha. The first four
// columns of that row multiply the input r, g, b, and a, respectively, and the last column
// is the "translation".
static const uint32_t kRGBAFlags[] = {
kR_GrColorComponentFlag,
kG_GrColorComponentFlag,
kB_GrColorComponentFlag,
kA_GrColorComponentFlag
};
static const int kShifts[] = {
GrColor_SHIFT_R, GrColor_SHIFT_G, GrColor_SHIFT_B, GrColor_SHIFT_A,
};
enum {
kAlphaRowStartIdx = 15,
kAlphaRowTranslateIdx = 19,
};
SkScalar outputA = 0;
for (int i = 0; i < 4; ++i) {
// If any relevant component of the color to be passed through the matrix is non-const
// then we can't know the final result.
if (0 != fMatrix.fMat[kAlphaRowStartIdx + i]) {
if (!(*validFlags & kRGBAFlags[i])) {
*validFlags = 0;
return;
} else {
uint32_t component = (*color >> kShifts[i]) & 0xFF;
outputA += fMatrix.fMat[kAlphaRowStartIdx + i] * component;
}
}
}
outputA += fMatrix.fMat[kAlphaRowTranslateIdx];
*validFlags = kA_GrColorComponentFlag;
// We pin the color to [0,1]. This would happen to the *final* color output from the frag
// shader but currently the effect does not pin its own output. So in the case of over/
// underflow this may deviate from the actual result. Maybe the effect should pin its
// result if the matrix could over/underflow for any component?
*color = static_cast<uint8_t>(SkScalarPin(outputA, 0, 255)) << GrColor_SHIFT_A;
}
GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
class GLProcessor : public GrGLFragmentProcessor {
@ -426,51 +471,6 @@ private:
return cme.fMatrix == fMatrix;
}
virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE {
// We only bother to check whether the alpha channel will be constant. If SkColorMatrix had
// type flags it might be worth checking the other components.
// The matrix is defined such the 4th row determines the output alpha. The first four
// columns of that row multiply the input r, g, b, and a, respectively, and the last column
// is the "translation".
static const uint32_t kRGBAFlags[] = {
kR_GrColorComponentFlag,
kG_GrColorComponentFlag,
kB_GrColorComponentFlag,
kA_GrColorComponentFlag
};
static const int kShifts[] = {
GrColor_SHIFT_R, GrColor_SHIFT_G, GrColor_SHIFT_B, GrColor_SHIFT_A,
};
enum {
kAlphaRowStartIdx = 15,
kAlphaRowTranslateIdx = 19,
};
SkScalar outputA = 0;
for (int i = 0; i < 4; ++i) {
// If any relevant component of the color to be passed through the matrix is non-const
// then we can't know the final result.
if (0 != fMatrix.fMat[kAlphaRowStartIdx + i]) {
if (!(inout->fValidFlags & kRGBAFlags[i])) {
inout->fValidFlags = 0;
return;
} else {
uint32_t component = (inout->fColor >> kShifts[i]) & 0xFF;
outputA += fMatrix.fMat[kAlphaRowStartIdx + i] * component;
}
}
}
outputA += fMatrix.fMat[kAlphaRowTranslateIdx];
inout->fValidFlags = kA_GrColorComponentFlag;
// We pin the color to [0,1]. This would happen to the *final* color output from the frag
// shader but currently the effect does not pin its own output. So in the case of over/
// underflow this may deviate from the actual result. Maybe the effect should pin its
// result if the matrix could over/underflow for any component?
inout->fColor = static_cast<uint8_t>(SkScalarPin(outputA, 0, 255)) << GrColor_SHIFT_A;
inout->fIsSingleComponent = false;
}
SkColorMatrix fMatrix;
typedef GrFragmentProcessor INHERITED;

10
src/effects/SkDisplacementMapEffect.cpp
View File

@ -351,11 +351,11 @@ public:
typedef GrGLDisplacementMapEffect GLProcessor;
static const char* Name() { return "DisplacementMap"; }
virtual void getConstantColorComponents(GrColor* color, uint32_t* validFlags) const SK_OVERRIDE;
private:
virtual bool onIsEqual(const GrProcessor&) const SK_OVERRIDE;
virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE;
GrDisplacementMapEffect(SkDisplacementMapEffect::ChannelSelectorType xChannelSelector,
SkDisplacementMapEffect::ChannelSelectorType yChannelSelector,
const SkVector& scale,
@ -491,14 +491,14 @@ const GrBackendFragmentProcessorFactory& GrDisplacementMapEffect::getFactory() c
return GrTBackendFragmentProcessorFactory<GrDisplacementMapEffect>::getInstance();
}
void GrDisplacementMapEffect::onComputeInvariantOutput(InvariantOutput* inout) const {
void GrDisplacementMapEffect::getConstantColorComponents(GrColor*,
uint32_t* validFlags) const {
// Any displacement offset bringing a pixel out of bounds will output a color of (0,0,0,0),
// so the only way we'd get a constant alpha is if the input color image has a constant alpha
// and no displacement offset push any texture coordinates out of bounds OR if the constant
// alpha is 0. Since this isn't trivial to compute at this point, let's assume the output is
// not of constant color when a displacement effect is applied.
inout->fValidFlags = 0;
inout->fIsSingleComponent = false;
*validFlags = 0;
}
///////////////////////////////////////////////////////////////////////////////

12
src/effects/SkLightingImageFilter.cpp
View File

@ -350,15 +350,15 @@ public:
SkScalar surfaceScale() const { return fSurfaceScale; }
const SkMatrix& filterMatrix() const { return fFilterMatrix; }
virtual void getConstantColorComponents(GrColor* color,
uint32_t* validFlags) const SK_OVERRIDE {
// lighting shaders are complicated. We just throw up our hands.
*validFlags = 0;
}
protected:
virtual bool onIsEqual(const GrProcessor&) const SK_OVERRIDE;
virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE {
// lighting shaders are complicated. We just throw up our hands.
inout->fValidFlags = 0;
inout->fIsSingleComponent = false;
}
private:
typedef GrSingleTextureEffect INHERITED;
const SkLight* fLight;

14
src/effects/SkLumaColorFilter.cpp
View File

@ -73,6 +73,13 @@ public:
return GrTBackendFragmentProcessorFactory<LumaColorFilterEffect>::getInstance();
}
virtual void getConstantColorComponents(GrColor* color,
uint32_t* validFlags) const SK_OVERRIDE {
// The output is always black.
*color = GrColorPackRGBA(0, 0, 0, GrColorUnpackA(*color));
*validFlags = kRGB_GrColorComponentFlags;
}
class GLProcessor : public GrGLFragmentProcessor {
public:
GLProcessor(const GrBackendProcessorFactory& factory,
@ -112,13 +119,6 @@ private:
virtual bool onIsEqual(const GrProcessor&) const SK_OVERRIDE {
return true;
}
virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE {
// The output is always black.
inout->fColor = GrColorPackRGBA(0, 0, 0, GrColorUnpackA(inout->fColor));
inout->fValidFlags = kRGB_GrColorComponentFlags;
inout->fIsSingleComponent = false;
}
};
GrFragmentProcessor* SkLumaColorFilter::asFragmentProcessor(GrContext*) const {

9
src/effects/SkMagnifierImageFilter.cpp
View File

@ -47,6 +47,8 @@ public:
static const char* Name() { return "Magnifier"; }
virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
virtual void getConstantColorComponents(GrColor* color, uint32_t* validFlags) const SK_OVERRIDE;
float x_offset() const { return fXOffset; }
float y_offset() const { return fYOffset; }
float x_inv_zoom() const { return fXInvZoom; }
@ -74,8 +76,6 @@ private:
virtual bool onIsEqual(const GrProcessor&) const SK_OVERRIDE;
virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE;
GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
float fXOffset;
@ -227,9 +227,8 @@ bool GrMagnifierEffect::onIsEqual(const GrProcessor& sBase) const {
this->fYInvInset == s.fYInvInset);
}
void GrMagnifierEffect::onComputeInvariantOutput(InvariantOutput* inout) const {
this->updateInvariantOutputForModulation(inout);
inout->fIsSingleComponent = false;
void GrMagnifierEffect::getConstantColorComponents(GrColor* color, uint32_t* validFlags) const {
this->updateConstantColorComponentsForModulation(color, validFlags);
}
#endif

8
src/effects/SkMorphologyImageFilter.cpp
View File

@ -309,6 +309,7 @@ public:
typedef GrGLMorphologyEffect GLProcessor;
virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
virtual void getConstantColorComponents(GrColor* color, uint32_t* validFlags) const SK_OVERRIDE;
protected:
@ -317,8 +318,6 @@ protected:
private:
virtual bool onIsEqual(const GrProcessor&) const SK_OVERRIDE;
virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE;
GrMorphologyEffect(GrTexture*, Direction, int radius, MorphologyType);
GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
@ -456,11 +455,10 @@ bool GrMorphologyEffect::onIsEqual(const GrProcessor& sBase) const {
this->type() == s.type());
}
void GrMorphologyEffect::onComputeInvariantOutput(InvariantOutput* inout) const {
void GrMorphologyEffect::getConstantColorComponents(GrColor* color, uint32_t* validFlags) const {
// This is valid because the color components of the result of the kernel all come
// exactly from existing values in the source texture.
this->updateInvariantOutputForModulation(inout);
inout->fIsSingleComponent = false;
this->updateConstantColorComponentsForModulation(color, validFlags);
}
///////////////////////////////////////////////////////////////////////////////

9
src/effects/SkPerlinNoiseShader.cpp
View File

@ -586,11 +586,6 @@ private:
fPaintingData->fStitchDataInit == s.fPaintingData->fStitchDataInit;
}
void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE {
inout->fValidFlags = 0; // This is noise. Nothing is constant.
inout->fIsSingleComponent = false;
}
GrPerlinNoiseEffect(SkPerlinNoiseShader::Type type,
int numOctaves, bool stitchTiles,
SkPerlinNoiseShader::PaintingData* paintingData,
@ -621,6 +616,10 @@ private:
GrTextureAccess fNoiseAccess;
SkPerlinNoiseShader::PaintingData *fPaintingData;
void getConstantColorComponents(GrColor*, uint32_t* validFlags) const SK_OVERRIDE {
*validFlags = 0; // This is noise. Nothing is constant.
}
private:
typedef GrFragmentProcessor INHERITED;
};

17
src/effects/SkTableColorFilter.cpp
View File

@ -294,20 +294,20 @@ public:
static const char* Name() { return "ColorTable"; }
virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
virtual void getConstantColorComponents(GrColor* color, uint32_t* validFlags) const SK_OVERRIDE;
typedef GLColorTableEffect GLProcessor;
private:
virtual bool onIsEqual(const GrProcessor&) const SK_OVERRIDE;
virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE;
explicit ColorTableEffect(GrTexture* texture, unsigned flags);
GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
GrTextureAccess fTextureAccess;
unsigned fFlags; // currently not used in shader code, just to assist
// onComputeInvariantOutput().
// getConstantColorComponents().
typedef GrFragmentProcessor INHERITED;
};
@ -401,22 +401,21 @@ bool ColorTableEffect::onIsEqual(const GrProcessor& sBase) const {
return this->texture(0) == sBase.texture(0);
}
void ColorTableEffect::onComputeInvariantOutput(InvariantOutput* inout) const {
void ColorTableEffect::getConstantColorComponents(GrColor* color, uint32_t* validFlags) const {
// If we kept the table in the effect then we could actually run known inputs through the
// table.
if (fFlags & SkTable_ColorFilter::kR_Flag) {
inout->fValidFlags &= ~kR_GrColorComponentFlag;
*validFlags &= ~kR_GrColorComponentFlag;
}
if (fFlags & SkTable_ColorFilter::kG_Flag) {
inout->fValidFlags &= ~kG_GrColorComponentFlag;
*validFlags &= ~kG_GrColorComponentFlag;
}
if (fFlags & SkTable_ColorFilter::kB_Flag) {
inout->fValidFlags &= ~kB_GrColorComponentFlag;
*validFlags &= ~kB_GrColorComponentFlag;
}
if (fFlags & SkTable_ColorFilter::kA_Flag) {
inout->fValidFlags &= ~kA_GrColorComponentFlag;
*validFlags &= ~kA_GrColorComponentFlag;
}
inout->fIsSingleComponent = false;
}

9
src/effects/gradients/SkGradientShader.cpp
View File

@ -1217,13 +1217,12 @@ bool GrGradientEffect::onIsEqual(const GrProcessor& processor) const {
return false;
}
void GrGradientEffect::onComputeInvariantOutput(InvariantOutput* inout) const {
if (fIsOpaque && inout->isOpaque()) {
inout->fValidFlags = kA_GrColorComponentFlag;
void GrGradientEffect::getConstantColorComponents(GrColor* color, uint32_t* validFlags) const {
if (fIsOpaque && (kA_GrColorComponentFlag & *validFlags) && 0xff == GrColorUnpackA(*color)) {
*validFlags = kA_GrColorComponentFlag;
} else {
inout->fValidFlags = 0;
*validFlags = 0;
}
inout->fIsSingleComponent = false;
}
int GrGradientEffect::RandomGradientParams(SkRandom* random,

4
src/effects/gradients/SkGradientShaderPriv.h
View File

@ -342,6 +342,8 @@ public:
bool useAtlas() const { return SkToBool(-1 != fRow); }
SkScalar getYCoord() const { return fYCoord; };
virtual void getConstantColorComponents(GrColor* color, uint32_t* validFlags) const SK_OVERRIDE;
SkGradientShaderBase::GpuColorType getColorType() const { return fColorType; }
enum PremulType {
@ -374,8 +376,6 @@ protected:
virtual bool onIsEqual(const GrProcessor&) const SK_OVERRIDE;
virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE;
const GrCoordTransform& getCoordTransform() const { return fCoordTransform; }
private:

10
src/gpu/GrAAConvexPathRenderer.cpp
View File

@ -517,6 +517,11 @@ public:
static const char* Name() { return "QuadEdge"; }
virtual void getConstantColorComponents(GrColor* color,
uint32_t* validFlags) const SK_OVERRIDE {
*validFlags = 0;
}
const GrShaderVar& inQuadEdge() const { return fInQuadEdge; }
virtual const GrBackendGeometryProcessorFactory& getFactory() const SK_OVERRIDE {
@ -588,11 +593,6 @@ private:
return true;
}
virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE {
inout->fValidFlags = 0;
inout->fIsSingleComponent = false;
}
const GrShaderVar& fInQuadEdge;
GR_DECLARE_GEOMETRY_PROCESSOR_TEST;

20
src/gpu/GrAARectRenderer.cpp
View File

@ -30,6 +30,11 @@ public:
static const char* Name() { return "AlignedRectEdge"; }
virtual void getConstantColorComponents(GrColor* color,
uint32_t* validFlags) const SK_OVERRIDE {
*validFlags = 0;
}
const GrShaderVar& inRect() const { return fInRect; }
virtual const GrBackendGeometryProcessorFactory& getFactory() const SK_OVERRIDE {
@ -107,11 +112,6 @@ private:
virtual bool onIsEqual(const GrProcessor&) const SK_OVERRIDE { return true; }
virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE {
inout->fValidFlags = 0;
inout->fIsSingleComponent = false;
}
GR_DECLARE_GEOMETRY_PROCESSOR_TEST;
typedef GrGeometryProcessor INHERITED;
@ -155,6 +155,11 @@ public:
static const char* Name() { return "RectEdge"; }
virtual void getConstantColorComponents(GrColor* color,
uint32_t* validFlags) const SK_OVERRIDE {
*validFlags = 0;
}
const GrShaderVar& inRectEdge() const { return fInRectEdge; }
const GrShaderVar& inWidthHeight() const { return fInWidthHeight; }
@ -252,11 +257,6 @@ private:
virtual bool onIsEqual(const GrProcessor&) const SK_OVERRIDE { return true; }
virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE {
inout->fValidFlags = 0;
inout->fIsSingleComponent = false;
}
const GrShaderVar& fInRectEdge;
const GrShaderVar& fInWidthHeight;

55
src/gpu/GrDrawState.cpp
View File

@ -421,26 +421,26 @@ bool GrDrawState::hasSolidCoverage() const {
return true;
}
GrProcessor::InvariantOutput inout;
inout.fIsSingleComponent = false;
GrColor coverage;
uint32_t validComponentFlags;
// Initialize to an unknown starting coverage if per-vertex coverage is specified.
if (this->hasCoverageVertexAttribute()) {
inout.fValidFlags = 0;
validComponentFlags = 0;
} else {
inout.fColor = fCoverage;
inout.fValidFlags = kRGBA_GrColorComponentFlags;
coverage = fCoverage;
validComponentFlags = kRGBA_GrColorComponentFlags;
}
// Run through the coverage stages and see if the coverage will be all ones at the end.
if (this->hasGeometryProcessor()) {
const GrGeometryProcessor* gp = fGeometryProcessor->getGeometryProcessor();
gp->computeInvariantOutput(&inout);
gp->getConstantColorComponents(&coverage, &validComponentFlags);
}
for (int s = 0; s < this->numCoverageStages(); ++s) {
const GrProcessor* processor = this->getCoverageStage(s).getProcessor();
processor->computeInvariantOutput(&inout);
processor->getConstantColorComponents(&coverage, &validComponentFlags);
}
return inout.isSolidWhite();
return (kRGBA_GrColorComponentFlags == validComponentFlags) && (0xffffffff == coverage);
}
//////////////////////////////////////////////////////////////////////////////
@ -755,54 +755,55 @@ GrDrawState::BlendOptFlags GrDrawState::getBlendOpts(bool forceCoverage,
bool GrDrawState::srcAlphaWillBeOne() const {
GrProcessor::InvariantOutput inoutColor;
inoutColor.fIsSingleComponent = false;
uint32_t validComponentFlags;
GrColor color;
// Check if per-vertex or constant color may have partial alpha
if (this->hasColorVertexAttribute()) {
if (fHints & kVertexColorsAreOpaque_Hint) {
inoutColor.fValidFlags = kA_GrColorComponentFlag;
inoutColor.fColor = 0xFF << GrColor_SHIFT_A;
validComponentFlags = kA_GrColorComponentFlag;
color = 0xFF << GrColor_SHIFT_A;
} else {
inoutColor.fValidFlags = 0;
// not strictly necessary but we get false alarms from tools about uninit.
inoutColor.fColor = 0;
validComponentFlags = 0;
color = 0; // not strictly necessary but we get false alarms from tools about uninit.
}
} else {
inoutColor.fValidFlags = kRGBA_GrColorComponentFlags;
inoutColor.fColor = this->getColor();
validComponentFlags = kRGBA_GrColorComponentFlags;
color = this->getColor();
}
// Run through the color stages
for (int s = 0; s < this->numColorStages(); ++s) {
const GrProcessor* processor = this->getColorStage(s).getProcessor();
processor->computeInvariantOutput(&inoutColor);
processor->getConstantColorComponents(&color, &validComponentFlags);
}
// Check whether coverage is treated as color. If so we run through the coverage computation.
if (this->isCoverageDrawing()) {
// The shader generated for coverage drawing runs the full coverage computation and then
// makes the shader output be the multiplication of color and coverage. We mirror that here.
GrProcessor::InvariantOutput inoutCoverage;
inoutCoverage.fIsSingleComponent = false;
GrColor coverage;
uint32_t coverageComponentFlags;
if (this->hasCoverageVertexAttribute()) {
inoutCoverage.fValidFlags = 0;
inoutCoverage.fColor = 0; // suppresses any warnings.
coverageComponentFlags = 0;
coverage = 0; // suppresses any warnings.
} else {
inoutCoverage.fValidFlags = kRGBA_GrColorComponentFlags;
inoutCoverage.fColor = this->getCoverageColor();
coverageComponentFlags = kRGBA_GrColorComponentFlags;
coverage = this->getCoverageColor();
}
// Run through the coverage stages
for (int s = 0; s < this->numCoverageStages(); ++s) {
const GrProcessor* processor = this->getCoverageStage(s).getProcessor();
processor->computeInvariantOutput(&inoutCoverage);
processor->getConstantColorComponents(&coverage, &coverageComponentFlags);
}
// Since the shader will multiply coverage and color, the only way the final A==1 is if
// coverage and color both have A==1.
return (inoutColor.isOpaque() && inoutCoverage.isOpaque());
return (kA_GrColorComponentFlag & validComponentFlags & coverageComponentFlags) &&
0xFF == GrColorUnpackA(color) && 0xFF == GrColorUnpackA(coverage);
}
return inoutColor.isOpaque();
return (kA_GrColorComponentFlag & validComponentFlags) && 0xFF == GrColorUnpackA(color);
}

23
src/gpu/GrOptDrawState.cpp
View File

@ -170,19 +170,18 @@ void GrOptDrawState::copyEffectiveColorStages(const GrDrawState& ds) {
int firstColorStage = 0;
// Set up color and flags for ConstantColorComponent checks
GrProcessor::InvariantOutput inout;
inout.fIsSingleComponent = false;
GrColor color;
uint32_t validComponentFlags;
if (!this->hasColorVertexAttribute()) {
inout.fColor = ds.getColor();
inout.fValidFlags = kRGBA_GrColorComponentFlags;
color = ds.getColor();
validComponentFlags = kRGBA_GrColorComponentFlags;
} else {
if (ds.vertexColorsAreOpaque()) {
inout.fColor = 0xFF << GrColor_SHIFT_A;
inout.fValidFlags = kA_GrColorComponentFlag;
color = 0xFF << GrColor_SHIFT_A;
validComponentFlags = kA_GrColorComponentFlag;
} else {
inout.fValidFlags = 0;
// not strictly necessary but we get false alarms from tools about uninit.
inout.fColor = 0;
validComponentFlags = 0;
color = 0; // not strictly necessary but we get false alarms from tools about uninit.
}
}
@ -192,10 +191,10 @@ void GrOptDrawState::copyEffectiveColorStages(const GrDrawState& ds) {
firstColorStage = i;
fInputColorIsUsed = false;
}
fp->computeInvariantOutput(&inout);
if (kRGBA_GrColorComponentFlags == inout.fValidFlags) {
fp->getConstantColorComponents(&color, &validComponentFlags);
if (kRGBA_GrColorComponentFlags == validComponentFlags) {
firstColorStage = i + 1;
fColor = inout.fColor;
fColor = color;
fInputColorIsUsed = true;
this->removeFixedFunctionVertexAttribs(0x1 << kColor_GrVertexAttribBinding);
}

30
src/gpu/GrOvalRenderer.cpp
View File

@ -75,6 +75,11 @@ public:
}
}
virtual void getConstantColorComponents(GrColor* color,
uint32_t* validFlags) const SK_OVERRIDE {
*validFlags = 0;
}
const GrShaderVar& inCircleEdge() const { return fInCircleEdge; }
virtual const GrBackendGeometryProcessorFactory& getFactory() const SK_OVERRIDE {
@ -145,11 +150,6 @@ private:
return cee.fStroke == fStroke;
}
virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE {
inout->fValidFlags = 0;
inout->fIsSingleComponent = false;
}
const GrShaderVar& fInCircleEdge;
bool fStroke;
@ -192,6 +192,11 @@ public:
}
}
virtual void getConstantColorComponents(GrColor* color,
uint32_t* validFlags) const SK_OVERRIDE {
*validFlags = 0;
}
virtual const GrBackendGeometryProcessorFactory& getFactory() const SK_OVERRIDE {
return GrTBackendGeometryProcessorFactory<EllipseEdgeEffect>::getInstance();
}
@ -286,11 +291,6 @@ private:
return eee.fStroke == fStroke;
}
virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE {
inout->fValidFlags = 0;
inout->fIsSingleComponent = false;
}
const GrShaderVar& fInEllipseOffset;
const GrShaderVar& fInEllipseRadii;
bool fStroke;
@ -341,6 +341,11 @@ public:
}
}
virtual void getConstantColorComponents(GrColor* color,
uint32_t* validFlags) const SK_OVERRIDE {
*validFlags = 0;
}
virtual const GrBackendGeometryProcessorFactory& getFactory() const SK_OVERRIDE {
return GrTBackendGeometryProcessorFactory<DIEllipseEdgeEffect>::getInstance();
}
@ -455,11 +460,6 @@ private:
return eee.fMode == fMode;
}
virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE {
inout->fValidFlags = 0;
inout->fIsSingleComponent = false;
}
const GrShaderVar& fInEllipseOffsets0;
const GrShaderVar& fInEllipseOffsets1;
Mode fMode;

24
src/gpu/GrPaint.cpp
View File

@ -52,32 +52,28 @@ bool GrPaint::getOpaqueAndKnownColor(GrColor* solidColor,
// TODO: Share this implementation with GrDrawState
GrProcessor::InvariantOutput inout;
inout.fColor = GrColorPackRGBA(fCoverage, fCoverage, fCoverage, fCoverage);
inout.fValidFlags = kRGBA_GrColorComponentFlags;
inout.fIsSingleComponent = false;
GrColor coverage = GrColorPackRGBA(fCoverage, fCoverage, fCoverage, fCoverage);
uint32_t coverageComps = kRGBA_GrColorComponentFlags;
int count = fCoverageStages.count();
for (int i = 0; i < count; ++i) {
fCoverageStages[i].getProcessor()->computeInvariantOutput(&inout);
fCoverageStages[i].getProcessor()->getConstantColorComponents(&coverage, &coverageComps);
}
if (!inout.isSolidWhite()) {
if (kRGBA_GrColorComponentFlags != coverageComps || 0xffffffff != coverage) {
return false;
}
inout.fColor = fColor;
inout.fValidFlags = kRGBA_GrColorComponentFlags;
inout.fIsSingleComponent = false;
GrColor color = fColor;
uint32_t colorComps = kRGBA_GrColorComponentFlags;
count = fColorStages.count();
for (int i = 0; i < count; ++i) {
fColorStages[i].getProcessor()->computeInvariantOutput(&inout);
fColorStages[i].getProcessor()->getConstantColorComponents(&color, &colorComps);
}
SkASSERT((NULL == solidColor) == (NULL == solidColorKnownComponents));
GrBlendCoeff srcCoeff = fSrcBlendCoeff;
GrBlendCoeff dstCoeff = fDstBlendCoeff;
GrSimplifyBlend(&srcCoeff, &dstCoeff, inout.fColor, inout.fValidFlags,
0, 0, 0);
GrSimplifyBlend(&srcCoeff, &dstCoeff, color, colorComps, 0, 0, 0);
bool opaque = kZero_GrBlendCoeff == dstCoeff && !GrBlendCoeffRefsDst(srcCoeff);
if (solidColor) {
@ -89,8 +85,8 @@ bool GrPaint::getOpaqueAndKnownColor(GrColor* solidColor,
break;
case kOne_GrBlendCoeff:
*solidColor = inout.fColor;
*solidColorKnownComponents = inout.fValidFlags;
*solidColor = color;
*solidColorKnownComponents = colorComps;
break;
// The src coeff should never refer to the src and if it refers to dst then opaque

42
src/gpu/GrProcessor.cpp
View File

@ -88,46 +88,4 @@ void GrProcessor::assertEquality(const GrProcessor& other) const {
SkASSERT(this->textureAccess(i) == other.textureAccess(i));
}
}
void GrProcessor::InvariantOutput::validate() const {
if (fIsSingleComponent) {
SkASSERT(0 == fValidFlags || kRGBA_GrColorComponentFlags == fValidFlags);
if (kRGBA_GrColorComponentFlags == fValidFlags) {
SkASSERT(this->colorComponentsAllEqual());
}
}
SkASSERT(this->validPreMulColor());
}
bool GrProcessor::InvariantOutput::colorComponentsAllEqual() const {
unsigned colorA = GrColorUnpackA(fColor);
return(GrColorUnpackR(fColor) == colorA &&
GrColorUnpackG(fColor) == colorA &&
GrColorUnpackB(fColor) == colorA);
}
bool GrProcessor::InvariantOutput::validPreMulColor() const {
if (kA_GrColorComponentFlag & fValidFlags) {
float c[4];
GrColorToRGBAFloat(fColor, c);
if (kR_GrColorComponentFlag & fValidFlags) {
if (c[0] > c[3]) {
return false;
}
}
if (kG_GrColorComponentFlag & fValidFlags) {
if (c[1] > c[3]) {
return false;
}
}
if (kB_GrColorComponentFlag & fValidFlags) {
if (c[2] > c[3]) {
return false;
}
}
}
return true;
}
#endif

30
src/gpu/effects/GrBezierEffect.h
View File

@ -97,6 +97,11 @@ public:
typedef GrGLConicEffect GLProcessor;
virtual void getConstantColorComponents(GrColor* color,
uint32_t* validFlags) const SK_OVERRIDE {
*validFlags = 0;
}
virtual const GrBackendGeometryProcessorFactory& getFactory() const SK_OVERRIDE;
private:
@ -104,11 +109,6 @@ private:
virtual bool onIsEqual(const GrProcessor& other) const SK_OVERRIDE;
virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE {
inout->fValidFlags = 0;
inout->fIsSingleComponent = false;
}
GrPrimitiveEdgeType fEdgeType;
const GrShaderVar& fInConicCoeffs;
@ -170,6 +170,11 @@ public:
typedef GrGLQuadEffect GLProcessor;
virtual void getConstantColorComponents(GrColor* color,
uint32_t* validFlags) const SK_OVERRIDE {
*validFlags = 0;
}
virtual const GrBackendGeometryProcessorFactory& getFactory() const SK_OVERRIDE;
private:
@ -177,11 +182,6 @@ private:
virtual bool onIsEqual(const GrProcessor& other) const SK_OVERRIDE;
virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE {
inout->fValidFlags = 0;
inout->fIsSingleComponent = false;
}
GrPrimitiveEdgeType fEdgeType;
const GrShaderVar& fInHairQuadEdge;
@ -245,6 +245,11 @@ public:
typedef GrGLCubicEffect GLProcessor;
virtual void getConstantColorComponents(GrColor* color,
uint32_t* validFlags) const SK_OVERRIDE {
*validFlags = 0;
}
virtual const GrBackendGeometryProcessorFactory& getFactory() const SK_OVERRIDE;
private:
@ -252,11 +257,6 @@ private:
virtual bool onIsEqual(const GrProcessor& other) const SK_OVERRIDE;
virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE {
inout->fValidFlags = 0;
inout->fIsSingleComponent = false;
}
GrPrimitiveEdgeType fEdgeType;
const GrShaderVar& fInCubicCoeffs;

5
src/gpu/effects/GrBicubicEffect.cpp
View File

@ -169,10 +169,9 @@ bool GrBicubicEffect::onIsEqual(const GrProcessor& sBase) const {
fDomain == s.fDomain;
}
void GrBicubicEffect::onComputeInvariantOutput(InvariantOutput* inout) const {
void GrBicubicEffect::getConstantColorComponents(GrColor* color, uint32_t* validFlags) const {
// FIXME: Perhaps we can do better.
inout->fValidFlags = 0;
inout->fIsSingleComponent = false;
*validFlags = 0;
return;
}

3
src/gpu/effects/GrBicubicEffect.h
View File

@ -29,6 +29,7 @@ public:
typedef GrGLBicubicEffect GLProcessor;
virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
virtual void getConstantColorComponents(GrColor* color, uint32_t* validFlags) const SK_OVERRIDE;
const GrTextureDomain& domain() const { return fDomain; }
@ -92,8 +93,6 @@ private:
const SkMatrix &matrix, const SkRect& domain);
virtual bool onIsEqual(const GrProcessor&) const SK_OVERRIDE;
virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE;
float fCoefficients[16];
GrTextureDomain fDomain;

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

@ -126,9 +126,9 @@ bool GrConfigConversionEffect::onIsEqual(const GrProcessor& s) const {
other.fPMConversion == fPMConversion;
}
void GrConfigConversionEffect::onComputeInvariantOutput(InvariantOutput* inout) const {
this->updateInvariantOutputForModulation(inout);
inout->fIsSingleComponent = false;
void GrConfigConversionEffect::getConstantColorComponents(GrColor* color,
uint32_t* validFlags) const {
this->updateConstantColorComponentsForModulation(color, validFlags);
}
///////////////////////////////////////////////////////////////////////////////

4
src/gpu/effects/GrConfigConversionEffect.h
View File

@ -43,6 +43,8 @@ public:
virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
virtual void getConstantColorComponents(GrColor* color, uint32_t* validFlags) const SK_OVERRIDE;
bool swapsRedAndBlue() const { return fSwapRedAndBlue; }
PMConversion pmConversion() const { return fPMConversion; }
@ -63,8 +65,6 @@ private:
virtual bool onIsEqual(const GrProcessor&) const SK_OVERRIDE;
virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE;
bool fSwapRedAndBlue;
PMConversion fPMConversion;

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

@ -29,6 +29,17 @@ public:
return SkNEW_ARGS(AARectEffect, (edgeType, rect));
}
virtual void getConstantColorComponents(GrColor* color,
uint32_t* validFlags) const SK_OVERRIDE {
if (fRect.isEmpty()) {
// An empty rect will have no coverage anywhere.
*color = 0x00000000;
*validFlags = kRGBA_GrColorComponentFlags;
} else {
*validFlags = 0;
}
}
GrPrimitiveEdgeType getEdgeType() const { return fEdgeType; }
virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
@ -43,17 +54,6 @@ private:
return fRect == aare.fRect;
}
virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE {
if (fRect.isEmpty()) {
// An empty rect will have no coverage anywhere.
inout->fColor = 0x00000000;
inout->fValidFlags = kRGBA_GrColorComponentFlags;
} else {
inout->fValidFlags = 0;
}
inout->fIsSingleComponent = false;
}
SkRect fRect;
GrPrimitiveEdgeType fEdgeType;
@ -328,9 +328,8 @@ GrFragmentProcessor* GrConvexPolyEffect::Create(GrPrimitiveEdgeType edgeType, co
GrConvexPolyEffect::~GrConvexPolyEffect() {}
void GrConvexPolyEffect::onComputeInvariantOutput(InvariantOutput* inout) const {
inout->fValidFlags = 0;
inout->fIsSingleComponent = false;
void GrConvexPolyEffect::getConstantColorComponents(GrColor* color, uint32_t* validFlags) const {
*validFlags = 0;
}
const GrBackendFragmentProcessorFactory& GrConvexPolyEffect::getFactory() const {

4
src/gpu/effects/GrConvexPolyEffect.h
View File

@ -70,6 +70,8 @@ public:
typedef GrGLConvexPolyEffect GLProcessor;
virtual void getConstantColorComponents(GrColor* color, uint32_t* validFlags) const SK_OVERRIDE;
virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
private:
@ -77,8 +79,6 @@ private:
virtual bool onIsEqual(const GrProcessor& other) const SK_OVERRIDE;
virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE;
GrPrimitiveEdgeType fEdgeType;
int fEdgeCount;
SkScalar fEdges[3 * kMaxEdges];

13
src/gpu/effects/GrConvolutionEffect.h
View File

@ -64,6 +64,12 @@ public:
virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
virtual void getConstantColorComponents(GrColor*, uint32_t* validFlags) const {
// If the texture was opaque we could know that the output color if we knew the sum of the
// kernel values.
*validFlags = 0;
}
enum {
// This was decided based on the min allowed value for the max texture
// samples per fragment program run in DX9SM2 (32). A sigma param of 4.0
@ -97,13 +103,6 @@ private:
virtual bool onIsEqual(const GrProcessor&) const SK_OVERRIDE;
virtual void onComputeInvariantOutput(InvariantOutput* inout) const {
// If the texture was opaque we could know that the output color if we knew the sum of the
// kernel values.
inout->fValidFlags = 0;
inout->fIsSingleComponent = false;
}
GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
typedef Gr1DKernelEffect INHERITED;

11
src/gpu/effects/GrCustomCoordsTextureEffect.cpp
View File

@ -72,13 +72,14 @@ bool GrCustomCoordsTextureEffect::onIsEqual(const GrProcessor& other) const {
return fTextureAccess == cte.fTextureAccess;
}
void GrCustomCoordsTextureEffect::onComputeInvariantOutput(InvariantOutput* inout) const {
if (inout->isOpaque() && GrPixelConfigIsOpaque(this->texture(0)->config())) {
inout->fValidFlags = kA_GrColorComponentFlag;
void GrCustomCoordsTextureEffect::getConstantColorComponents(GrColor* color,
uint32_t* validFlags) const {
if ((*validFlags & kA_GrColorComponentFlag) && 0xFF == GrColorUnpackA(*color) &&
GrPixelConfigIsOpaque(this->texture(0)->config())) {
*validFlags = kA_GrColorComponentFlag;
} else {
inout->fValidFlags = 0;
*validFlags = 0;
}
inout->fIsSingleComponent = false;
}
const GrBackendGeometryProcessorFactory& GrCustomCoordsTextureEffect::getFactory() const {

4
src/gpu/effects/GrCustomCoordsTextureEffect.h
View File

@ -28,6 +28,8 @@ public:
static const char* Name() { return "Texture"; }
virtual void getConstantColorComponents(GrColor* color, uint32_t* validFlags) const SK_OVERRIDE;
const GrShaderVar& inTextureCoords() const { return fInTextureCoords; }
typedef GrGLCustomCoordsTextureEffect GLProcessor;
@ -39,8 +41,6 @@ private:
virtual bool onIsEqual(const GrProcessor& other) const SK_OVERRIDE;
virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE;
GrTextureAccess fTextureAccess;
const GrShaderVar& fInTextureCoords;

18
src/gpu/effects/GrDashingEffect.cpp
View File

@ -456,6 +456,8 @@ public:
typedef GLDashingCircleEffect GLProcessor;
virtual void getConstantColorComponents(GrColor* color, uint32_t* validFlags) const SK_OVERRIDE;
virtual const GrBackendGeometryProcessorFactory& getFactory() const SK_OVERRIDE;
private:
@ -463,8 +465,6 @@ private:
virtual bool onIsEqual(const GrProcessor& other) const SK_OVERRIDE;
virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE;
GrPrimitiveEdgeType fEdgeType;
const GrShaderVar& fInCoord;
SkScalar fIntervalLength;
@ -584,9 +584,8 @@ GrGeometryProcessor* DashingCircleEffect::Create(GrPrimitiveEdgeType edgeType, c
DashingCircleEffect::~DashingCircleEffect() {}
void DashingCircleEffect::onComputeInvariantOutput(InvariantOutput* inout) const {
inout->fValidFlags = 0;
inout->fIsSingleComponent = false;
void DashingCircleEffect::getConstantColorComponents(GrColor* color, uint32_t* validFlags) const {
*validFlags = 0;
}
const GrBackendGeometryProcessorFactory& DashingCircleEffect::getFactory() const {
@ -669,6 +668,8 @@ public:
typedef GLDashingLineEffect GLProcessor;
virtual void getConstantColorComponents(GrColor* color, uint32_t* validFlags) const SK_OVERRIDE;
virtual const GrBackendGeometryProcessorFactory& getFactory() const SK_OVERRIDE;
private:
@ -676,8 +677,6 @@ private:
virtual bool onIsEqual(const GrProcessor& other) const SK_OVERRIDE;
virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE;
GrPrimitiveEdgeType fEdgeType;
const GrShaderVar& fInCoord;
SkRect fRect;
@ -808,9 +807,8 @@ GrGeometryProcessor* DashingLineEffect::Create(GrPrimitiveEdgeType edgeType,
DashingLineEffect::~DashingLineEffect() {}
void DashingLineEffect::onComputeInvariantOutput(InvariantOutput* inout) const {
inout->fValidFlags = 0;
inout->fIsSingleComponent = false;
void DashingLineEffect::getConstantColorComponents(GrColor* color, uint32_t* validFlags) const {
*validFlags = 0;
}
const GrBackendGeometryProcessorFactory& DashingLineEffect::getFactory() const {

24
src/gpu/effects/GrDistanceFieldTextureEffect.cpp
View File

@ -206,14 +206,14 @@ bool GrDistanceFieldTextureEffect::onIsEqual(const GrProcessor& other) const {
fFlags == cte.fFlags;
}
void GrDistanceFieldTextureEffect::onComputeInvariantOutput(
InvariantOutput* inout) const {
if (inout->isOpaque() && GrPixelConfigIsOpaque(this->texture(0)->config())) {
inout->fValidFlags = kA_GrColorComponentFlag;
void GrDistanceFieldTextureEffect::getConstantColorComponents(GrColor* color,
uint32_t* validFlags) const {
if ((*validFlags & kA_GrColorComponentFlag) && 0xFF == GrColorUnpackA(*color) &&
GrPixelConfigIsOpaque(this->texture(0)->config())) {
*validFlags = kA_GrColorComponentFlag;
} else {
inout->fValidFlags = 0;
*validFlags = 0;
}
inout->fIsSingleComponent = false;
}
const GrBackendGeometryProcessorFactory& GrDistanceFieldTextureEffect::getFactory() const {
@ -476,14 +476,14 @@ bool GrDistanceFieldLCDTextureEffect::onIsEqual(const GrProcessor& other) const
fFlags == cte.fFlags);
}
void GrDistanceFieldLCDTextureEffect::onComputeInvariantOutput(
InvariantOutput* inout) const {
if (inout->isOpaque() && GrPixelConfigIsOpaque(this->texture(0)->config())) {
inout->fValidFlags = kA_GrColorComponentFlag;
void GrDistanceFieldLCDTextureEffect::getConstantColorComponents(GrColor* color,
uint32_t* validFlags) const {
if ((*validFlags & kA_GrColorComponentFlag) && 0xFF == GrColorUnpackA(*color) &&
GrPixelConfigIsOpaque(this->texture(0)->config())) {
*validFlags = kA_GrColorComponentFlag;
} else {
inout->fValidFlags = 0;
*validFlags = 0;
}
inout->fIsSingleComponent = false;
}
const GrBackendGeometryProcessorFactory& GrDistanceFieldLCDTextureEffect::getFactory() const {

7
src/gpu/effects/GrDistanceFieldTextureEffect.h
View File

@ -58,6 +58,8 @@ public:
static const char* Name() { return "DistanceFieldTexture"; }
virtual void getConstantColorComponents(GrColor* color, uint32_t* validFlags) const SK_OVERRIDE;
const GrShaderVar& inTextureCoords() const { return fInTextureCoords; }
#ifdef SK_GAMMA_APPLY_TO_A8
float getLuminance() const { return fLuminance; }
@ -77,8 +79,6 @@ private:
virtual bool onIsEqual(const GrProcessor& other) const SK_OVERRIDE;
virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE;
GrTextureAccess fTextureAccess;
#ifdef SK_GAMMA_APPLY_TO_A8
GrTextureAccess fGammaTextureAccess;
@ -112,6 +112,7 @@ public:
static const char* Name() { return "DistanceFieldLCDTexture"; }
const GrShaderVar& inTextureCoords() const { return fInTextureCoords; }
virtual void getConstantColorComponents(GrColor* color, uint32_t* validFlags) const SK_OVERRIDE;
GrColor getTextColor() const { return fTextColor; }
uint32_t getFlags() const { return fFlags; }
@ -127,8 +128,6 @@ private:
virtual bool onIsEqual(const GrProcessor& other) const SK_OVERRIDE;
virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE;
GrTextureAccess fTextureAccess;
GrTextureAccess fGammaTextureAccess;
GrColor fTextColor;

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

@ -30,6 +30,8 @@ public:
typedef GLDitherEffect GLProcessor;
virtual void getConstantColorComponents(GrColor* color, uint32_t* validFlags) const SK_OVERRIDE;
virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE {
return GrTBackendFragmentProcessorFactory<DitherEffect>::getInstance();
}
@ -42,16 +44,13 @@ private:
// All dither effects are equal
virtual bool onIsEqual(const GrProcessor&) const SK_OVERRIDE { return true; }
virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE;
GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
typedef GrFragmentProcessor INHERITED;
};
void DitherEffect::onComputeInvariantOutput(InvariantOutput* inout) const {
inout->fValidFlags = 0;
inout->fIsSingleComponent = false;
void DitherEffect::getConstantColorComponents(GrColor* color, uint32_t* validFlags) const {
*validFlags = 0;
}
//////////////////////////////////////////////////////////////////////////////

12
src/gpu/effects/GrMatrixConvolutionEffect.h
View File

@ -52,6 +52,12 @@ public:
virtual ~GrMatrixConvolutionEffect();
virtual void getConstantColorComponents(GrColor* color,
uint32_t* validFlags) const SK_OVERRIDE {
// TODO: Try to do better?
*validFlags = 0;
}
static const char* Name() { return "MatrixConvolution"; }
const SkIRect& bounds() const { return fBounds; }
const SkISize& kernelSize() const { return fKernelSize; }
@ -79,12 +85,6 @@ private:
virtual bool onIsEqual(const GrProcessor&) const SK_OVERRIDE;
virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE {
// TODO: Try to do better?
inout->fValidFlags = 0;
inout->fIsSingleComponent = false;
}
SkIRect fBounds;
SkISize fKernelSize;
float fKernel[MAX_KERNEL_SIZE];

18
src/gpu/effects/GrOvalEffect.cpp
View File

@ -32,6 +32,8 @@ public:
typedef GLCircleEffect GLProcessor;
virtual void getConstantColorComponents(GrColor* color, uint32_t* validFlags) const SK_OVERRIDE;
virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
private:
@ -39,8 +41,6 @@ private:
virtual bool onIsEqual(const GrProcessor&) const SK_OVERRIDE;
virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE;
SkPoint fCenter;
SkScalar fRadius;
GrPrimitiveEdgeType fEdgeType;
@ -56,9 +56,8 @@ GrFragmentProcessor* CircleEffect::Create(GrPrimitiveEdgeType edgeType, const Sk
return SkNEW_ARGS(CircleEffect, (edgeType, center, radius));
}
void CircleEffect::onComputeInvariantOutput(InvariantOutput* inout) const {
inout->fValidFlags = 0;
inout->fIsSingleComponent = false;
void CircleEffect::getConstantColorComponents(GrColor* color, uint32_t* validFlags) const {
*validFlags = 0;
}
const GrBackendFragmentProcessorFactory& CircleEffect::getFactory() const {
@ -205,6 +204,8 @@ public:
typedef GLEllipseEffect GLProcessor;
virtual void getConstantColorComponents(GrColor* color, uint32_t* validFlags) const SK_OVERRIDE;
virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
private:
@ -212,8 +213,6 @@ private:
virtual bool onIsEqual(const GrProcessor&) const SK_OVERRIDE;
virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE;
SkPoint fCenter;
SkVector fRadii;
GrPrimitiveEdgeType fEdgeType;
@ -231,9 +230,8 @@ GrFragmentProcessor* EllipseEffect::Create(GrPrimitiveEdgeType edgeType,
return SkNEW_ARGS(EllipseEffect, (edgeType, center, rx, ry));
}
void EllipseEffect::onComputeInvariantOutput(InvariantOutput* inout) const {
inout->fValidFlags = 0;
inout->fIsSingleComponent = false;
void EllipseEffect::getConstantColorComponents(GrColor* color, uint32_t* validFlags) const {
*validFlags = 0;
}
const GrBackendFragmentProcessorFactory& EllipseEffect::getFactory() const {

18
src/gpu/effects/GrRRectEffect.cpp
View File

@ -59,6 +59,8 @@ public:
typedef GLCircularRRectEffect GLProcessor;
virtual void getConstantColorComponents(GrColor* color, uint32_t* validFlags) const SK_OVERRIDE;
virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
private:
@ -66,8 +68,6 @@ private:
virtual bool onIsEqual(const GrProcessor& other) const SK_OVERRIDE;
virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE;
SkRRect fRRect;
GrPrimitiveEdgeType fEdgeType;
uint32_t fCircularCornerFlags;
@ -86,9 +86,8 @@ GrFragmentProcessor* CircularRRectEffect::Create(GrPrimitiveEdgeType edgeType,
return SkNEW_ARGS(CircularRRectEffect, (edgeType, circularCornerFlags, rrect));
}
void CircularRRectEffect::onComputeInvariantOutput(InvariantOutput* inout) const {
inout->fValidFlags = 0;
inout->fIsSingleComponent = false;
void CircularRRectEffect::getConstantColorComponents(GrColor* color, uint32_t* validFlags) const {
*validFlags = 0;
}
const GrBackendFragmentProcessorFactory& CircularRRectEffect::getFactory() const {
@ -400,6 +399,8 @@ public:
typedef GLEllipticalRRectEffect GLProcessor;
virtual void getConstantColorComponents(GrColor* color, uint32_t* validFlags) const SK_OVERRIDE;
virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
private:
@ -407,8 +408,6 @@ private:
virtual bool onIsEqual(const GrProcessor& other) const SK_OVERRIDE;
virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE;
SkRRect fRRect;
GrPrimitiveEdgeType fEdgeType;
@ -425,9 +424,8 @@ EllipticalRRectEffect::Create(GrPrimitiveEdgeType edgeType, const SkRRect& rrect
return SkNEW_ARGS(EllipticalRRectEffect, (edgeType, rrect));
}
void EllipticalRRectEffect::onComputeInvariantOutput(InvariantOutput* inout) const {
inout->fValidFlags = 0;
inout->fIsSingleComponent = false;
void EllipticalRRectEffect::getConstantColorComponents(GrColor* color, uint32_t* validFlags) const {
*validFlags = 0;
}
const GrBackendFragmentProcessorFactory& EllipticalRRectEffect::getFactory() const {

5
src/gpu/effects/GrSimpleTextureEffect.cpp
View File

@ -41,9 +41,8 @@ private:
///////////////////////////////////////////////////////////////////////////////
void GrSimpleTextureEffect::onComputeInvariantOutput(InvariantOutput* inout) const {
this->updateInvariantOutputForModulation(inout);
inout->fIsSingleComponent = false;
void GrSimpleTextureEffect::getConstantColorComponents(GrColor* color, uint32_t* validFlags) const {
this->updateConstantColorComponentsForModulation(color, validFlags);
}
const GrBackendFragmentProcessorFactory& GrSimpleTextureEffect::getFactory() const {

4
src/gpu/effects/GrSimpleTextureEffect.h
View File

@ -49,6 +49,8 @@ public:
static const char* Name() { return "Texture"; }
virtual void getConstantColorComponents(GrColor* color, uint32_t* validFlags) const SK_OVERRIDE;
typedef GrGLSimpleTextureEffect GLProcessor;
virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
@ -73,8 +75,6 @@ private:
return this->hasSameTextureParamsMatrixAndSourceCoords(ste);
}
virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE;
GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
typedef GrSingleTextureEffect INHERITED;

11
src/gpu/effects/GrSingleTextureEffect.h
View File

@ -44,15 +44,16 @@ protected:
}
/**
* Can be used as a helper to implement subclass onComputeInvariantOutput(). It assumes that
* Can be used as a helper to implement subclass getConstantColorComponents(). It assumes that
* the subclass output color will be a modulation of the input color with a value read from the
* texture.
*/
void updateInvariantOutputForModulation(InvariantOutput* inout) const {
if (inout->isOpaque() && GrPixelConfigIsOpaque(this->texture(0)->config())) {
inout->fValidFlags = kA_GrColorComponentFlag;
void updateConstantColorComponentsForModulation(GrColor* color, uint32_t* validFlags) const {
if ((*validFlags & kA_GrColorComponentFlag) && 0xFF == GrColorUnpackA(*color) &&
GrPixelConfigIsOpaque(this->texture(0)->config())) {
*validFlags = kA_GrColorComponentFlag;
} else {
inout->fValidFlags = 0;
*validFlags = 0;
}
}

7
src/gpu/effects/GrTextureDomain.cpp
View File

@ -269,13 +269,12 @@ bool GrTextureDomainEffect::onIsEqual(const GrProcessor& sBase) const {
this->fTextureDomain == s.fTextureDomain;
}
void GrTextureDomainEffect::onComputeInvariantOutput(InvariantOutput* inout) const {
void GrTextureDomainEffect::getConstantColorComponents(GrColor* color, uint32_t* validFlags) const {
if (GrTextureDomain::kDecal_Mode == fTextureDomain.mode()) { // TODO: helper
inout->fValidFlags = 0;
*validFlags = 0;
} else {
this->updateInvariantOutputForModulation(inout);
this->updateConstantColorComponentsForModulation(color, validFlags);
}
inout->fIsSingleComponent = false;
}
///////////////////////////////////////////////////////////////////////////////

3
src/gpu/effects/GrTextureDomain.h
View File

@ -159,6 +159,7 @@ public:
typedef GrGLTextureDomainEffect GLProcessor;
virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
virtual void getConstantColorComponents(GrColor* color, uint32_t* validFlags) const SK_OVERRIDE;
const GrTextureDomain& textureDomain() const { return fTextureDomain; }
@ -175,8 +176,6 @@ private:
virtual bool onIsEqual(const GrProcessor&) const SK_OVERRIDE;
virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE;
GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
typedef GrSingleTextureEffect INHERITED;

14
src/gpu/effects/GrYUVtoRGBEffect.cpp
View File

@ -28,6 +28,13 @@ public:
return GrTBackendFragmentProcessorFactory<YUVtoRGBEffect>::getInstance();
}
virtual void getConstantColorComponents(GrColor* color,
uint32_t* validFlags) const SK_OVERRIDE {
// YUV is opaque
*color = 0xFF;
*validFlags = kA_GrColorComponentFlag;
}
SkYUVColorSpace getColorSpace() const {
return fColorSpace;
}
@ -110,13 +117,6 @@ private:
fColorSpace == s.getColorSpace();
}
virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE {
// YUV is opaque
inout->fColor = 0xFF;
inout->fValidFlags = kA_GrColorComponentFlag;
inout->fIsSingleComponent = false;
}
GrCoordTransform fCoordTransform;
GrTextureAccess fYAccess;
GrTextureAccess fUAccess;

12
tests/GpuColorFilterTest.cpp
View File

@ -99,14 +99,12 @@ static void test_getConstantColorComponents(skiatest::Reporter* reporter, GrCont
const GetConstantComponentTestCase& test = filterTests[i];
SkAutoTUnref<SkColorFilter> cf(SkColorFilter::CreateModeFilter(test.filterColor, test.filterMode));
SkAutoTUnref<GrFragmentProcessor> effect(cf->asFragmentProcessor(grContext));
GrProcessor::InvariantOutput inout;
inout.fColor = test.inputColor;
inout.fValidFlags = test.inputComponents;
inout.fIsSingleComponent = false;
effect->computeInvariantOutput(&inout);
GrColor color = test.inputColor;
uint32_t components = test.inputComponents;
effect->getConstantColorComponents(&color, &components);
REPORTER_ASSERT(reporter, filterColor(inout.fColor, inout.fValidFlags) == test.outputColor);
REPORTER_ASSERT(reporter, test.outputComponents == inout.fValidFlags);
REPORTER_ASSERT(reporter, filterColor(color, components) == test.outputColor);
REPORTER_ASSERT(reporter, test.outputComponents == components);
}
}