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

Revert "Start of rewrite of GrFragmentProcessor optimizations."

Browse Source 
This reverts commit 85eb4226a4.

Reason for revert: test failures on Windows, e.g. https://chromium-swarm.appspot.com/task?id=33f9527484414110&refresh=10

Original change's description:
> Start of rewrite of GrFragmentProcessor optimizations.
> 
> This adds a replacement for computeInvariantOutput buts does not use it yet. The replacement allows for three types of optimizations:
> 
> * known input color -> known output color for GrFP elimination
> * tracking of whether all color processors modulate their input for the "tweak alpha" optimziation
> * opaqueness tracking
> 
> This loses some of the generality of computInvariantOutput. It does not track the known output status of individual color components (other than opaque alpha). It does not track whether GrFragmentProcessors read their input color. It doesn't allow a processor that will receive non-constant output to advertise that it produces a constant output. These could probably be added back in the unlikely case that they prove valuable.
> 
> Unlike computeInvariantOutput the optimizations are decided at instantiation time and constant colors are expressed as GrColor4f rather than GrColor.
> 
> Change-Id: I684d3f9050693dde2d28154fa695e049ed8cf61a
> Reviewed-on: https://skia-review.googlesource.com/7481
> Reviewed-by: Greg Daniel <egdaniel@google.com>
> Commit-Queue: Brian Salomon <bsalomon@google.com>
> 

TBR=egdaniel@google.com,bsalomon@google.com,brianosman@google.com
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true

Change-Id: I2390df257456013fa74137cb5d7b5a93820c291e
Reviewed-on: https://skia-review.googlesource.com/7652
Commit-Queue: Ethan Nicholas <ethannicholas@google.com>
Reviewed-by: Ethan Nicholas <ethannicholas@google.com>
This commit is contained in:
Ethan Nicholas 2017-01-27 15:34:34 +00:00 committed by Skia Commit-Bot
parent 85eb4226a4
commit 052fd5158f
58 changed files with 336 additions and 849 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
experimental/SkPerlinNoiseShader2/SkPerlinNoiseShader2.cpp
View File

