From b4b7a4c9ea2e399db550f93e3754c351e5b2079a Mon Sep 17 00:00:00 2001 From: robertphillips Date: Thu, 2 Oct 2014 12:12:48 -0700 Subject: [PATCH] Revert of Add isSingleComponent bool to getConstantColorComponent (patchset #6 id:100001 of https://codereview.chromium.org/608253002/) 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 --- include/gpu/GrProcessor.h | 49 ++----------- src/core/SkXfermode.cpp | 10 +-- src/effects/SkAlphaThresholdFilter.cpp | 14 ++-- src/effects/SkArithmeticMode.cpp | 9 ++- src/effects/SkBlurMaskFilter.cpp | 19 +++-- src/effects/SkColorFilters.cpp | 15 ++-- src/effects/SkColorMatrixFilter.cpp | 90 ++++++++++++------------ src/effects/SkDisplacementMapEffect.cpp | 10 +-- src/effects/SkLightingImageFilter.cpp | 12 ++-- src/effects/SkLumaColorFilter.cpp | 14 ++-- src/effects/SkMagnifierImageFilter.cpp | 9 ++- src/effects/SkMorphologyImageFilter.cpp | 8 +-- src/effects/SkPerlinNoiseShader.cpp | 9 ++- src/effects/SkTableColorFilter.cpp | 17 +++-- src/effects/gradients/SkGradientShader.cpp | 9 ++- src/effects/gradients/SkGradientShaderPriv.h | 4 +- src/gpu/GrAAConvexPathRenderer.cpp | 10 +-- src/gpu/GrAARectRenderer.cpp | 20 +++--- src/gpu/GrDrawState.cpp | 55 ++++++++------- src/gpu/GrOptDrawState.cpp | 23 +++--- src/gpu/GrOvalRenderer.cpp | 30 ++++---- src/gpu/GrPaint.cpp | 24 +++---- src/gpu/GrProcessor.cpp | 42 ----------- src/gpu/effects/GrBezierEffect.h | 30 ++++---- src/gpu/effects/GrBicubicEffect.cpp | 5 +- src/gpu/effects/GrBicubicEffect.h | 3 +- src/gpu/effects/GrConfigConversionEffect.cpp | 6 +- src/gpu/effects/GrConfigConversionEffect.h | 4 +- src/gpu/effects/GrConvexPolyEffect.cpp | 27 ++++--- src/gpu/effects/GrConvexPolyEffect.h | 4 +- src/gpu/effects/GrConvolutionEffect.h | 13 ++-- src/gpu/effects/GrCustomCoordsTextureEffect.cpp | 11 +-- src/gpu/effects/GrCustomCoordsTextureEffect.h | 4 +- src/gpu/effects/GrDashingEffect.cpp | 18 +++-- src/gpu/effects/GrDistanceFieldTextureEffect.cpp | 24 +++---- src/gpu/effects/GrDistanceFieldTextureEffect.h | 7 +- src/gpu/effects/GrDitherEffect.cpp | 9 ++- src/gpu/effects/GrMatrixConvolutionEffect.h | 12 ++-- src/gpu/effects/GrOvalEffect.cpp | 18 +++-- src/gpu/effects/GrRRectEffect.cpp | 18 +++-- src/gpu/effects/GrSimpleTextureEffect.cpp | 5 +- src/gpu/effects/GrSimpleTextureEffect.h | 4 +- src/gpu/effects/GrSingleTextureEffect.h | 11 +-- src/gpu/effects/GrTextureDomain.cpp | 7 +- src/gpu/effects/GrTextureDomain.h | 3 +- src/gpu/effects/GrYUVtoRGBEffect.cpp | 14 ++-- tests/GpuColorFilterTest.cpp | 14 ++-- 47 files changed, 332 insertions(+), 441 deletions(-) diff --git a/include/gpu/GrProcessor.h b/include/gpu/GrProcessor.h index b309d2d..7053872 100644 --- a/include/gpu/GrProcessor.h +++ b/include/gpu/GrProcessor.h @@ -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; diff --git a/src/core/SkXfermode.cpp b/src/core/SkXfermode.cpp index 1d151e4..8a3218f 100644 --- a/src/core/SkXfermode.cpp +++ b/src/core/SkXfermode.cpp @@ -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::getInstance(); } @@ -1211,11 +1216,6 @@ private: return fMode == s.fMode && fBackgroundAccess.getTexture() == s.fBackgroundAccess.getTexture(); } - - virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE { - inout->fValidFlags = 0; - inout->fIsSingleComponent = false; - } SkXfermode::Mode fMode; GrCoordTransform fBackgroundTransform; diff --git a/src/effects/SkAlphaThresholdFilter.cpp b/src/effects/SkAlphaThresholdFilter.cpp index 462cfec..09cc618 100644 --- a/src/effects/SkAlphaThresholdFilter.cpp +++ b/src/effects/SkAlphaThresholdFilter.cpp @@ -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 diff --git a/src/effects/SkArithmeticMode.cpp b/src/effects/SkArithmeticMode.cpp index b62b33d..85af19c 100644 --- a/src/effects/SkArithmeticMode.cpp +++ b/src/effects/SkArithmeticMode.cpp @@ -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::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; } /////////////////////////////////////////////////////////////////////////////// diff --git a/src/effects/SkBlurMaskFilter.cpp b/src/effects/SkBlurMaskFilter.cpp index 251398c..123b9d2 100644 --- a/src/effects/SkBlurMaskFilter.cpp +++ b/src/effects/SkBlurMaskFilter.cpp @@ -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 { diff --git a/src/effects/SkColorFilters.cpp b/src/effects/SkColorFilters.cpp index ba62817..bd0d2aa 100644 --- a/src/effects/SkColorFilters.cpp +++ b/src/effects/SkColorFilters.cpp @@ -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); diff --git a/src/effects/SkColorMatrixFilter.cpp b/src/effects/SkColorMatrixFilter.cpp index 8549fd7..5ac4552 100644 --- a/src/effects/SkColorMatrixFilter.cpp +++ b/src/effects/SkColorMatrixFilter.cpp @@ -349,6 +349,51 @@ public: return GrTBackendFragmentProcessorFactory::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(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(SkScalarPin(outputA, 0, 255)) << GrColor_SHIFT_A; - inout->fIsSingleComponent = false; - } - SkColorMatrix fMatrix; typedef GrFragmentProcessor INHERITED; diff --git a/src/effects/SkDisplacementMapEffect.cpp b/src/effects/SkDisplacementMapEffect.cpp index ace9e02..474d9a7 100644 --- a/src/effects/SkDisplacementMapEffect.cpp +++ b/src/effects/SkDisplacementMapEffect.cpp @@ -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::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; } /////////////////////////////////////////////////////////////////////////////// diff --git a/src/effects/SkLightingImageFilter.cpp b/src/effects/SkLightingImageFilter.cpp index ce787c6..f766562 100644 --- a/src/effects/SkLightingImageFilter.cpp +++ b/src/effects/SkLightingImageFilter.cpp @@ -350,15 +350,15 @@ public: SkScalar surfaceScale() const { return fSurfaceScale; } const SkMatrix& filterMatrix() const { return fFilterMatrix; } -protected: - virtual bool onIsEqual(const GrProcessor&) const SK_OVERRIDE; - - virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE { + virtual void getConstantColorComponents(GrColor* color, + uint32_t* validFlags) const SK_OVERRIDE { // lighting shaders are complicated. We just throw up our hands. - inout->fValidFlags = 0; - inout->fIsSingleComponent = false; + *validFlags = 0; } +protected: + virtual bool onIsEqual(const GrProcessor&) const SK_OVERRIDE; + private: typedef GrSingleTextureEffect INHERITED; const SkLight* fLight; diff --git a/src/effects/SkLumaColorFilter.cpp b/src/effects/SkLumaColorFilter.cpp index 616bcde..ee2bfa6 100644 --- a/src/effects/SkLumaColorFilter.cpp +++ b/src/effects/SkLumaColorFilter.cpp @@ -73,6 +73,13 @@ public: return GrTBackendFragmentProcessorFactory::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 { diff --git a/src/effects/SkMagnifierImageFilter.cpp b/src/effects/SkMagnifierImageFilter.cpp index d6a8e78..9d7b918 100644 --- a/src/effects/SkMagnifierImageFilter.cpp +++ b/src/effects/SkMagnifierImageFilter.cpp @@ -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 diff --git a/src/effects/SkMorphologyImageFilter.cpp b/src/effects/SkMorphologyImageFilter.cpp index 4c7f624..397e431 100644 --- a/src/effects/SkMorphologyImageFilter.cpp +++ b/src/effects/SkMorphologyImageFilter.cpp @@ -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); } /////////////////////////////////////////////////////////////////////////////// diff --git a/src/effects/SkPerlinNoiseShader.cpp b/src/effects/SkPerlinNoiseShader.cpp index 43197de..88e6cad 100644 --- a/src/effects/SkPerlinNoiseShader.cpp +++ b/src/effects/SkPerlinNoiseShader.cpp @@ -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; }; diff --git a/src/effects/SkTableColorFilter.cpp b/src/effects/SkTableColorFilter.cpp index f6726ca..4853f73 100644 --- a/src/effects/SkTableColorFilter.cpp +++ b/src/effects/SkTableColorFilter.cpp @@ -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; } diff --git a/src/effects/gradients/SkGradientShader.cpp b/src/effects/gradients/SkGradientShader.cpp index 89b323a..d25873b 100644 --- a/src/effects/gradients/SkGradientShader.cpp +++ b/src/effects/gradients/SkGradientShader.cpp @@ -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, diff --git a/src/effects/gradients/SkGradientShaderPriv.h b/src/effects/gradients/SkGradientShaderPriv.h index 33d8add..b81b562 100644 --- a/src/effects/gradients/SkGradientShaderPriv.h +++ b/src/effects/gradients/SkGradientShaderPriv.h @@ -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: diff --git a/src/gpu/GrAAConvexPathRenderer.cpp b/src/gpu/GrAAConvexPathRenderer.cpp index 1aa90c3..dc74459 100644 --- a/src/gpu/GrAAConvexPathRenderer.cpp +++ b/src/gpu/GrAAConvexPathRenderer.cpp @@ -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; diff --git a/src/gpu/GrAARectRenderer.cpp b/src/gpu/GrAARectRenderer.cpp index 0b895d1..5720982 100644 --- a/src/gpu/GrAARectRenderer.cpp +++ b/src/gpu/GrAARectRenderer.cpp @@ -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; diff --git a/src/gpu/GrDrawState.cpp b/src/gpu/GrDrawState.cpp index b4cf9c8..872d20a 100644 --- a/src/gpu/GrDrawState.cpp +++ b/src/gpu/GrDrawState.cpp @@ -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); } diff --git a/src/gpu/GrOptDrawState.cpp b/src/gpu/GrOptDrawState.cpp index 6a79203..98a5689 100644 --- a/src/gpu/GrOptDrawState.cpp +++ b/src/gpu/GrOptDrawState.cpp @@ -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); } diff --git a/src/gpu/GrOvalRenderer.cpp b/src/gpu/GrOvalRenderer.cpp index 7a84f80..4ae0ebc 100644 --- a/src/gpu/GrOvalRenderer.cpp +++ b/src/gpu/GrOvalRenderer.cpp @@ -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::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::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; diff --git a/src/gpu/GrPaint.cpp b/src/gpu/GrPaint.cpp index ffde5f9..84fdf42 100644 --- a/src/gpu/GrPaint.cpp +++ b/src/gpu/GrPaint.cpp @@ -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 diff --git a/src/gpu/GrProcessor.cpp b/src/gpu/GrProcessor.cpp index 26e0053..45298b5 100644 --- a/src/gpu/GrProcessor.cpp +++ b/src/gpu/GrProcessor.cpp @@ -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 - diff --git a/src/gpu/effects/GrBezierEffect.h b/src/gpu/effects/GrBezierEffect.h index 4631a2c..cb79ac3 100644 --- a/src/gpu/effects/GrBezierEffect.h +++ b/src/gpu/effects/GrBezierEffect.h @@ -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; diff --git a/src/gpu/effects/GrBicubicEffect.cpp b/src/gpu/effects/GrBicubicEffect.cpp index f5cc9d1..d73e604 100644 --- a/src/gpu/effects/GrBicubicEffect.cpp +++ b/src/gpu/effects/GrBicubicEffect.cpp @@ -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; } diff --git a/src/gpu/effects/GrBicubicEffect.h b/src/gpu/effects/GrBicubicEffect.h index e36aa8d..03476da 100644 --- a/src/gpu/effects/GrBicubicEffect.h +++ b/src/gpu/effects/GrBicubicEffect.h @@ -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; diff --git a/src/gpu/effects/GrConfigConversionEffect.cpp b/src/gpu/effects/GrConfigConversionEffect.cpp index f60be2a..3042d86 100644 --- a/src/gpu/effects/GrConfigConversionEffect.cpp +++ b/src/gpu/effects/GrConfigConversionEffect.cpp @@ -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); } /////////////////////////////////////////////////////////////////////////////// diff --git a/src/gpu/effects/GrConfigConversionEffect.h b/src/gpu/effects/GrConfigConversionEffect.h index aa2c874..765e49b 100644 --- a/src/gpu/effects/GrConfigConversionEffect.h +++ b/src/gpu/effects/GrConfigConversionEffect.h @@ -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; diff --git a/src/gpu/effects/GrConvexPolyEffect.cpp b/src/gpu/effects/GrConvexPolyEffect.cpp index 836596a..4857a9e 100644 --- a/src/gpu/effects/GrConvexPolyEffect.cpp +++ b/src/gpu/effects/GrConvexPolyEffect.cpp @@ -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 { diff --git a/src/gpu/effects/GrConvexPolyEffect.h b/src/gpu/effects/GrConvexPolyEffect.h index 7f76f79..e474939 100644 --- a/src/gpu/effects/GrConvexPolyEffect.h +++ b/src/gpu/effects/GrConvexPolyEffect.h @@ -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]; diff --git a/src/gpu/effects/GrConvolutionEffect.h b/src/gpu/effects/GrConvolutionEffect.h index f61f378..f2a2d5a 100644 --- a/src/gpu/effects/GrConvolutionEffect.h +++ b/src/gpu/effects/GrConvolutionEffect.h @@ -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; diff --git a/src/gpu/effects/GrCustomCoordsTextureEffect.cpp b/src/gpu/effects/GrCustomCoordsTextureEffect.cpp index 7362ba9..b9794c1 100644 --- a/src/gpu/effects/GrCustomCoordsTextureEffect.cpp +++ b/src/gpu/effects/GrCustomCoordsTextureEffect.cpp @@ -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 { diff --git a/src/gpu/effects/GrCustomCoordsTextureEffect.h b/src/gpu/effects/GrCustomCoordsTextureEffect.h index 0a6af7d..f48a144 100644 --- a/src/gpu/effects/GrCustomCoordsTextureEffect.h +++ b/src/gpu/effects/GrCustomCoordsTextureEffect.h @@ -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; diff --git a/src/gpu/effects/GrDashingEffect.cpp b/src/gpu/effects/GrDashingEffect.cpp index 4df1f02..704a6ac 100644 --- a/src/gpu/effects/GrDashingEffect.cpp +++ b/src/gpu/effects/GrDashingEffect.cpp @@ -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 { diff --git a/src/gpu/effects/GrDistanceFieldTextureEffect.cpp b/src/gpu/effects/GrDistanceFieldTextureEffect.cpp index 245a035..d5d3348 100755 --- a/src/gpu/effects/GrDistanceFieldTextureEffect.cpp +++ b/src/gpu/effects/GrDistanceFieldTextureEffect.cpp @@ -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 { diff --git a/src/gpu/effects/GrDistanceFieldTextureEffect.h b/src/gpu/effects/GrDistanceFieldTextureEffect.h index efd622e..b8d774d 100644 --- a/src/gpu/effects/GrDistanceFieldTextureEffect.h +++ b/src/gpu/effects/GrDistanceFieldTextureEffect.h @@ -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; diff --git a/src/gpu/effects/GrDitherEffect.cpp b/src/gpu/effects/GrDitherEffect.cpp index e7f90ac..fe7447d 100644 --- a/src/gpu/effects/GrDitherEffect.cpp +++ b/src/gpu/effects/GrDitherEffect.cpp @@ -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::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; } ////////////////////////////////////////////////////////////////////////////// diff --git a/src/gpu/effects/GrMatrixConvolutionEffect.h b/src/gpu/effects/GrMatrixConvolutionEffect.h index 4d76f4c..4cc4296 100644 --- a/src/gpu/effects/GrMatrixConvolutionEffect.h +++ b/src/gpu/effects/GrMatrixConvolutionEffect.h @@ -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]; diff --git a/src/gpu/effects/GrOvalEffect.cpp b/src/gpu/effects/GrOvalEffect.cpp index 2a04e16..10fd8a6 100644 --- a/src/gpu/effects/GrOvalEffect.cpp +++ b/src/gpu/effects/GrOvalEffect.cpp @@ -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 { diff --git a/src/gpu/effects/GrRRectEffect.cpp b/src/gpu/effects/GrRRectEffect.cpp index 0af564c..f5131fe 100644 --- a/src/gpu/effects/GrRRectEffect.cpp +++ b/src/gpu/effects/GrRRectEffect.cpp @@ -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 { diff --git a/src/gpu/effects/GrSimpleTextureEffect.cpp b/src/gpu/effects/GrSimpleTextureEffect.cpp index a7707da..6743ddb 100644 --- a/src/gpu/effects/GrSimpleTextureEffect.cpp +++ b/src/gpu/effects/GrSimpleTextureEffect.cpp @@ -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 { diff --git a/src/gpu/effects/GrSimpleTextureEffect.h b/src/gpu/effects/GrSimpleTextureEffect.h index 88c5ca2..dc9cf85 100644 --- a/src/gpu/effects/GrSimpleTextureEffect.h +++ b/src/gpu/effects/GrSimpleTextureEffect.h @@ -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; diff --git a/src/gpu/effects/GrSingleTextureEffect.h b/src/gpu/effects/GrSingleTextureEffect.h index cba322e..6349ee7 100644 --- a/src/gpu/effects/GrSingleTextureEffect.h +++ b/src/gpu/effects/GrSingleTextureEffect.h @@ -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; } } diff --git a/src/gpu/effects/GrTextureDomain.cpp b/src/gpu/effects/GrTextureDomain.cpp index 90e3b41..1d3b37d 100644 --- a/src/gpu/effects/GrTextureDomain.cpp +++ b/src/gpu/effects/GrTextureDomain.cpp @@ -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; } /////////////////////////////////////////////////////////////////////////////// diff --git a/src/gpu/effects/GrTextureDomain.h b/src/gpu/effects/GrTextureDomain.h index ec86847..5751bad 100644 --- a/src/gpu/effects/GrTextureDomain.h +++ b/src/gpu/effects/GrTextureDomain.h @@ -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; diff --git a/src/gpu/effects/GrYUVtoRGBEffect.cpp b/src/gpu/effects/GrYUVtoRGBEffect.cpp index cdbe654..436106c 100644 --- a/src/gpu/effects/GrYUVtoRGBEffect.cpp +++ b/src/gpu/effects/GrYUVtoRGBEffect.cpp @@ -28,6 +28,13 @@ public: return GrTBackendFragmentProcessorFactory::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; diff --git a/tests/GpuColorFilterTest.cpp b/tests/GpuColorFilterTest.cpp index a61fe0b..202756b 100644 --- a/tests/GpuColorFilterTest.cpp +++ b/tests/GpuColorFilterTest.cpp @@ -99,14 +99,12 @@ static void test_getConstantColorComponents(skiatest::Reporter* reporter, GrCont const GetConstantComponentTestCase& test = filterTests[i]; SkAutoTUnref cf(SkColorFilter::CreateModeFilter(test.filterColor, test.filterMode)); SkAutoTUnref effect(cf->asFragmentProcessor(grContext)); - GrProcessor::InvariantOutput inout; - inout.fColor = test.inputColor; - inout.fValidFlags = test.inputComponents; - inout.fIsSingleComponent = false; - effect->computeInvariantOutput(&inout); - - REPORTER_ASSERT(reporter, filterColor(inout.fColor, inout.fValidFlags) == test.outputColor); - REPORTER_ASSERT(reporter, test.outputComponents == inout.fValidFlags); + GrColor color = test.inputColor; + uint32_t components = test.inputComponents; + effect->getConstantColorComponents(&color, &components); + + REPORTER_ASSERT(reporter, filterColor(color, components) == test.outputColor); + REPORTER_ASSERT(reporter, test.outputComponents == components); } } -- 2.7.4