@ -675,17 +675,17 @@ private:
inout->setToUnknown();
}
GrPerlinNoise2Effect(SkPerlinNoiseShader2::Type type, int numOctaves, bool stitchTiles,
SkPerlinNoiseShader2::PaintingData* paintingData,
GrTexture* permutationsTexture, GrTexture* noiseTexture,
const SkMatrix& matrix)
: INHERITED(kNone_OptimizationFlags)
, fType(type)
, fNumOctaves(numOctaves)
, fStitchTiles(stitchTiles)
, fPermutationsSampler(permutationsTexture)
, fNoiseSampler(noiseTexture)
, fPaintingData(paintingData) {
GrPerlinNoise2Effect(SkPerlinNoiseShader2::Type type,
int numOctaves, bool stitchTiles,
SkPerlinNoiseShader2::PaintingData* paintingData,
GrTexture* permutationsTexture, GrTexture* noiseTexture,
const SkMatrix& matrix)
: fType(type)
, fNumOctaves(numOctaves)
, fStitchTiles(stitchTiles)
, fPermutationsSampler(permutationsTexture)
, fNoiseSampler(noiseTexture)
, fPaintingData(paintingData) {
this->initClassID<GrPerlinNoise2Effect>();
this->addTextureSampler(&fPermutationsSampler);
this->addTextureSampler(&fNoiseSampler);
@ -703,6 +703,7 @@ private:
TextureSampler fNoiseSampler;
SkPerlinNoiseShader2::PaintingData* fPaintingData;
private:
typedef GrFragmentProcessor INHERITED;
};
@ -1086,16 +1087,15 @@ private:
inout->setToUnknown();
}
GrImprovedPerlinNoiseEffect(int octaves, SkScalar z,
GrImprovedPerlinNoiseEffect(int octaves, SkScalar z,
SkPerlinNoiseShader2::PaintingData* paintingData,
GrTexture* permutationsTexture, GrTexture* gradientTexture,
const SkMatrix& matrix)
: INHERITED(kNone_OptimizationFlags)
, fOctaves(octaves)
, fZ(z)
, fPermutationsSampler(permutationsTexture)
, fGradientSampler(gradientTexture)
, fPaintingData(paintingData) {
: fOctaves(octaves)
, fZ(z)
, fPermutationsSampler(permutationsTexture)
, fGradientSampler(gradientTexture)
, fPaintingData(paintingData) {
this->initClassID<GrImprovedPerlinNoiseEffect>();
this->addTextureSampler(&fPermutationsSampler);
this->addTextureSampler(&fGradientSampler);
@ -1112,6 +1112,7 @@ private:
TextureSampler fGradientSampler;
SkPerlinNoiseShader2::PaintingData* fPaintingData;
private:
typedef GrFragmentProcessor INHERITED;
};

15
include/gpu/GrColor.h
View File

@ -213,17 +213,6 @@ struct GrColor4f {
return GrColor4f(color.fR, color.fG, color.fB, color.fA);
}
GrColor4f modulate(const GrColor4f& x) const {
return GrColor4f(fRGBA[0] * x.fRGBA[0],
fRGBA[1] * x.fRGBA[1],
fRGBA[2] * x.fRGBA[2],
fRGBA[3] * x.fRGBA[3]);
}
GrColor4f mulByScalar(float x) const {
return GrColor4f(fRGBA[0] * x, fRGBA[1] * x, fRGBA[2] * x, fRGBA[3] * x);
}
bool operator==(const GrColor4f& other) const {
return
fRGBA[0] == other.fRGBA[0] &&
@ -251,10 +240,6 @@ struct GrColor4f {
return GrColor4f(fRGBA[0], fRGBA[1], fRGBA[2], 1.0f);
}
bool isOpaque() const {
return fRGBA[3] >= 1.f; // just in case precision causes a superopaque value.
}
GrColor4f premul() const {
float a = fRGBA[3];
return GrColor4f(fRGBA[0] * a, fRGBA[1] * a, fRGBA[2] * a, a);

93
include/gpu/GrFragmentProcessor.h
View File

@ -64,6 +64,11 @@ public:
*/
static sk_sp<GrFragmentProcessor> RunInSeries(sk_sp<GrFragmentProcessor>*, int cnt);
GrFragmentProcessor()
: INHERITED()
, fUsesDistanceVectorField(false)
, fUsesLocalCoords(false) {}
~GrFragmentProcessor() override;
GrGLSLFragmentProcessor* createGLSLInstance() const;
@ -90,42 +95,10 @@ public:
const GrFragmentProcessor& childProcessor(int index) const { return *fChildProcessors[index]; }
/** Do any of the coordtransforms for this processor require local coords? */
bool usesLocalCoords() const { return SkToBool(fFlags & kUsesLocalCoords_Flag); }
bool usesLocalCoords() const { return fUsesLocalCoords; }
/** Does this FP need a vector to the nearest edge? */
bool usesDistanceVectorField() const {
return SkToBool(fFlags & kUsesDistanceVectorField_Flag);
}
/**
* True if the processor's output is a modulation of its input color or alpha with a computed
* color or alpha in the 0..1 range. If true and the blend mode allows it we may fold coverage
* into the first color fragment processor's input.
*/
bool modulatesInput() const { return SkToBool(fFlags & kModulatesInput_OptimizationFlag); }
/**
* If this is true then all opaque input colors to the processor produce opaque output colors.
*/
bool preservesOpaqueInput() const {
return SkToBool(fFlags & kPreservesOpaqueInput_OptimizationFlag);
}
/**
* Tests whether given a constant input color the processor produces a constant output color
* (for all fragments). If true outputColor will contain the constant color produces for
* inputColor.
*/
bool hasConstantOutputForConstantInput(GrColor4f inputColor, GrColor4f* outputColor) const {
if (fFlags & kConstantOutputForConstantInput_OptimizationFlag) {
*outputColor = this->constantOutputForConstantInput(inputColor);
return true;
}
return false;
}
bool hasConstantOutputForConstantInput() const {
return SkToBool(fFlags & kConstantOutputForConstantInput_OptimizationFlag);
}
bool usesDistanceVectorField() const { return fUsesDistanceVectorField; }
/** Returns true if this and other processor conservatively draw identically. It can only return
true when the two processor are of the same subclass (i.e. they return the same object from
@ -216,36 +189,6 @@ public:
&GrProcessor::textureSampler>;
protected:
enum OptimizationFlags : uint32_t {
kNone_OptimizationFlags,
kModulatesInput_OptimizationFlag = 0x1,
kPreservesOpaqueInput_OptimizationFlag = 0x2,
kConstantOutputForConstantInput_OptimizationFlag = 0x4,
kAll_OptimizationFlags = kModulatesInput_OptimizationFlag |
kPreservesOpaqueInput_OptimizationFlag |
kConstantOutputForConstantInput_OptimizationFlag
};
GR_DECL_BITFIELD_OPS_FRIENDS(OptimizationFlags)
GrFragmentProcessor(OptimizationFlags optimizationFlags) : fFlags(optimizationFlags) {
SkASSERT((fFlags & ~kAll_OptimizationFlags) == 0);
}
OptimizationFlags optimizationFlags() const {
return static_cast<OptimizationFlags>(kAll_OptimizationFlags & fFlags);
}
/**
* This allows one subclass to access another subclass's implementation of
* constantOutputForConstantInput. It must only be called when
* hasConstantOutputForConstantInput() is known to be true.
*/
static GrColor4f ConstantOutputForConstantInput(const GrFragmentProcessor& fp,
GrColor4f input) {
SkASSERT(fp.hasConstantOutputForConstantInput());
return fp.constantOutputForConstantInput(input);
}
/**
* Fragment Processor subclasses call this from their constructor to register coordinate
* transformations. Coord transforms provide a mechanism for a processor to receive coordinates
@ -284,20 +227,14 @@ protected:
*/
virtual void onComputeInvariantOutput(GrInvariantOutput* inout) const = 0;
/**
* Sub-classes should call this in their constructors if they need access to a distance
/* Sub-classes should set this to true in their constructors if they need access to a distance
* vector field to the nearest edge
*/
void setWillUseDistanceVectorField() { fFlags |= kUsesDistanceVectorField_Flag; }
bool fUsesDistanceVectorField;
private:
void notifyRefCntIsZero() const final;
virtual GrColor4f constantOutputForConstantInput(GrColor4f /* inputColor */) const {
SkFAIL("Subclass must override this if advertising this optimization.");
return GrColor4f::TransparentBlack();
}
/** Returns a new instance of the appropriate *GL* implementation class
for the given GrFragmentProcessor; caller is responsible for deleting
the object. */
@ -316,13 +253,7 @@ private:
bool hasSameTransforms(const GrFragmentProcessor&) const;
enum PrivateFlags {
kFirstPrivateFlag = kAll_OptimizationFlags + 1,
kUsesLocalCoords_Flag = kFirstPrivateFlag,
kUsesDistanceVectorField_Flag = kFirstPrivateFlag << 1,
};
mutable uint32_t fFlags = 0;
bool fUsesLocalCoords;
SkSTArray<4, const GrCoordTransform*, true> fCoordTransforms;
@ -330,11 +261,9 @@ private:
* This is not SkSTArray<1, sk_sp<GrFragmentProcessor>> because this class holds strong
* references until notifyRefCntIsZero and then it holds pending executions.
*/
SkSTArray<1, GrFragmentProcessor*, true> fChildProcessors;
SkSTArray<1, GrFragmentProcessor*, true> fChildProcessors;
typedef GrProcessor INHERITED;
};
GR_MAKE_BITFIELD_OPS(GrFragmentProcessor::OptimizationFlags)
#endif

6
include/gpu/GrProcessorUnitTest.h
View File

@ -46,8 +46,10 @@ struct GrProcessorTestData {
GrProcessorTestData(SkRandom* random,
GrContext* context,
const GrRenderTargetContext* renderTargetContext,
GrTexture* const textures[2])
: fRandom(random), fContext(context), fRenderTargetContext(renderTargetContext) {
GrTexture* textures[2])
: fRandom(random)
, fContext(context)
, fRenderTargetContext(renderTargetContext) {
fTextures[0] = textures[0];
fTextures[1] = textures[1];

43
include/gpu/GrTypes.h
View File

@ -19,59 +19,56 @@
* bitfield.
*/
#define GR_MAKE_BITFIELD_OPS(X) \
inline X operator |(X a, X b) { \
inline X operator | (X a, X b) { \
return (X) (+a | +b); \
} \
inline X& operator |=(X& a, X b) { \
inline X& operator |= (X& a, X b) { \
return (a = a | b); \
} \
inline X operator &(X a, X b) { \
return (X) (+a & +b); \
} \
inline X& operator &=(X& a, X b) { \
return (a = a & b); \
} \
template <typename T> \
inline X operator &(T a, X b) { \
\
inline X operator & (X a, X b) { \
return (X) (+a & +b); \
} \
template <typename T> \
inline X operator &(X a, T b) { \
inline X operator & (T a, X b) { \
return (X) (+a & +b); \
} \
template <typename T> \
inline X operator & (X a, T b) { \
return (X) (+a & +b); \
} \
#define GR_DECL_BITFIELD_OPS_FRIENDS(X) \
friend X operator |(X a, X b); \
friend X& operator |=(X& a, X b); \
friend X operator | (X a, X b); \
friend X& operator |= (X& a, X b); \
\
friend X operator &(X a, X b); \
friend X& operator &=(X& a, X b); \
friend X operator & (X a, X b); \
\
template <typename T> \
friend X operator &(T a, X b); \
friend X operator & (T a, X b); \
\
template <typename T> \
friend X operator &(X a, T b); \
friend X operator & (X a, T b); \
/**
* Defines bitwise operators that make it possible to use an enum class as a
* very basic bitfield.
*/
#define GR_MAKE_BITFIELD_CLASS_OPS(X) \
inline X operator |(X a, X b) { \
inline X operator | (X a, X b) { \
return (X) ((int)a | (int)b); \
} \
inline X& operator |=(X& a, X b) { \
inline X& operator |= (X& a, X b) { \
return (a = a | b); \
} \
inline bool operator &(X a, X b) { \
inline bool operator & (X a, X b) { \
return SkToBool((int)a & (int)b); \
}
#define GR_DECL_BITFIELD_CLASS_OPS_FRIENDS(X) \
friend X operator |(X a, X b); \
friend X& operator |=(X& a, X b); \
friend bool operator &(X a, X b);
friend X operator | (X a, X b); \
friend X& operator |= (X& a, X b); \
friend bool operator & (X a, X b);
////////////////////////////////////////////////////////////////////////////////

15
include/gpu/effects/GrConstColorProcessor.h
View File

@ -43,19 +43,7 @@ public:
InputMode inputMode() const { return fMode; }
private:
static OptimizationFlags OptFlags(GrColor4f color, InputMode mode) {
OptimizationFlags flags = kConstantOutputForConstantInput_OptimizationFlag;
if (mode != kIgnore_InputMode) {
flags |= kModulatesInput_OptimizationFlag;
}
if (color.isOpaque()) {
flags |= kPreservesOpaqueInput_OptimizationFlag;
}
return flags;
}
GrConstColorProcessor(GrColor4f color, InputMode mode)
: INHERITED(OptFlags(color, mode)), fColor(color), fMode(mode) {
GrConstColorProcessor(GrColor4f color, InputMode mode) : fColor(color), fMode(mode) {
this->initClassID<GrConstColorProcessor>();
}
@ -66,7 +54,6 @@ private:
bool onIsEqual(const GrFragmentProcessor&) const override;
void onComputeInvariantOutput(GrInvariantOutput* inout) const override;
GrColor4f constantOutputForConstantInput(GrColor4f input) const override;
GR_DECLARE_FRAGMENT_PROCESSOR_TEST;

5
src/core/SkColorMatrixFilterRowMajor255.cpp
View File

@ -345,10 +345,9 @@ public:
typedef GrGLSLFragmentProcessor INHERITED;
};
private:
// We could implement the constant input->constant output optimization but haven't. Other
// optimizations would be matrix-dependent.
ColorMatrixEffect(const SkScalar matrix[20]) : INHERITED(kNone_OptimizationFlags) {
ColorMatrixEffect(const SkScalar matrix[20]) {
memcpy(fMatrix, matrix, sizeof(SkScalar) * 20);
this->initClassID<ColorMatrixEffect>();
}

6
src/core/SkLightingShader.cpp
View File

@ -117,8 +117,8 @@ private:
// premul'd.
class LightingFP : public GrFragmentProcessor {
public:
LightingFP(sk_sp<GrFragmentProcessor> normalFP, sk_sp<SkLights> lights)
: INHERITED(kPreservesOpaqueInput_OptimizationFlag) {
LightingFP(sk_sp<GrFragmentProcessor> normalFP, sk_sp<SkLights> lights) {
// fuse all ambient lights into a single one
fAmbientColor = lights->ambientLightColor();
for (int i = 0; i < lights->numLights(); ++i) {
@ -263,8 +263,6 @@ private:
SkTArray<SkLights::Light> fDirectionalLights;
SkColor3f fAmbientColor;
typedef GrFragmentProcessor INHERITED;
};
////////////////////////////////////////////////////////////////////////////

11
src/core/SkNormalBevelSource.cpp
View File

@ -30,13 +30,12 @@
class NormalBevelFP : public GrFragmentProcessor {
public:
NormalBevelFP(SkNormalSource::BevelType bevelType, SkScalar bevelWidth, SkScalar bevelHeight)
: INHERITED(kNone_OptimizationFlags)
, fBevelType(bevelType)
, fBevelWidth(bevelWidth)
, fBevelHeight(bevelHeight) {
: fBevelType(bevelType)
, fBevelWidth(bevelWidth)
, fBevelHeight(bevelHeight) {
this->initClassID<NormalBevelFP>();
this->setWillUseDistanceVectorField();
fUsesDistanceVectorField = true;
}
class GLSLNormalBevelFP : public GLSLNormalFP {
@ -240,8 +239,6 @@ private:
SkNormalSource::BevelType fBevelType;
SkScalar fBevelWidth;
SkScalar fBevelHeight;
typedef GrFragmentProcessor INHERITED;
};
sk_sp<GrFragmentProcessor> SkNormalBevelSourceImpl::asFragmentProcessor(

15
src/core/SkNormalFlatSource.cpp
View File

@ -20,7 +20,7 @@
class NormalFlatFP : public GrFragmentProcessor {
public:
NormalFlatFP() : INHERITED(kConstantOutputForConstantInput_OptimizationFlag) {
NormalFlatFP() {
this->initClassID<NormalFlatFP>();
}
@ -43,23 +43,20 @@ public:
const GrProcessor& proc) override {}
};
const char* name() const override { return "NormalFlatFP"; }
private:
void onGetGLSLProcessorKey(const GrShaderCaps& caps, GrProcessorKeyBuilder* b) const override {
GLSLNormalFlatFP::GenKey(*this, caps, b);
}
const char* name() const override { return "NormalFlatFP"; }
void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
inout->setToUnknown();
}
GrColor4f constantOutputForConstantInput(GrColor4f) const override {
return GrColor4f(0, 0, 1, 0);
}
private:
GrGLSLFragmentProcessor* onCreateGLSLInstance() const override { return new GLSLNormalFlatFP; }
bool onIsEqual(const GrFragmentProcessor&) const override { return true; }
typedef GrFragmentProcessor INHERITED;
};
sk_sp<GrFragmentProcessor> SkNormalFlatSourceImpl::asFragmentProcessor(

4
src/core/SkNormalMapSource.cpp
View File

@ -26,7 +26,7 @@
class NormalMapFP : public GrFragmentProcessor {
public:
NormalMapFP(sk_sp<GrFragmentProcessor> mapFP, const SkMatrix& invCTM)
: INHERITED(kNone_OptimizationFlags), fInvCTM(invCTM) {
: fInvCTM(invCTM) {
this->registerChildProcessor(mapFP);
this->initClassID<NormalMapFP>();
@ -117,8 +117,6 @@ private:
}
SkMatrix fInvCTM;
typedef GrFragmentProcessor INHERITED;
};
sk_sp<GrFragmentProcessor> SkNormalMapSourceImpl::asFragmentProcessor(

29
src/effects/GrAlphaThresholdFragmentProcessor.cpp
View File

@ -32,14 +32,6 @@ sk_sp<GrFragmentProcessor> GrAlphaThresholdFragmentProcessor::Make(
bounds));
}
inline GrFragmentProcessor::OptimizationFlags GrAlphaThresholdFragmentProcessor::OptFlags(float outerThreshold) {
if (outerThreshold >= 1.f) {
return kPreservesOpaqueInput_OptimizationFlag | kModulatesInput_OptimizationFlag;
} else {
return kModulatesInput_OptimizationFlag;
}
}
GrAlphaThresholdFragmentProcessor::GrAlphaThresholdFragmentProcessor(
GrTexture* texture,
sk_sp<GrColorSpaceXform> colorSpaceXform,
@ -47,17 +39,16 @@ GrAlphaThresholdFragmentProcessor::GrAlphaThresholdFragmentProcessor(
float innerThreshold,
float outerThreshold,
const SkIRect& bounds)
: INHERITED(OptFlags(outerThreshold))
, fInnerThreshold(innerThreshold)
, fOuterThreshold(outerThreshold)
, fImageCoordTransform(SkMatrix::I(), texture, GrSamplerParams::kNone_FilterMode)
, fImageTextureSampler(texture)
, fColorSpaceXform(std::move(colorSpaceXform))
, fMaskCoordTransform(
SkMatrix::MakeTrans(SkIntToScalar(-bounds.x()), SkIntToScalar(-bounds.y())),
maskTexture,
GrSamplerParams::kNone_FilterMode)
, fMaskTextureSampler(maskTexture) {
: fInnerThreshold(innerThreshold)
, fOuterThreshold(outerThreshold)
, fImageCoordTransform(SkMatrix::I(), texture, GrSamplerParams::kNone_FilterMode)
, fImageTextureSampler(texture)
, fColorSpaceXform(std::move(colorSpaceXform))
, fMaskCoordTransform(SkMatrix::MakeTrans(SkIntToScalar(-bounds.x()),
SkIntToScalar(-bounds.y())),
maskTexture,
GrSamplerParams::kNone_FilterMode)
, fMaskTextureSampler(maskTexture) {
this->initClassID<GrAlphaThresholdFragmentProcessor>();
this->addCoordTransform(&fImageCoordTransform);
this->addTextureSampler(&fImageTextureSampler);

2
src/effects/GrAlphaThresholdFragmentProcessor.h
View File

@ -35,8 +35,6 @@ public:
GrColorSpaceXform* colorSpaceXform() const { return fColorSpaceXform.get(); }
private:
static OptimizationFlags OptFlags(float outerThreshold);
GrAlphaThresholdFragmentProcessor(GrTexture* texture,
sk_sp<GrColorSpaceXform> colorSpaceXform,
GrTexture* maskTexture,

9
src/effects/GrCircleBlurFragmentProcessor.cpp
View File

@ -88,11 +88,10 @@ GrCircleBlurFragmentProcessor::GrCircleBlurFragmentProcessor(const SkRect& circl
float textureRadius,
float solidRadius,
GrTexture* blurProfile)
: INHERITED(kModulatesInput_OptimizationFlag)
, fCircle(circle)
, fSolidRadius(solidRadius)
, fTextureRadius(textureRadius)
, fBlurProfileSampler(blurProfile, GrSamplerParams::kBilerp_FilterMode) {
: fCircle(circle)
, fSolidRadius(solidRadius)
, fTextureRadius(textureRadius)
, fBlurProfileSampler(blurProfile, GrSamplerParams::kBilerp_FilterMode) {
this->initClassID<GrCircleBlurFragmentProcessor>();
this->addTextureSampler(&fBlurProfileSampler);
}

8
src/effects/SkArithmeticImageFilter.cpp
View File

@ -290,15 +290,9 @@ private:
inout->setToUnknown();
}
// This could implement the const input -> const output optimization but it's unlikely to help.
ArithmeticFP(float k1, float k2, float k3, float k4, bool enforcePMColor,
sk_sp<GrFragmentProcessor> dst)
: INHERITED(kNone_OptimizationFlags)
, fK1(k1)
, fK2(k2)
, fK3(k3)
, fK4(k4)
, fEnforcePMColor(enforcePMColor) {
: fK1(k1), fK2(k2), fK3(k3), fK4(k4), fEnforcePMColor(enforcePMColor) {
this->initClassID<ArithmeticFP>();
SkASSERT(dst);
SkDEBUGCODE(int dstIndex =) this->registerChildProcessor(std::move(dst));

20
src/effects/SkBlurMaskFilter.cpp
View File

@ -974,13 +974,12 @@ GrTexture* GrRectBlurEffect::CreateBlurProfileTexture(GrTextureProvider* texture
return blurProfile;
}
GrRectBlurEffect::GrRectBlurEffect(const SkRect& rect, float sigma, GrTexture* blurProfile,
GrRectBlurEffect::GrRectBlurEffect(const SkRect& rect, float sigma, GrTexture *blurProfile,
GrSLPrecision precision)
: INHERITED(kModulatesInput_OptimizationFlag)
, fRect(rect)
, fSigma(sigma)
, fBlurProfileSampler(blurProfile)
, fPrecision(precision) {
: fRect(rect)
, fSigma(sigma)
, fBlurProfileSampler(blurProfile)
, fPrecision(precision) {
this->initClassID<GrRectBlurEffect>();
this->addTextureSampler(&fBlurProfileSampler);
}
@ -1207,11 +1206,10 @@ void GrRRectBlurEffect::onComputeInvariantOutput(GrInvariantOutput* inout) const
inout->mulByUnknownSingleComponent();
}
GrRRectBlurEffect::GrRRectBlurEffect(float sigma, const SkRRect& rrect, GrTexture* ninePatchTexture)
: INHERITED(kModulatesInput_OptimizationFlag)
, fRRect(rrect)
, fSigma(sigma)
, fNinePatchSampler(ninePatchTexture) {
GrRRectBlurEffect::GrRRectBlurEffect(float sigma, const SkRRect& rrect, GrTexture *ninePatchTexture)
: fRRect(rrect),
fSigma(sigma),
fNinePatchSampler(ninePatchTexture) {
this->initClassID<GrRRectBlurEffect>();
this->addTextureSampler(&fNinePatchSampler);
}

38
src/effects/SkDisplacementMapEffect.cpp
View File

@ -487,26 +487,24 @@ void GrDisplacementMapEffect::onGetGLSLProcessorKey(const GrShaderCaps& caps,
}
GrDisplacementMapEffect::GrDisplacementMapEffect(
SkDisplacementMapEffect::ChannelSelectorType xChannelSelector,
SkDisplacementMapEffect::ChannelSelectorType yChannelSelector,
const SkVector& scale,
GrTexture* displacement,
const SkMatrix& offsetMatrix,
GrTexture* color,
sk_sp<GrColorSpaceXform> colorSpaceXform,
const SkISize& colorDimensions)
: INHERITED(GrPixelConfigIsOpaque(color->config()) ? kPreservesOpaqueInput_OptimizationFlag
: kNone_OptimizationFlags)
, fDisplacementTransform(offsetMatrix, displacement, GrSamplerParams::kNone_FilterMode)
, fDisplacementSampler(displacement)
, fColorTransform(color, GrSamplerParams::kNone_FilterMode)
, fDomain(color, GrTextureDomain::MakeTexelDomain(SkIRect::MakeSize(colorDimensions)),
GrTextureDomain::kDecal_Mode)
, fColorSampler(color)
, fColorSpaceXform(std::move(colorSpaceXform))
, fXChannelSelector(xChannelSelector)
, fYChannelSelector(yChannelSelector)
, fScale(scale) {
SkDisplacementMapEffect::ChannelSelectorType xChannelSelector,
SkDisplacementMapEffect::ChannelSelectorType yChannelSelector,
const SkVector& scale,
GrTexture* displacement,
const SkMatrix& offsetMatrix,
GrTexture* color,
sk_sp<GrColorSpaceXform> colorSpaceXform,
const SkISize& colorDimensions)
: fDisplacementTransform(offsetMatrix, displacement, GrSamplerParams::kNone_FilterMode)
, fDisplacementSampler(displacement)
, fColorTransform(color, GrSamplerParams::kNone_FilterMode)
, fDomain(color, GrTextureDomain::MakeTexelDomain(SkIRect::MakeSize(colorDimensions)),
GrTextureDomain::kDecal_Mode)
, fColorSampler(color)
, fColorSpaceXform(std::move(colorSpaceXform))
, fXChannelSelector(xChannelSelector)
, fYChannelSelector(yChannelSelector)
, fScale(scale) {
this->initClassID<GrDisplacementMapEffect>();
this->addCoordTransform(&fDisplacementTransform);
this->addTextureSampler(&fDisplacementSampler);

6
src/effects/SkGaussianEdgeShader.cpp
View File

@ -63,11 +63,11 @@ private:
class GaussianEdgeFP : public GrFragmentProcessor {
public:
GaussianEdgeFP() : INHERITED(kNone_OptimizationFlags) {
GaussianEdgeFP() {
this->initClassID<GaussianEdgeFP>();
// enable output of distance information for shape
this->setWillUseDistanceVectorField();
fUsesDistanceVectorField = true;
}
class GLSLGaussianEdgeFP : public GrGLSLFragmentProcessor {
@ -123,8 +123,6 @@ private:
}
bool onIsEqual(const GrFragmentProcessor& proc) const override { return true; }
typedef GrFragmentProcessor INHERITED;
};
////////////////////////////////////////////////////////////////////////////

15
src/effects/SkLightingImageFilter.cpp
View File

@ -1625,7 +1625,7 @@ SkString emitNormalFunc(BoundaryMode mode,
}
class GrGLLightingEffect : public GrGLSLFragmentProcessor {
class GrGLLightingEffect : public GrGLSLFragmentProcessor {
public:
GrGLLightingEffect() : fLight(nullptr) { }
virtual ~GrGLLightingEffect() { delete fLight; }
@ -1702,13 +1702,12 @@ GrLightingEffect::GrLightingEffect(GrTexture* texture,
const SkMatrix& matrix,
BoundaryMode boundaryMode,
const SkIRect* srcBounds)
// Perhaps this could advertise the opaque or modulating optimizations?
: INHERITED(texture, nullptr, SkMatrix::I(), kNone_OptimizationFlags)
, fLight(light)
, fSurfaceScale(surfaceScale)
, fFilterMatrix(matrix)
, fBoundaryMode(boundaryMode)
, fDomain(create_domain(texture, srcBounds, GrTextureDomain::kDecal_Mode)) {
: INHERITED(texture, nullptr, SkMatrix::I())
, fLight(light)
, fSurfaceScale(surfaceScale)
, fFilterMatrix(matrix)
, fBoundaryMode(boundaryMode)
, fDomain(create_domain(texture, srcBounds, GrTextureDomain::kDecal_Mode)) {
fLight->ref();
}

10
src/effects/SkLumaColorFilter.cpp
View File

@ -98,7 +98,7 @@ public:
};
private:
LumaColorFilterEffect() : INHERITED(kConstantOutputForConstantInput_OptimizationFlag) {
LumaColorFilterEffect() {
this->initClassID<LumaColorFilterEffect>();
}
@ -117,14 +117,6 @@ private:
// The output is always black. The alpha value for the color passed in is arbitrary.
inout->setToOther(kRGB_GrColorComponentFlags, GrColorPackRGBA(0, 0, 0, 0));
}
GrColor4f constantOutputForConstantInput(GrColor4f input) const override {
float luma = SK_ITU_BT709_LUM_COEFF_R * input.fRGBA[0] +
SK_ITU_BT709_LUM_COEFF_G * input.fRGBA[1] +
SK_ITU_BT709_LUM_COEFF_B * input.fRGBA[2];
return GrColor4f(0, 0, 0, luma);
}
typedef GrFragmentProcessor INHERITED;
};
sk_sp<GrFragmentProcessor> SkLumaColorFilter::asFragmentProcessor(GrContext*, SkColorSpace*) const {

18
src/effects/SkMagnifierImageFilter.cpp
View File

@ -27,6 +27,7 @@
#include "../private/GrGLSL.h"
class GrMagnifierEffect : public GrSingleTextureEffect {
public:
static sk_sp<GrFragmentProcessor> Make(GrTexture* texture,
sk_sp<GrColorSpaceXform> colorSpaceXform,
@ -70,15 +71,14 @@ private:
float yInvZoom,
float xInvInset,
float yInvInset)
: INHERITED(texture, std::move(colorSpaceXform), SkMatrix::I(),
ModulationFlags(texture->config()))
, fBounds(bounds)
, fXOffset(xOffset)
, fYOffset(yOffset)
, fXInvZoom(xInvZoom)
, fYInvZoom(yInvZoom)
, fXInvInset(xInvInset)
, fYInvInset(yInvInset) {
: INHERITED(texture, std::move(colorSpaceXform), SkMatrix::I())
, fBounds(bounds)
, fXOffset(xOffset)
, fYOffset(yOffset)
, fXInvZoom(xInvZoom)
, fYInvZoom(yInvZoom)
, fXInvInset(xInvInset)
, fYInvInset(yInvInset) {
this->initClassID<GrMagnifierEffect>();
}

14
src/effects/SkMorphologyImageFilter.cpp
View File

@ -140,7 +140,9 @@ void SkDilateImageFilter::toString(SkString* str) const {
* color.
*/
class GrMorphologyEffect : public Gr1DKernelEffect {
public:
enum MorphologyType {
kErode_MorphologyType,
kDilate_MorphologyType,
@ -325,9 +327,9 @@ GrMorphologyEffect::GrMorphologyEffect(GrTexture* texture,
Direction direction,
int radius,
MorphologyType type)
: INHERITED(texture, direction, radius, ModulationFlags(texture->config()))
, fType(type)
, fUseRange(false) {
: INHERITED(texture, direction, radius)
, fType(type)
, fUseRange(false) {
this->initClassID<GrMorphologyEffect>();
}
@ -336,9 +338,9 @@ GrMorphologyEffect::GrMorphologyEffect(GrTexture* texture,
int radius,
MorphologyType type,
const float range[2])
: INHERITED(texture, direction, radius, ModulationFlags(texture->config()))
, fType(type)
, fUseRange(true) {
: INHERITED(texture, direction, radius)
, fType(type)
, fUseRange(true) {
this->initClassID<GrMorphologyEffect>();
fRange[0] = range[0];
fRange[1] = range[1];

6
src/effects/SkOverdrawColorFilter.cpp
View File

@ -59,6 +59,7 @@ public:
static sk_sp<GrFragmentProcessor> Make(const SkPMColor* colors);
const char* name() const override { return "Overdraw"; }
private:
GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;
void onGetGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const override {}
@ -104,10 +105,7 @@ sk_sp<GrFragmentProcessor> OverdrawFragmentProcessor::Make(const SkPMColor* colo
return sk_sp<OverdrawFragmentProcessor>(new OverdrawFragmentProcessor(grColors));
}
// This could implement the constant input -> constant output optimization, but we don't really
// care given how this is used.
OverdrawFragmentProcessor::OverdrawFragmentProcessor(const GrColor4f* colors)
: INHERITED(kNone_OptimizationFlags) {
OverdrawFragmentProcessor::OverdrawFragmentProcessor(const GrColor4f* colors) {
this->initClassID<OverdrawFragmentProcessor>();
memcpy(fColors, colors, SkOverdrawColorFilter::kNumColors * sizeof(GrColor4f));
}

18
src/effects/SkPerlinNoiseShader.cpp
View File

@ -538,18 +538,18 @@ private:
inout->setToUnknown();
}
GrPerlinNoiseEffect(SkPerlinNoiseShader::Type type, int numOctaves, bool stitchTiles,
GrPerlinNoiseEffect(SkPerlinNoiseShader::Type type,
int numOctaves, bool stitchTiles,
SkPerlinNoiseShader::PaintingData* paintingData,
GrTexture* permutationsTexture, GrTexture* noiseTexture,
const SkMatrix& matrix)
: INHERITED(kNone_OptimizationFlags)
, fType(type)
, fCoordTransform(matrix)
, fNumOctaves(numOctaves)
, fStitchTiles(stitchTiles)
, fPermutationsSampler(permutationsTexture)
, fNoiseSampler(noiseTexture)
, fPaintingData(paintingData) {
: fType(type)
, fCoordTransform(matrix)
, fNumOctaves(numOctaves)
, fStitchTiles(stitchTiles)
, fPermutationsSampler(permutationsTexture)
, fNoiseSampler(noiseTexture)
, fPaintingData(paintingData) {
this->initClassID<GrPerlinNoiseEffect>();
this->addTextureSampler(&fPermutationsSampler);
this->addTextureSampler(&fNoiseSampler);

4
src/effects/SkRRectsGaussianEdgeMaskFilter.cpp
View File

@ -207,7 +207,9 @@ public:
};
RRectsGaussianEdgeFP(const SkRRect& first, const SkRRect& second, SkScalar radius)
: INHERITED(kNone_OptimizationFlags), fFirst(first), fSecond(second), fRadius(radius) {
: fFirst(first)
, fSecond(second)
, fRadius(radius) {
this->initClassID<RRectsGaussianEdgeFP>();
fFirstMode = ComputeMode(fFirst);

9
src/effects/SkTableColorFilter.cpp
View File

@ -512,11 +512,10 @@ sk_sp<GrFragmentProcessor> ColorTableEffect::Make(GrContext* context, SkBitmap b
ColorTableEffect::ColorTableEffect(GrTexture* texture, GrTextureStripAtlas* atlas, int row,
unsigned flags)
: INHERITED(kNone_OptimizationFlags) // Not bothering with table-specific optimizations.
, fTextureSampler(texture)
, fFlags(flags)
, fAtlas(atlas)
, fRow(row) {
: fTextureSampler(texture)
, fFlags(flags)
, fAtlas(atlas)
, fRow(row) {
this->initClassID<ColorTableEffect>();
this->addTextureSampler(&fTextureSampler);
}

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

@ -1572,13 +1572,7 @@ void GrGradientEffect::GLSLProcessor::emitColor(GrGLSLFPFragmentBuilder* fragBui
/////////////////////////////////////////////////////////////////////
inline GrFragmentProcessor::OptimizationFlags GrGradientEffect::OptFlags(bool isOpaque) {
return isOpaque ? kPreservesOpaqueInput_OptimizationFlag | kModulatesInput_OptimizationFlag
: kModulatesInput_OptimizationFlag;
}
GrGradientEffect::GrGradientEffect(const CreateArgs& args, bool isOpaque)
: INHERITED(OptFlags(isOpaque)) {
GrGradientEffect::GrGradientEffect(const CreateArgs& args) {
const SkGradientShaderBase& shader(*args.fShader);
fIsOpaque = shader.isOpaque();

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

@ -352,6 +352,8 @@ public:
class GLSLProcessor;
GrGradientEffect(const CreateArgs&);
virtual ~GrGradientEffect();
bool useAtlas() const { return SkToBool(-1 != fRow); }
@ -400,8 +402,6 @@ public:
}
protected:
GrGradientEffect(const CreateArgs&, bool isOpaque);
/** Helper struct that stores (and populates) parameters to construct a random gradient.
If fUseColors4f is true, then the SkColor4f factory should be called, with fColors4f and
fColorSpace. Otherwise, the SkColor factory should be called, with fColors. fColorCount
@ -430,8 +430,6 @@ protected:
const GrCoordTransform& getCoordTransform() const { return fCoordTransform; }
private:
static OptimizationFlags OptFlags(bool isOpaque);
// If we're in legacy mode, then fColors will be populated. If we're gamma-correct, then
// fColors4f and fColorSpaceXform will be populated.
SkTDArray<SkColor> fColors;

3
src/effects/gradients/SkLinearGradient.cpp
View File

@ -426,7 +426,8 @@ public:
const char* name() const override { return "Linear Gradient"; }
private:
GrLinearGradient(const CreateArgs& args) : INHERITED(args, args.fShader->colorsAreOpaque()) {
GrLinearGradient(const CreateArgs& args)
: INHERITED(args) {
this->initClassID<GrLinearGradient>();
}

3
src/effects/gradients/SkRadialGradient.cpp
View File

@ -256,7 +256,8 @@ public:
const char* name() const override { return "Radial Gradient"; }
private:
GrRadialGradient(const CreateArgs& args) : INHERITED(args, args.fShader->colorsAreOpaque()) {
GrRadialGradient(const CreateArgs& args)
: INHERITED(args) {
this->initClassID<GrRadialGradient>();
}

3
src/effects/gradients/SkSweepGradient.cpp
View File

@ -138,7 +138,8 @@ public:
const char* name() const override { return "Sweep Gradient"; }
private:
GrSweepGradient(const CreateArgs& args) : INHERITED(args, args.fShader->colorsAreOpaque()) {
GrSweepGradient(const CreateArgs& args)
: INHERITED(args) {
this->initClassID<GrSweepGradient>();
}

22
src/effects/gradients/SkTwoPointConicalGradient_gpu.cpp
View File

@ -92,7 +92,7 @@ private:
}
Edge2PtConicalEffect(const CreateArgs& args)
: INHERITED(args, false /* opaque: draws transparent black outside of the cone. */) {
: INHERITED(args) {
const SkTwoPointConicalGradient& shader =
*static_cast<const SkTwoPointConicalGradient*>(args.fShader);
fCenterX1 = shader.getCenterX1();
@ -398,15 +398,10 @@ private:
this->fIsFlipped == s.fIsFlipped);
}
static bool IsFlipped(const CreateArgs& args) {
// eww.
return static_cast<const SkTwoPointConicalGradient*>(args.fShader)->isFlippedGrad();
}
FocalOutside2PtConicalEffect(const CreateArgs& args, SkScalar focalX)
: INHERITED(args, false /* opaque: draws transparent black outside of the cone. */)
, fFocalX(focalX)
, fIsFlipped(IsFlipped(args)) {
: INHERITED(args)
, fFocalX(focalX)
, fIsFlipped(static_cast<const SkTwoPointConicalGradient*>(args.fShader)->isFlippedGrad()) {
this->initClassID<FocalOutside2PtConicalEffect>();
}
@ -418,7 +413,7 @@ private:
typedef GrGradientEffect INHERITED;
};
class FocalOutside2PtConicalEffect::GLSLFocalOutside2PtConicalProcessor
class FocalOutside2PtConicalEffect::GLSLFocalOutside2PtConicalProcessor
: public GrGradientEffect::GLSLProcessor {
public:
GLSLFocalOutside2PtConicalProcessor(const GrProcessor&);
@ -611,7 +606,7 @@ private:
}
FocalInside2PtConicalEffect(const CreateArgs& args, SkScalar focalX)
: INHERITED(args, args.fShader->colorsAreOpaque()), fFocalX(focalX) {
: INHERITED(args), fFocalX(focalX) {
this->initClassID<FocalInside2PtConicalEffect>();
}
@ -852,7 +847,7 @@ private:
}
CircleInside2PtConicalEffect(const CreateArgs& args, const CircleConicalInfo& info)
: INHERITED(args, args.fShader->colorsAreOpaque()), fInfo(info) {
: INHERITED(args), fInfo(info) {
this->initClassID<CircleInside2PtConicalEffect>();
}
@ -1069,8 +1064,7 @@ private:
}
CircleOutside2PtConicalEffect(const CreateArgs& args, const CircleConicalInfo& info)
: INHERITED(args, false /* opaque: draws transparent black outside of the cone. */)
, fInfo(info) {
: INHERITED(args), fInfo(info) {
this->initClassID<CircleOutside2PtConicalEffect>();
const SkTwoPointConicalGradient& shader =
*static_cast<const SkTwoPointConicalGradient*>(args.fShader);

6
src/effects/shadows/SkAmbientShadowMaskFilter.cpp
View File

@ -140,7 +140,9 @@ void SkAmbientShadowMaskFilterImpl::flatten(SkWriteBuffer& buffer) const {
//
class ShadowEdgeFP : public GrFragmentProcessor {
public:
ShadowEdgeFP() : INHERITED(kNone_OptimizationFlags) { this->initClassID<ShadowEdgeFP>(); }
ShadowEdgeFP() {
this->initClassID<ShadowEdgeFP>();
}
class GLSLShadowEdgeFP : public GrGLSLFragmentProcessor {
public:
@ -177,8 +179,6 @@ private:
}
bool onIsEqual(const GrFragmentProcessor& proc) const override { return true; }
typedef GrFragmentProcessor INHERITED;
};
///////////////////////////////////////////////////////////////////////////////////////////////////

79
src/gpu/GrFragmentProcessor.cpp
View File

@ -58,7 +58,7 @@ GrGLSLFragmentProcessor* GrFragmentProcessor::createGLSLInstance() const {
void GrFragmentProcessor::addCoordTransform(const GrCoordTransform* transform) {
fCoordTransforms.push_back(transform);
fFlags |= kUsesLocalCoords_Flag;
fUsesLocalCoords = true;
SkDEBUGCODE(transform->setInProcessor();)
}
@ -66,10 +66,10 @@ int GrFragmentProcessor::registerChildProcessor(sk_sp<GrFragmentProcessor> child
this->combineRequiredFeatures(*child);
if (child->usesLocalCoords()) {
fFlags |= kUsesLocalCoords_Flag;
fUsesLocalCoords = true;
}
if (child->usesDistanceVectorField()) {
fFlags |= kUsesDistanceVectorField_Flag;
fUsesDistanceVectorField = true;
}
int index = fChildProcessors.count();
@ -111,13 +111,12 @@ sk_sp<GrFragmentProcessor> GrFragmentProcessor::PremulInput(sk_sp<GrFragmentProc
class PremulInputFragmentProcessor : public GrFragmentProcessor {
public:
PremulInputFragmentProcessor()
: INHERITED(kPreservesOpaqueInput_OptimizationFlag |
kConstantOutputForConstantInput_OptimizationFlag) {
PremulInputFragmentProcessor() {
this->initClassID<PremulInputFragmentProcessor>();
}
const char* name() const override { return "PremultiplyInput"; }
private:
GrGLSLFragmentProcessor* onCreateGLSLInstance() const override {
class GLFP : public GrGLSLFragmentProcessor {
@ -140,11 +139,6 @@ sk_sp<GrFragmentProcessor> GrFragmentProcessor::PremulInput(sk_sp<GrFragmentProc
void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
inout->premulFourChannelColor();
}
GrColor4f constantOutputForConstantInput(GrColor4f input) const override {
return input.premul();
}
typedef GrFragmentProcessor INHERITED;
};
if (!fp) {
return nullptr;
@ -158,8 +152,7 @@ sk_sp<GrFragmentProcessor> GrFragmentProcessor::MulOutputByInputUnpremulColor(
class PremulFragmentProcessor : public GrFragmentProcessor {
public:
PremulFragmentProcessor(sk_sp<GrFragmentProcessor> processor)
: INHERITED(OptFlags(processor.get())) {
PremulFragmentProcessor(sk_sp<GrFragmentProcessor> processor) {
this->initClassID<PremulFragmentProcessor>();
this->registerChildProcessor(processor);
}
@ -185,16 +178,6 @@ sk_sp<GrFragmentProcessor> GrFragmentProcessor::MulOutputByInputUnpremulColor(
bool onIsEqual(const GrFragmentProcessor&) const override { return true; }
static OptimizationFlags OptFlags(const GrFragmentProcessor* inner) {
OptimizationFlags flags = kNone_OptimizationFlags;
if (inner->preservesOpaqueInput()) {
flags |= kPreservesOpaqueInput_OptimizationFlag;
}
if (inner->hasConstantOutputForConstantInput()) {
flags |= kConstantOutputForConstantInput_OptimizationFlag;
}
return flags;
}
void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
// TODO: Add a helper to GrInvariantOutput that handles multiplying by color with flags?
if (!(inout->validFlags() & kA_GrColorComponentFlag)) {
@ -227,16 +210,6 @@ sk_sp<GrFragmentProcessor> GrFragmentProcessor::MulOutputByInputUnpremulColor(
}
inout->setToOther(commonFlags, color);
}
GrColor4f constantOutputForConstantInput(GrColor4f input) const override {
GrColor4f childColor = ConstantOutputForConstantInput(this->childProcessor(0),
GrColor4f::OpaqueWhite());
return GrColor4f(input.fRGBA[3] * input.fRGBA[0] * childColor.fRGBA[0],
input.fRGBA[3] * input.fRGBA[1] * childColor.fRGBA[1],
input.fRGBA[3] * input.fRGBA[2] * childColor.fRGBA[2],
input.fRGBA[3] * childColor.fRGBA[3]);
}
typedef GrFragmentProcessor INHERITED;
};
if (!fp) {
return nullptr;
@ -251,7 +224,7 @@ sk_sp<GrFragmentProcessor> GrFragmentProcessor::OverrideInput(sk_sp<GrFragmentPr
class ReplaceInputFragmentProcessor : public GrFragmentProcessor {
public:
ReplaceInputFragmentProcessor(sk_sp<GrFragmentProcessor> child, GrColor4f color)
: INHERITED(OptFlags(child.get(), color)), fColor(color) {
: fColor(color) {
this->initClassID<ReplaceInputFragmentProcessor>();
this->registerChildProcessor(std::move(child));
}
@ -291,18 +264,6 @@ sk_sp<GrFragmentProcessor> GrFragmentProcessor::OverrideInput(sk_sp<GrFragmentPr
}
private:
static OptimizationFlags OptFlags(const GrFragmentProcessor* child, GrColor4f color) {
OptimizationFlags childFlags = child->optimizationFlags();
OptimizationFlags flags = kNone_OptimizationFlags;
if (childFlags & kConstantOutputForConstantInput_OptimizationFlag) {
flags |= kConstantOutputForConstantInput_OptimizationFlag;
}
if ((childFlags & kPreservesOpaqueInput_OptimizationFlag) && color.isOpaque()) {
flags |= kPreservesOpaqueInput_OptimizationFlag;
}
return flags;
}
void onGetGLSLProcessorKey(const GrShaderCaps& caps, GrProcessorKeyBuilder* b) const override
{}
@ -315,13 +276,7 @@ sk_sp<GrFragmentProcessor> GrFragmentProcessor::OverrideInput(sk_sp<GrFragmentPr
this->childProcessor(0).computeInvariantOutput(inout);
}
GrColor4f constantOutputForConstantInput(GrColor4f) const override {
return ConstantOutputForConstantInput(this->childProcessor(0), fColor);
}
GrColor4f fColor;
typedef GrFragmentProcessor INHERITED;
};
GrInvariantOutput childOut(0x0, kNone_GrColorComponentFlags);
@ -333,8 +288,7 @@ sk_sp<GrFragmentProcessor> GrFragmentProcessor::RunInSeries(sk_sp<GrFragmentProc
int cnt) {
class SeriesFragmentProcessor : public GrFragmentProcessor {
public:
SeriesFragmentProcessor(sk_sp<GrFragmentProcessor>* children, int cnt)
: INHERITED(OptFlags(children, cnt)) {
SeriesFragmentProcessor(sk_sp<GrFragmentProcessor>* children, int cnt){
SkASSERT(cnt > 1);
this->initClassID<SeriesFragmentProcessor>();
for (int i = 0; i < cnt; ++i) {
@ -363,14 +317,8 @@ sk_sp<GrFragmentProcessor> GrFragmentProcessor::RunInSeries(sk_sp<GrFragmentProc
};
return new GLFP;
}
private:
static OptimizationFlags OptFlags(sk_sp<GrFragmentProcessor>* children, int cnt) {
OptimizationFlags flags = kAll_OptimizationFlags;
for (int i = 0; i < cnt && flags != kNone_OptimizationFlags; ++i) {
flags &= children[i]->optimizationFlags();
}
return flags;
}
void onGetGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const override {}
bool onIsEqual(const GrFragmentProcessor&) const override { return true; }
@ -380,15 +328,6 @@ sk_sp<GrFragmentProcessor> GrFragmentProcessor::RunInSeries(sk_sp<GrFragmentProc
this->childProcessor(i).computeInvariantOutput(inout);
}
}
GrColor4f constantOutputForConstantInput(GrColor4f color) const override {
int childCnt = this->numChildProcessors();
for (int i = 0; i < childCnt; ++i) {
color = ConstantOutputForConstantInput(this->childProcessor(i), color);
}
return color;
}
typedef GrFragmentProcessor INHERITED;
};
if (!cnt) {

18
src/gpu/SkGrPriv.h
View File

@ -8,11 +8,10 @@
#ifndef SkGrPriv_DEFINED
#define SkGrPriv_DEFINED
#include "GrBlend.h"
#include "GrTypes.h"
#include "GrBlend.h"
#include "SkImageInfo.h"
#include "SkMatrix.h"
#include "SkPM4f.h"
#include "SkXfermodePriv.h"
class GrCaps;
@ -103,21 +102,6 @@ bool SkPaintToGrPaintWithTexture(GrContext* context,
//////////////////////////////////////////////////////////////////////////////
static inline SkPM4f GrColor4fToSkPM4f(const GrColor4f& c) {
SkPM4f pm4f;
pm4f.fVec[SkPM4f::R] = c.fRGBA[0];
pm4f.fVec[SkPM4f::G] = c.fRGBA[1];
pm4f.fVec[SkPM4f::B] = c.fRGBA[2];
pm4f.fVec[SkPM4f::A] = c.fRGBA[3];
return pm4f;
}
static inline GrColor4f SkPM4fToGrColor4f(const SkPM4f& c) {
return GrColor4f{c.r(), c.g(), c.b(), c.a()};
}
//////////////////////////////////////////////////////////////////////////////
GrSurfaceDesc GrImageInfoToSurfaceDesc(const SkImageInfo&, const GrCaps&);
bool GrPixelConfigToColorType(GrPixelConfig, SkColorType*);

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

@ -28,11 +28,12 @@ public:
kY_Direction,
};
Gr1DKernelEffect(GrTexture* texture, Direction direction, int radius,
OptimizationFlags optFlags)
: INHERITED(texture, nullptr, SkMatrix::I(), optFlags)
, fDirection(direction)
, fRadius(radius) {}
Gr1DKernelEffect(GrTexture* texture,
Direction direction,
int radius)
: INHERITED(texture, nullptr, SkMatrix::I())
, fDirection(direction)
, fRadius(radius) {}
virtual ~Gr1DKernelEffect() {}
@ -50,6 +51,7 @@ public:
}
private:
Direction fDirection;
int fRadius;

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

@ -132,23 +132,21 @@ void GrGLBicubicEffect::onSetData(const GrGLSLProgramDataManager& pdman,
GrBicubicEffect::GrBicubicEffect(GrTexture* texture,
sk_sp<GrColorSpaceXform> colorSpaceXform,
const SkMatrix& matrix,
const SkMatrix &matrix,
const SkShader::TileMode tileModes[2])
: INHERITED(texture, std::move(colorSpaceXform), matrix,
GrSamplerParams(tileModes, GrSamplerParams::kNone_FilterMode),
ModulationFlags(texture->config()))
, fDomain(GrTextureDomain::IgnoredDomain()) {
: INHERITED(texture, std::move(colorSpaceXform), matrix,
GrSamplerParams(tileModes, GrSamplerParams::kNone_FilterMode))
, fDomain(GrTextureDomain::IgnoredDomain()) {
this->initClassID<GrBicubicEffect>();
}
GrBicubicEffect::GrBicubicEffect(GrTexture* texture,
sk_sp<GrColorSpaceXform> colorSpaceXform,
const SkMatrix& matrix,
const SkMatrix &matrix,
const SkRect& domain)
: INHERITED(texture, std::move(colorSpaceXform), matrix,
GrSamplerParams(SkShader::kClamp_TileMode, GrSamplerParams::kNone_FilterMode),
ModulationFlags(texture->config()))
, fDomain(texture, domain, GrTextureDomain::kClamp_Mode) {
: INHERITED(texture, std::move(colorSpaceXform), matrix,
GrSamplerParams(SkShader::kClamp_TileMode, GrSamplerParams::kNone_FilterMode))
, fDomain(texture, domain, GrTextureDomain::kClamp_Mode) {
this->initClassID<GrBicubicEffect>();
}

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

@ -98,9 +98,9 @@ GrConfigConversionEffect::GrConfigConversionEffect(GrTexture* texture,
const GrSwizzle& swizzle,
PMConversion pmConversion,
const SkMatrix& matrix)
: INHERITED(texture, nullptr, matrix, ModulationFlags(texture->config()))
, fSwizzle(swizzle)
, fPMConversion(pmConversion) {
: INHERITED(texture, nullptr, matrix)
, fSwizzle(swizzle)
, fPMConversion(pmConversion) {
this->initClassID<GrConfigConversionEffect>();
// We expect to get here with non-BGRA/RGBA only if we're doing not doing a premul/unpremul
// conversion.
@ -116,7 +116,7 @@ GrConfigConversionEffect::GrConfigConversionEffect(GrContext* context,
const GrSwizzle& swizzle,
PMConversion pmConversion,
const SkMatrix& matrix)
: INHERITED(context, ModulationFlags(proxy->config()), proxy, nullptr, matrix)
: INHERITED(context, proxy, nullptr, matrix)
, fSwizzle(swizzle)
, fPMConversion(pmConversion) {
this->initClassID<GrConfigConversionEffect>();

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

@ -52,6 +52,7 @@ public:
static void TestForPreservingPMConversions(GrContext* context,
PMConversion* PMToUPMRule,
PMConversion* UPMToPMRule);
private:
GrConfigConversionEffect(GrTexture*, const GrSwizzle&, PMConversion, const SkMatrix& matrix);

13
src/gpu/effects/GrConstColorProcessor.cpp
View File

@ -85,19 +85,6 @@ void GrConstColorProcessor::onComputeInvariantOutput(GrInvariantOutput* inout) c
}
}
GrColor4f GrConstColorProcessor::constantOutputForConstantInput(GrColor4f input) const {
switch (fMode) {
case kIgnore_InputMode:
return fColor;
case kModulateA_InputMode:
return fColor.mulByScalar(input.fRGBA[3]);
case kModulateRGBA_InputMode:
return fColor.modulate(input);
}
SkFAIL("Unexpected mode");
return GrColor4f::TransparentBlack();
}
void GrConstColorProcessor::onGetGLSLProcessorKey(const GrShaderCaps&,
GrProcessorKeyBuilder* b) const {
b->add32(fMode);

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

@ -32,7 +32,7 @@ public:
private:
AARectEffect(GrPrimitiveEdgeType edgeType, const SkRect& rect)
: INHERITED(kModulatesInput_OptimizationFlag), fRect(rect), fEdgeType(edgeType) {
: fRect(rect), fEdgeType(edgeType) {
this->initClassID<AARectEffect>();
}
@ -339,7 +339,8 @@ GrGLSLFragmentProcessor* GrConvexPolyEffect::onCreateGLSLInstance() const {
}
GrConvexPolyEffect::GrConvexPolyEffect(GrPrimitiveEdgeType edgeType, int n, const SkScalar edges[])
: INHERITED(kModulatesInput_OptimizationFlag), fEdgeType(edgeType), fEdgeCount(n) {
: fEdgeType(edgeType)
, fEdgeCount(n) {
this->initClassID<GrConvexPolyEffect>();
// Factory function should have already ensured this.
SkASSERT(n <= kMaxEdges);

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

@ -26,7 +26,9 @@ public:
const char* name() const override { return "Dither"; }
private:
DitherEffect() : INHERITED(kNone_OptimizationFlags) { this->initClassID<DitherEffect>(); }
DitherEffect() {
this->initClassID<DitherEffect>();
}
GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;

3
src/gpu/effects/GrGaussianConvolutionFragmentProcessor.cpp
View File

@ -150,8 +150,7 @@ GrGaussianConvolutionFragmentProcessor::GrGaussianConvolutionFragmentProcessor(G
float gaussianSigma,
bool useBounds,
float bounds[2])
: INHERITED(texture, direction, radius, ModulationFlags(texture->config()))
, fUseBounds(useBounds) {
: INHERITED(texture, direction, radius), fUseBounds(useBounds) {
this->initClassID<GrGaussianConvolutionFragmentProcessor>();
SkASSERT(radius <= kMaxKernelRadius);
int width = this->width();

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

@ -156,14 +156,12 @@ GrMatrixConvolutionEffect::GrMatrixConvolutionEffect(GrTexture* texture,
const SkIPoint& kernelOffset,
GrTextureDomain::Mode tileMode,
bool convolveAlpha)
// To advertise either the modulation or opaqueness optimizations we'd have to examine the
// parameters.
: INHERITED(texture, nullptr, SkMatrix::I(), kNone_OptimizationFlags)
, fKernelSize(kernelSize)
, fGain(SkScalarToFloat(gain))
, fBias(SkScalarToFloat(bias) / 255.0f)
, fConvolveAlpha(convolveAlpha)
, fDomain(texture, GrTextureDomain::MakeTexelDomainForMode(bounds, tileMode), tileMode) {
: INHERITED(texture, nullptr, SkMatrix::I()),
fKernelSize(kernelSize),
fGain(SkScalarToFloat(gain)),
fBias(SkScalarToFloat(bias) / 255.0f),
fConvolveAlpha(convolveAlpha),
fDomain(texture, GrTextureDomain::MakeTexelDomainForMode(bounds, tileMode), tileMode) {
this->initClassID<GrMatrixConvolutionEffect>();
for (int i = 0; i < kernelSize.width() * kernelSize.height(); i++) {
fKernel[i] = SkScalarToFloat(kernel[i]);

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

@ -64,7 +64,9 @@ void CircleEffect::onComputeInvariantOutput(GrInvariantOutput* inout) const {
}
CircleEffect::CircleEffect(GrPrimitiveEdgeType edgeType, const SkPoint& c, SkScalar r)
: INHERITED(kModulatesInput_OptimizationFlag), fCenter(c), fRadius(r), fEdgeType(edgeType) {
: fCenter(c)
, fRadius(r)
, fEdgeType(edgeType) {
this->initClassID<CircleEffect>();
}
@ -228,12 +230,10 @@ void EllipseEffect::onComputeInvariantOutput(GrInvariantOutput* inout) const {
inout->mulByUnknownSingleComponent();
}
EllipseEffect::EllipseEffect(GrPrimitiveEdgeType edgeType, const SkPoint& c, SkScalar rx,
SkScalar ry)
: INHERITED(kModulatesInput_OptimizationFlag)
, fCenter(c)
, fRadii(SkVector::Make(rx, ry))
, fEdgeType(edgeType) {
EllipseEffect::EllipseEffect(GrPrimitiveEdgeType edgeType, const SkPoint& c, SkScalar rx, SkScalar ry)
: fCenter(c)
, fRadii(SkVector::Make(rx, ry))
, fEdgeType(edgeType) {
this->initClassID<EllipseEffect>();
}

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

@ -95,10 +95,9 @@ void CircularRRectEffect::onComputeInvariantOutput(GrInvariantOutput* inout) con
CircularRRectEffect::CircularRRectEffect(GrPrimitiveEdgeType edgeType, uint32_t circularCornerFlags,
const SkRRect& rrect)
: INHERITED(kModulatesInput_OptimizationFlag)
, fRRect(rrect)
, fEdgeType(edgeType)
, fCircularCornerFlags(circularCornerFlags) {
: fRRect(rrect)
, fEdgeType(edgeType)
, fCircularCornerFlags(circularCornerFlags) {
this->initClassID<CircularRRectEffect>();
}
@ -411,8 +410,8 @@ private:
void onComputeInvariantOutput(GrInvariantOutput* inout) const override;
SkRRect fRRect;
GrPrimitiveEdgeType fEdgeType;
SkRRect fRRect;
GrPrimitiveEdgeType fEdgeType;
GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
@ -432,7 +431,8 @@ void EllipticalRRectEffect::onComputeInvariantOutput(GrInvariantOutput* inout) c
}
EllipticalRRectEffect::EllipticalRRectEffect(GrPrimitiveEdgeType edgeType, const SkRRect& rrect)
: INHERITED(kModulatesInput_OptimizationFlag), fRRect(rrect), fEdgeType(edgeType) {
: fRRect(rrect)
, fEdgeType(edgeType) {
this->initClassID<EllipticalRRectEffect>();
}

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

@ -71,9 +71,7 @@ private:
///////////////////////////////////////////////////////////////////////////////
GrSRGBEffect::GrSRGBEffect(Mode mode)
: INHERITED(kPreservesOpaqueInput_OptimizationFlag |
kConstantOutputForConstantInput_OptimizationFlag)
, fMode(mode) {
: fMode(mode) {
this->initClassID<GrSRGBEffect>();
}
@ -86,26 +84,6 @@ void GrSRGBEffect::onComputeInvariantOutput(GrInvariantOutput* inout) const {
inout->setToUnknown();
}
static inline float srgb_to_linear(float srgb) {
return (srgb <= 0.04045f) ? srgb / 12.92f : powf((srgb + 0.055f) / 1.055f, 2.4f);
}
static inline float linear_to_srgb(float linear) {
return (linear <= 0.0031308) ? linear * 12.92f : 1.055f * powf(linear, 1.f / 2.4f) - 0.055f;
}
GrColor4f GrSRGBEffect::constantOutputForConstantInput(GrColor4f input) const {
switch (fMode) {
case Mode::kLinearToSRGB:
return GrColor4f(linear_to_srgb(input.fRGBA[0]), linear_to_srgb(input.fRGBA[1]),
linear_to_srgb(input.fRGBA[2]), input.fRGBA[3]);
case Mode::kSRGBToLinear:
return GrColor4f(srgb_to_linear(input.fRGBA[0]), srgb_to_linear(input.fRGBA[1]),
srgb_to_linear(input.fRGBA[2]), input.fRGBA[3]);
}
SkFAIL("Unexpected mode");
return GrColor4f::TransparentBlack();
}
///////////////////////////////////////////////////////////////////////////////
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrSRGBEffect);

1
src/gpu/effects/GrSRGBEffect.h
View File

@ -33,7 +33,6 @@ private:
void onGetGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const override;
bool onIsEqual(const GrFragmentProcessor&) const override;
void onComputeInvariantOutput(GrInvariantOutput* inout) const override;
GrColor4f constantOutputForConstantInput(GrColor4f input) const override;
Mode fMode;

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

@ -13,29 +13,6 @@
class GrInvariantOutput;
// In a few places below we rely on braced initialization order being defined by the C++ spec (left
// to right). We use operator-> on a sk_sp and then in a later argument std::move() the sk_sp. GCC
// 4.9.0 and earlier has a bug where the left to right order evaluation isn't implemented correctly.
#if defined(__GNUC__) && !defined(__clang__)
# define GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
# if (GCC_VERSION > 40900)
# define GCC_EVAL_ORDER_BUG 0
# else
# define GCC_EVAL_ORDER_BUG 1
# endif
# undef GCC_VERSION
#else
# define GCC_EVAL_ORDER_BUG 0
#endif
#if GCC_EVAL_ORDER_BUG
# define PROXY_MOVE(X) (X)
#else
# define PROXY_MOVE(X) (std::move(X))
#endif
#undef GCC_EVAL_ORDER_BUG
/**
* The output color of this effect is a modulation of the input color and a sample from a texture.
* It allows explicit specification of the filtering and wrap modes (GrSamplerParams) and accepts
@ -104,41 +81,32 @@ private:
sk_sp<GrColorSpaceXform> colorSpaceXform,
const SkMatrix& matrix,
GrSamplerParams::FilterMode filterMode)
: INHERITED(texture, std::move(colorSpaceXform), matrix, filterMode,
ModulationFlags(texture->config())) {
: GrSingleTextureEffect(texture, std::move(colorSpaceXform), matrix, filterMode) {
this->initClassID<GrSimpleTextureEffect>();
}
GrSimpleTextureEffect(GrContext* ctx, sk_sp<GrTextureProxy> proxy,
sk_sp<GrColorSpaceXform> colorSpaceXform, const SkMatrix& matrix,
sk_sp<GrColorSpaceXform> colorSpaceXform,
const SkMatrix& matrix,
GrSamplerParams::FilterMode filterMode)
: INHERITED{ctx,
ModulationFlags(proxy->config()),
PROXY_MOVE(proxy),
std::move(colorSpaceXform),
matrix,
filterMode} {
: GrSingleTextureEffect(ctx, std::move(proxy), std::move(colorSpaceXform),
matrix, filterMode) {
this->initClassID<GrSimpleTextureEffect>();
}
GrSimpleTextureEffect(GrTexture* texture,
sk_sp<GrColorSpaceXform>colorSpaceXform,
sk_sp<GrColorSpaceXform> colorSpaceXform,
const SkMatrix& matrix,
const GrSamplerParams& params)
: INHERITED(texture, std::move(colorSpaceXform), matrix, params,
ModulationFlags(texture->config())) {
: GrSingleTextureEffect(texture, std::move(colorSpaceXform), matrix, params) {
this->initClassID<GrSimpleTextureEffect>();
}
GrSimpleTextureEffect(GrContext* ctx, sk_sp<GrTextureProxy> proxy,
sk_sp<GrColorSpaceXform> colorSpaceXform, const SkMatrix& matrix,
sk_sp<GrColorSpaceXform> colorSpaceXform,
const SkMatrix& matrix,
const GrSamplerParams& params)
: INHERITED{ctx,
ModulationFlags(proxy->config()),
PROXY_MOVE(proxy),
std::move(colorSpaceXform),
matrix,
params} {
: GrSingleTextureEffect(ctx, std::move(proxy), std::move(colorSpaceXform), matrix, params) {
this->initClassID<GrSimpleTextureEffect>();
}
@ -155,6 +123,4 @@ private:
typedef GrSingleTextureEffect INHERITED;
};
#undef PROXY_MOVE
#endif

102
src/gpu/effects/GrSingleTextureEffect.cpp
View File

@ -11,74 +11,68 @@
#include "GrTextureProxy.h"
GrSingleTextureEffect::GrSingleTextureEffect(GrTexture* texture,
sk_sp<GrColorSpaceXform> colorSpaceXform,
const SkMatrix& m, OptimizationFlags optFlags)
: INHERITED(optFlags)
, fCoordTransform(m, texture, GrSamplerParams::kNone_FilterMode)
, fTextureSampler(texture)
, fColorSpaceXform(std::move(colorSpaceXform)) {
this->addCoordTransform(&fCoordTransform);
this->addTextureSampler(&fTextureSampler);
}
GrSingleTextureEffect::GrSingleTextureEffect(GrTexture* texture,
sk_sp<GrColorSpaceXform> colorSpaceXform,
const SkMatrix& m,
GrSamplerParams::FilterMode filterMode,
OptimizationFlags optFlags)
: INHERITED(optFlags)
, fCoordTransform(m, texture, filterMode)
, fTextureSampler(texture, filterMode)
, fColorSpaceXform(std::move(colorSpaceXform)) {
this->addCoordTransform(&fCoordTransform);
this->addTextureSampler(&fTextureSampler);
}
GrSingleTextureEffect::GrSingleTextureEffect(GrTexture* texture,
sk_sp<GrColorSpaceXform> colorSpaceXform,
const SkMatrix& m, const GrSamplerParams& params,
OptimizationFlags optFlags)
: INHERITED(optFlags)
, fCoordTransform(m, texture, params.filterMode())
, fTextureSampler(texture, params)
, fColorSpaceXform(std::move(colorSpaceXform)) {
this->addCoordTransform(&fCoordTransform);
this->addTextureSampler(&fTextureSampler);
}
GrSingleTextureEffect::GrSingleTextureEffect(GrContext* ctx, OptimizationFlags optFlags,
sk_sp<GrTextureProxy> proxy,
sk_sp<GrColorSpaceXform> colorSpaceXform,
const SkMatrix& m)
: INHERITED(optFlags)
, fCoordTransform(ctx, m, proxy.get(), GrSamplerParams::kNone_FilterMode)
, fTextureSampler(ctx->textureProvider(), std::move(proxy))
, fColorSpaceXform(std::move(colorSpaceXform)) {
: fCoordTransform(m, texture, GrSamplerParams::kNone_FilterMode)
, fTextureSampler(texture)
, fColorSpaceXform(std::move(colorSpaceXform)) {
this->addCoordTransform(&fCoordTransform);
this->addTextureSampler(&fTextureSampler);
}
GrSingleTextureEffect::GrSingleTextureEffect(GrContext* ctx, OptimizationFlags optFlags,
sk_sp<GrTextureProxy> proxy,
GrSingleTextureEffect::GrSingleTextureEffect(GrTexture* texture,
sk_sp<GrColorSpaceXform> colorSpaceXform,
const SkMatrix& m,
GrSamplerParams::FilterMode filterMode)
: INHERITED(optFlags)
, fCoordTransform(ctx, m, proxy.get(), filterMode)
, fTextureSampler(ctx->textureProvider(), std::move(proxy), filterMode)
, fColorSpaceXform(std::move(colorSpaceXform)) {
: fCoordTransform(m, texture, filterMode)
, fTextureSampler(texture, filterMode)
, fColorSpaceXform(std::move(colorSpaceXform)) {
this->addCoordTransform(&fCoordTransform);
this->addTextureSampler(&fTextureSampler);
}
GrSingleTextureEffect::GrSingleTextureEffect(GrContext* ctx, OptimizationFlags optFlags,
sk_sp<GrTextureProxy> proxy,
GrSingleTextureEffect::GrSingleTextureEffect(GrTexture* texture,
sk_sp<GrColorSpaceXform> colorSpaceXform,
const SkMatrix& m, const GrSamplerParams& params)
: INHERITED(optFlags)
, fCoordTransform(ctx, m, proxy.get(), params.filterMode())
, fTextureSampler(ctx->textureProvider(), std::move(proxy), params)
, fColorSpaceXform(std::move(colorSpaceXform)) {
const SkMatrix& m,
const GrSamplerParams& params)
: fCoordTransform(m, texture, params.filterMode())
, fTextureSampler(texture, params)
, fColorSpaceXform(std::move(colorSpaceXform)) {
this->addCoordTransform(&fCoordTransform);
this->addTextureSampler(&fTextureSampler);
}
GrSingleTextureEffect::GrSingleTextureEffect(GrContext* ctx, sk_sp<GrTextureProxy> proxy,
sk_sp<GrColorSpaceXform> colorSpaceXform,
const SkMatrix& m)
: fCoordTransform(ctx, m, proxy.get(), GrSamplerParams::kNone_FilterMode)
, fTextureSampler(ctx->textureProvider(), std::move(proxy))
, fColorSpaceXform(std::move(colorSpaceXform)) {
this->addCoordTransform(&fCoordTransform);
this->addTextureSampler(&fTextureSampler);
}
GrSingleTextureEffect::GrSingleTextureEffect(GrContext* ctx, sk_sp<GrTextureProxy> proxy,
sk_sp<GrColorSpaceXform> colorSpaceXform,
const SkMatrix& m,
GrSamplerParams::FilterMode filterMode)
: fCoordTransform(ctx, m, proxy.get(), filterMode)
, fTextureSampler(ctx->textureProvider(), std::move(proxy), filterMode)
, fColorSpaceXform(std::move(colorSpaceXform)) {
this->addCoordTransform(&fCoordTransform);
this->addTextureSampler(&fTextureSampler);
}
GrSingleTextureEffect::GrSingleTextureEffect(GrContext* ctx, sk_sp<GrTextureProxy> proxy,
sk_sp<GrColorSpaceXform> colorSpaceXform,
const SkMatrix& m,
const GrSamplerParams& params)
: fCoordTransform(ctx, m, proxy.get(), params.filterMode())
, fTextureSampler(ctx->textureProvider(), std::move(proxy), params)
, fColorSpaceXform(std::move(colorSpaceXform)) {
this->addCoordTransform(&fCoordTransform);
this->addTextureSampler(&fTextureSampler);
}
GrSingleTextureEffect::~GrSingleTextureEffect() {
}

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

@ -23,6 +23,8 @@ class GrTextureProxy;
*/
class GrSingleTextureEffect : public GrFragmentProcessor {
public:
~GrSingleTextureEffect() override;
SkString dumpInfo() const override {
SkString str;
str.appendf("Texture: %d", fTextureSampler.texture()->uniqueID().asUInt());
@ -33,26 +35,25 @@ public:
protected:
/** unfiltered, clamp mode */
GrSingleTextureEffect(GrTexture*, sk_sp<GrColorSpaceXform>, const SkMatrix&,
OptimizationFlags optFlags);
GrSingleTextureEffect(GrTexture*, sk_sp<GrColorSpaceXform>, const SkMatrix&);
/** clamp mode */
GrSingleTextureEffect(GrTexture*, sk_sp<GrColorSpaceXform>, const SkMatrix&,
GrSamplerParams::FilterMode filterMode, OptimizationFlags optFlags);
GrSamplerParams::FilterMode filterMode);
GrSingleTextureEffect(GrTexture*,
sk_sp<GrColorSpaceXform>,
const SkMatrix&,
const GrSamplerParams&,
OptimizationFlags optFlags);
const GrSamplerParams&);
/** unfiltered, clamp mode */
GrSingleTextureEffect(GrContext*, OptimizationFlags, sk_sp<GrTextureProxy>,
sk_sp<GrColorSpaceXform>, const SkMatrix&);
GrSingleTextureEffect(GrContext*,
sk_sp<GrTextureProxy>, sk_sp<GrColorSpaceXform>, const SkMatrix&);
/** clamp mode */
GrSingleTextureEffect(GrContext*, OptimizationFlags, sk_sp<GrTextureProxy>,
sk_sp<GrColorSpaceXform>, const SkMatrix&,
GrSingleTextureEffect(GrContext*,
sk_sp<GrTextureProxy>, sk_sp<GrColorSpaceXform>, const SkMatrix&,
GrSamplerParams::FilterMode filterMode);
GrSingleTextureEffect(GrContext*, OptimizationFlags, sk_sp<GrTextureProxy>,
sk_sp<GrColorSpaceXform>, const SkMatrix&, const GrSamplerParams&);
GrSingleTextureEffect(GrContext*,
sk_sp<GrTextureProxy>, sk_sp<GrColorSpaceXform>, const SkMatrix&,
const GrSamplerParams&);
/**
* Can be used as a helper to implement subclass onComputeInvariantOutput(). It assumes that
@ -70,19 +71,6 @@ protected:
}
}
/**
* Can be used as a helper to implement subclass onOptimizationFlags(). It assumes that
* the subclass output color will be a modulation of the input color with a value read from the
* texture.
*/
static OptimizationFlags ModulationFlags(GrPixelConfig config) {
if (GrPixelConfigIsOpaque(config)) {
return kModulatesInput_OptimizationFlag | kPreservesOpaqueInput_OptimizationFlag;
} else {
return kModulatesInput_OptimizationFlag;
}
}
private:
GrCoordTransform fCoordTransform;
TextureSampler fTextureSampler;

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

@ -208,25 +208,14 @@ sk_sp<GrFragmentProcessor> GrTextureDomainEffect::Make(GrTexture* texture,
}
}
inline GrFragmentProcessor::OptimizationFlags GrTextureDomainEffect::OptFlags(
GrTexture* texture, GrTextureDomain::Mode mode) {
if (mode == GrTextureDomain::kDecal_Mode || !GrPixelConfigIsOpaque(texture->config())) {
return GrFragmentProcessor::kModulatesInput_OptimizationFlag;
} else {
return GrFragmentProcessor::kModulatesInput_OptimizationFlag |
GrFragmentProcessor::kPreservesOpaqueInput_OptimizationFlag;
}
}
GrTextureDomainEffect::GrTextureDomainEffect(GrTexture* texture,
sk_sp<GrColorSpaceXform> colorSpaceXform,
const SkMatrix& matrix,
const SkRect& domain,
GrTextureDomain::Mode mode,
GrSamplerParams::FilterMode filterMode)
: GrSingleTextureEffect(texture, std::move(colorSpaceXform), matrix, filterMode,
OptFlags(texture, mode))
, fTextureDomain(texture, domain, mode) {
: GrSingleTextureEffect(texture, std::move(colorSpaceXform), matrix, filterMode)
, fTextureDomain(texture, domain, mode) {
SkASSERT(mode != GrTextureDomain::kRepeat_Mode ||
filterMode == GrSamplerParams::kNone_FilterMode);
this->initClassID<GrTextureDomainEffect>();
@ -334,8 +323,7 @@ sk_sp<GrFragmentProcessor> GrDeviceSpaceTextureDecalFragmentProcessor::Make(GrTe
GrDeviceSpaceTextureDecalFragmentProcessor::GrDeviceSpaceTextureDecalFragmentProcessor(
GrTexture* texture, const SkIRect& subset, const SkIPoint& deviceSpaceOffset)
: INHERITED(kModulatesInput_OptimizationFlag)
, fTextureSampler(texture, GrSamplerParams::ClampNoFilter())
: fTextureSampler(texture, GrSamplerParams::ClampNoFilter())
, fTextureDomain(texture, GrTextureDomain::MakeTexelDomain(subset),
GrTextureDomain::kDecal_Mode) {
this->addTextureSampler(&fTextureSampler);

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

@ -178,8 +178,6 @@ private:
GrTextureDomain::Mode,
GrSamplerParams::FilterMode);
static OptimizationFlags OptFlags(GrTexture* texture, GrTextureDomain::Mode mode);
GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;
void onGetGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const override;

56
src/gpu/effects/GrXfermodeFragmentProcessor.cpp
View File

@ -19,7 +19,7 @@ class ComposeTwoFragmentProcessor : public GrFragmentProcessor {
public:
ComposeTwoFragmentProcessor(sk_sp<GrFragmentProcessor> src, sk_sp<GrFragmentProcessor> dst,
SkBlendMode mode)
: INHERITED(OptFlags(src.get(), dst.get(), mode)), fMode(mode) {
: fMode(mode) {
this->initClassID<ComposeTwoFragmentProcessor>();
SkDEBUGCODE(int shaderAChildIndex = )this->registerChildProcessor(std::move(src));
SkDEBUGCODE(int shaderBChildIndex = )this->registerChildProcessor(std::move(dst));
@ -35,18 +35,7 @@ public:
SkBlendMode getMode() const { return fMode; }
private:
static OptimizationFlags OptFlags(const GrFragmentProcessor* src,
const GrFragmentProcessor* dst, SkBlendMode mode) {
// We only attempt the constant output optimization.
// The CPU and GPU implementations differ significantly for the advanced modes.
if (mode <= SkBlendMode::kLastSeparableMode && src->hasConstantOutputForConstantInput() &&
dst->hasConstantOutputForConstantInput()) {
return kConstantOutputForConstantInput_OptimizationFlag;
}
return kNone_OptimizationFlags;
}
protected:
bool onIsEqual(const GrFragmentProcessor& other) const override {
const ComposeTwoFragmentProcessor& cs = other.cast<ComposeTwoFragmentProcessor>();
return fMode == cs.fMode;
@ -56,17 +45,7 @@ private:
inout->setToUnknown();
}
GrColor4f constantOutputForConstantInput(GrColor4f input) const override {
float alpha = input.fRGBA[3];
input = input.opaque();
GrColor4f srcColor = ConstantOutputForConstantInput(this->childProcessor(0), input);
GrColor4f dstColor = ConstantOutputForConstantInput(this->childProcessor(1), input);
SkPM4f src = GrColor4fToSkPM4f(srcColor);
SkPM4f dst = GrColor4fToSkPM4f(dstColor);
auto proc = SkXfermode::GetProc4f(fMode);
return SkPM4fToGrColor4f(proc(src, dst)).mulByScalar(alpha);
}
private:
GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;
SkBlendMode fMode;
@ -166,7 +145,8 @@ public:
};
ComposeOneFragmentProcessor(sk_sp<GrFragmentProcessor> dst, SkBlendMode mode, Child child)
: INHERITED(OptFlags(dst.get(), mode)), fMode(mode), fChild(child) {
: fMode(mode)
, fChild(child) {
this->initClassID<ComposeOneFragmentProcessor>();
SkDEBUGCODE(int dstIndex = )this->registerChildProcessor(std::move(dst));
SkASSERT(0 == dstIndex);
@ -192,16 +172,7 @@ public:
Child child() const { return fChild; }
private:
OptimizationFlags OptFlags(const GrFragmentProcessor* child, SkBlendMode mode) {
// We only attempt the constant output optimization.
// The CPU and GPU implementations differ significantly for the advanced modes.
if (mode <= SkBlendMode::kLastSeparableMode && child->hasConstantOutputForConstantInput()) {
return kConstantOutputForConstantInput_OptimizationFlag;
}
return kNone_OptimizationFlags;
}
protected:
bool onIsEqual(const GrFragmentProcessor& that) const override {
return fMode == that.cast<ComposeOneFragmentProcessor>().fMode;
}
@ -232,21 +203,6 @@ private:
}
}
GrColor4f constantOutputForConstantInput(GrColor4f inputColor) const override {
GrColor4f childColor =
ConstantOutputForConstantInput(this->childProcessor(0), GrColor4f::OpaqueWhite());
SkPM4f src, dst;
if (kSrc_Child == fChild) {
src = GrColor4fToSkPM4f(childColor);
dst = GrColor4fToSkPM4f(inputColor);
} else {
src = GrColor4fToSkPM4f(inputColor);
dst = GrColor4fToSkPM4f(childColor);
}
auto proc = SkXfermode::GetProc4f(fMode);
return SkPM4fToGrColor4f(proc(src, dst));
}
private:
GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;

30
src/gpu/effects/GrYUVEffect.cpp
View File

@ -155,17 +155,19 @@ public:
};
private:
YUVtoRGBEffect(GrContext* ctx, sk_sp<GrTextureProxy> yProxy, sk_sp<GrTextureProxy> uProxy,
sk_sp<GrTextureProxy> vProxy, const SkMatrix yuvMatrix[3],
GrSamplerParams::FilterMode uvFilterMode, SkYUVColorSpace colorSpace, bool nv12)
: INHERITED(kPreservesOpaqueInput_OptimizationFlag)
, fYTransform(ctx, yuvMatrix[0], yProxy.get(), GrSamplerParams::kNone_FilterMode)
, fYSampler(ctx->textureProvider(), std::move(yProxy))
, fUTransform(ctx, yuvMatrix[1], uProxy.get(), uvFilterMode)
, fUSampler(ctx->textureProvider(), std::move(uProxy), uvFilterMode)
, fVSampler(ctx->textureProvider(), vProxy, uvFilterMode)
, fColorSpace(colorSpace)
, fNV12(nv12) {
YUVtoRGBEffect(GrContext* ctx,
sk_sp<GrTextureProxy> yProxy,
sk_sp<GrTextureProxy> uProxy,
sk_sp<GrTextureProxy> vProxy,
const SkMatrix yuvMatrix[3], GrSamplerParams::FilterMode uvFilterMode,
SkYUVColorSpace colorSpace, bool nv12)
: fYTransform(ctx, yuvMatrix[0], yProxy.get(), GrSamplerParams::kNone_FilterMode)
, fYSampler(ctx->textureProvider(), std::move(yProxy))
, fUTransform(ctx, yuvMatrix[1], uProxy.get(), uvFilterMode)
, fUSampler(ctx->textureProvider(), std::move(uProxy), uvFilterMode)
, fVSampler(ctx->textureProvider(), vProxy, uvFilterMode)
, fColorSpace(colorSpace)
, fNV12(nv12) {
this->initClassID<YUVtoRGBEffect>();
this->addCoordTransform(&fYTransform);
this->addTextureSampler(&fYSampler);
@ -226,10 +228,8 @@ public:
RGBToYUVEffect(sk_sp<GrFragmentProcessor> rgbFP, SkYUVColorSpace colorSpace,
OutputChannels output)
// This could advertise kConstantOutputForConstantInput, but doesn't seem useful.
: INHERITED(kPreservesOpaqueInput_OptimizationFlag)
, fColorSpace(colorSpace)
, fOutputChannels(output) {
: fColorSpace(colorSpace)
, fOutputChannels(output) {
this->initClassID<RGBToYUVEffect>();
this->registerChildProcessor(std::move(rgbFP));
}

7
tests/GLProgramsTest.cpp
View File

@ -78,7 +78,9 @@ public:
}
private:
BigKeyProcessor() : INHERITED(kNone_OptimizationFlags) { this->initClassID<BigKeyProcessor>(); }
BigKeyProcessor() {
this->initClassID<BigKeyProcessor>();
}
virtual void onGetGLSLProcessorKey(const GrShaderCaps& caps,
GrProcessorKeyBuilder* b) const override {
GLBigKeyProcessor::GenKey(*this, caps, b);
@ -120,8 +122,7 @@ private:
typedef GrGLSLFragmentProcessor INHERITED;
};
BlockInputFragmentProcessor(sk_sp<GrFragmentProcessor> child)
: INHERITED(kNone_OptimizationFlags) {
BlockInputFragmentProcessor(sk_sp<GrFragmentProcessor> child) {
this->initClassID<BlockInputFragmentProcessor>();
this->registerChildProcessor(std::move(child));
}

4
tests/ImageStorageTest.cpp
View File

@ -28,8 +28,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageStorageLoad, reporter, ctxInfo) {
private:
TestFP(sk_sp<GrTexture> texture, GrSLMemoryModel mm, GrSLRestrict restrict)
: INHERITED(kNone_OptimizationFlags)
, fImageStorageAccess(std::move(texture), kRead_GrIOType, mm, restrict) {
: fImageStorageAccess(std::move(texture), kRead_GrIOType, mm, restrict) {
this->initClassID<TestFP>();
this->addImageStorageAccess(&fImageStorageAccess);
}
@ -74,7 +73,6 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageStorageLoad, reporter, ctxInfo) {
}
ImageStorageAccess fImageStorageAccess;
typedef GrFragmentProcessor INHERITED;
};
static constexpr int kS = 256;

141
tests/ProcessorTest.cpp
View File

@ -70,7 +70,7 @@ public:
private:
TestFP(const SkTArray<sk_sp<GrTexture>>& textures, const SkTArray<sk_sp<GrBuffer>>& buffers,
const SkTArray<Image>& images)
: INHERITED(kNone_OptimizationFlags), fSamplers(4), fBuffers(4), fImages(4) {
: fSamplers(4), fBuffers(4), fImages(4) {
for (const auto& texture : textures) {
this->addTextureSampler(&fSamplers.emplace_back(texture.get()));
}
@ -83,8 +83,7 @@ private:
}
}
TestFP(sk_sp<GrFragmentProcessor> child)
: INHERITED(kNone_OptimizationFlags), fSamplers(4), fBuffers(4), fImages(4) {
TestFP(sk_sp<GrFragmentProcessor> child) : fSamplers(4), fBuffers(4), fImages(4) {
this->registerChildProcessor(std::move(child));
}
@ -107,7 +106,6 @@ private:
GrTAllocator<TextureSampler> fSamplers;
GrTAllocator<BufferAccess> fBuffers;
GrTAllocator<ImageStorageAccess> fImages;
typedef GrFragmentProcessor INHERITED;
};
}
@ -232,139 +230,4 @@ DEF_GPUTEST_FOR_ALL_CONTEXTS(ProcessorRefTest, reporter, ctxInfo) {
}
}
}
// This test uses the random GrFragmentProcessor test factory, which relies on static initializers.
#if SK_ALLOW_STATIC_GLOBAL_INITIALIZERS
static GrColor texel_color(int i, int j) {
SkASSERT((unsigned)i < 256 && (unsigned)j < 256);
GrColor color = GrColorPackRGBA(j, (uint8_t)(i + j), (uint8_t)(2 * j - i), i);
return GrPremulColor(color);
}
static GrColor4f texel_color4f(int i, int j) { return GrColor4f::FromGrColor(texel_color(i, j)); }
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ProcessorOptimizationValidationTest, reporter, ctxInfo) {
GrContext* context = ctxInfo.grContext();
using FPFactory = GrProcessorTestFactory<GrFragmentProcessor>;
SkRandom random;
sk_sp<GrRenderTargetContext> rtc = context->makeRenderTargetContext(
SkBackingFit::kExact, 256, 256, kRGBA_8888_GrPixelConfig, nullptr);
GrSurfaceDesc desc;
desc.fWidth = 256;
desc.fHeight = 256;
desc.fFlags = kRenderTarget_GrSurfaceFlag;
desc.fConfig = kRGBA_8888_GrPixelConfig;
sk_sp<GrTexture> tex0(context->textureProvider()->createTexture(desc, SkBudgeted::kYes));
desc.fConfig = kAlpha_8_GrPixelConfig;
sk_sp<GrTexture> tex1(context->textureProvider()->createTexture(desc, SkBudgeted::kYes));
GrTexture* textures[] = {tex0.get(), tex1.get()};
GrProcessorTestData testData(&random, context, rtc.get(), textures);
std::unique_ptr<GrColor> data(new GrColor[256 * 256]);
for (int y = 0; y < 256; ++y) {
for (int x = 0; x < 256; ++x) {
data.get()[256 * y + x] = texel_color(x, y);
}
}
desc.fConfig = kRGBA_8888_GrPixelConfig;
sk_sp<GrTexture> dataTexture(context->textureProvider()->createTexture(
desc, SkBudgeted::kYes, data.get(), 256 * sizeof(GrColor)));
// Because processors factories configure themselves in random ways, this is not exhaustive.
for (int i = 0; i < FPFactory::Count(); ++i) {
int timesToInvokeFactory = 5;
// Increase the number of attempts if the FP has child FPs since optimizations likely depend
// on child optimizations being present.
sk_sp<GrFragmentProcessor> fp = FPFactory::MakeIdx(i, &testData);
for (int j = 0; j < fp->numChildProcessors(); ++j) {
// This value made a reasonable trade off between time and coverage when this test was
// written.
timesToInvokeFactory *= FPFactory::Count() / 2;
}
for (int j = 0; j < timesToInvokeFactory; ++j) {
fp = FPFactory::MakeIdx(i, &testData);
if (!fp->hasConstantOutputForConstantInput() && !fp->preservesOpaqueInput() &&
!fp->modulatesInput()) {
continue;
}
GrPaint paint;
paint.addColorTextureProcessor(dataTexture.get(), nullptr, SkMatrix::I());
paint.addColorFragmentProcessor(fp);
paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
rtc->drawRect(GrNoClip(), std::move(paint), GrAA::kNo, SkMatrix::I(),
SkRect::MakeWH(256.f, 256.f));
memset(data.get(), 0x0, sizeof(GrColor) * 256 * 256);
rtc->readPixels(
SkImageInfo::Make(256, 256, kRGBA_8888_SkColorType, kPremul_SkAlphaType),
data.get(), 0, 0, 0);
bool passing = true;
if (0) { // Useful to see what FPs are being tested.
SkString children;
for (int c = 0; c < fp->numChildProcessors(); ++c) {
if (!c) {
children.append("(");
}
children.append(fp->childProcessor(c).name());
children.append(c == fp->numChildProcessors() - 1 ? ")" : ", ");
}
SkDebugf("%s %s\n", fp->name(), children.c_str());
}
for (int y = 0; y < 256 && passing; ++y) {
for (int x = 0; x < 256 && passing; ++x) {
GrColor input = texel_color(x, y);
GrColor output = data.get()[y * 256 + x];
if (fp->modulatesInput()) {
// A modulating processor is allowed to modulate either the input color or
// just the input alpha.
bool legalColorModulation =
GrColorUnpackA(output) <= GrColorUnpackA(input) &&
GrColorUnpackR(output) <= GrColorUnpackR(input) &&
GrColorUnpackG(output) <= GrColorUnpackG(input) &&
GrColorUnpackB(output) <= GrColorUnpackB(input);
bool legalAlphaModulation =
GrColorUnpackA(output) <= GrColorUnpackA(input) &&
GrColorUnpackR(output) <= GrColorUnpackA(input) &&
GrColorUnpackG(output) <= GrColorUnpackA(input) &&
GrColorUnpackB(output) <= GrColorUnpackA(input);
if (!legalColorModulation && !legalAlphaModulation) {
ERRORF(reporter,
"\"Modulating\" processor %s made color/alpha value larger. "
"Input: 0x%0x8, Output: 0x%08x.",
fp->name(), input, output);
passing = false;
}
}
GrColor4f input4f = texel_color4f(x, y);
GrColor4f output4f = GrColor4f::FromGrColor(output);
GrColor4f expected4f;
if (fp->hasConstantOutputForConstantInput(input4f, &expected4f)) {
float rDiff = fabsf(output4f.fRGBA[0] - expected4f.fRGBA[0]);
float gDiff = fabsf(output4f.fRGBA[1] - expected4f.fRGBA[1]);
float bDiff = fabsf(output4f.fRGBA[2] - expected4f.fRGBA[2]);
float aDiff = fabsf(output4f.fRGBA[3] - expected4f.fRGBA[3]);
static constexpr float kTol = 3 / 255.f;
if (rDiff > kTol || gDiff > kTol || bDiff > kTol || aDiff > kTol) {
ERRORF(reporter,
"Processor %s claimed output for const input doesn't match "
"actual output.",
fp->name());
passing = false;
}
}
if (GrColorIsOpaque(input) && fp->preservesOpaqueInput() &&
!GrColorIsOpaque(output)) {
ERRORF(reporter,
"Processor %s claimed opaqueness is preserved but it is not. Input: "
"0x%0x8, Output: 0x%08x.",
fp->name(), input, output);
passing = false;
}
}
}
}
}
}
#endif
#endif