inout->setToUnknown();
}
- 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) {
+ 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) {
this->initClassID<GrPerlinNoise2Effect>();
this->addTextureSampler(&fPermutationsSampler);
this->addTextureSampler(&fNoiseSampler);
TextureSampler fNoiseSampler;
SkPerlinNoiseShader2::PaintingData* fPaintingData;
-private:
typedef GrFragmentProcessor INHERITED;
};
inout->setToUnknown();
}
- GrImprovedPerlinNoiseEffect(int octaves, SkScalar z,
+ GrImprovedPerlinNoiseEffect(int octaves, SkScalar z,
SkPerlinNoiseShader2::PaintingData* paintingData,
GrTexture* permutationsTexture, GrTexture* gradientTexture,
const SkMatrix& matrix)
- : fOctaves(octaves)
- , fZ(z)
- , fPermutationsSampler(permutationsTexture)
- , fGradientSampler(gradientTexture)
- , fPaintingData(paintingData) {
+ : INHERITED(kNone_OptimizationFlags)
+ , fOctaves(octaves)
+ , fZ(z)
+ , fPermutationsSampler(permutationsTexture)
+ , fGradientSampler(gradientTexture)
+ , fPaintingData(paintingData) {
this->initClassID<GrImprovedPerlinNoiseEffect>();
this->addTextureSampler(&fPermutationsSampler);
this->addTextureSampler(&fGradientSampler);
TextureSampler fGradientSampler;
SkPerlinNoiseShader2::PaintingData* fPaintingData;
-private:
typedef GrFragmentProcessor INHERITED;
};
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] &&
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);
*/
static sk_sp<GrFragmentProcessor> RunInSeries(sk_sp<GrFragmentProcessor>*, int cnt);
- GrFragmentProcessor()
- : INHERITED()
- , fUsesDistanceVectorField(false)
- , fUsesLocalCoords(false) {}
-
~GrFragmentProcessor() override;
GrGLSLFragmentProcessor* createGLSLInstance() const;
const GrFragmentProcessor& childProcessor(int index) const { return *fChildProcessors[index]; }
/** Do any of the coordtransforms for this processor require local coords? */
- bool usesLocalCoords() const { return fUsesLocalCoords; }
+ bool usesLocalCoords() const { return SkToBool(fFlags & kUsesLocalCoords_Flag); }
/** Does this FP need a vector to the nearest edge? */
- bool usesDistanceVectorField() const { return fUsesDistanceVectorField; }
+ 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);
+ }
/** 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
&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
*/
virtual void onComputeInvariantOutput(GrInvariantOutput* inout) const = 0;
- /* Sub-classes should set this to true in their constructors if they need access to a distance
+ /**
+ * Sub-classes should call this in their constructors if they need access to a distance
* vector field to the nearest edge
*/
- bool fUsesDistanceVectorField;
+ void setWillUseDistanceVectorField() { fFlags |= kUsesDistanceVectorField_Flag; }
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. */
bool hasSameTransforms(const GrFragmentProcessor&) const;
- bool fUsesLocalCoords;
+ enum PrivateFlags {
+ kFirstPrivateFlag = kAll_OptimizationFlags + 1,
+ kUsesLocalCoords_Flag = kFirstPrivateFlag,
+ kUsesDistanceVectorField_Flag = kFirstPrivateFlag << 1,
+ };
+
+ mutable uint32_t fFlags = 0;
SkSTArray<4, const GrCoordTransform*, true> fCoordTransforms;
* 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
GrProcessorTestData(SkRandom* random,
GrContext* context,
const GrRenderTargetContext* renderTargetContext,
- GrTexture* textures[2])
- : fRandom(random)
- , fContext(context)
- , fRenderTargetContext(renderTargetContext) {
+ GrTexture* const textures[2])
+ : fRandom(random), fContext(context), fRenderTargetContext(renderTargetContext) {
fTextures[0] = textures[0];
fTextures[1] = textures[1];
* 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) { \
+ 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 &(T a, X b) { \
return (X) (+a & +b); \
} \
template <typename T> \
- inline X operator & (X a, T b) { \
+ 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);
////////////////////////////////////////////////////////////////////////////////
InputMode inputMode() const { return fMode; }
private:
- GrConstColorProcessor(GrColor4f color, InputMode mode) : fColor(color), fMode(mode) {
+ 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) {
this->initClassID<GrConstColorProcessor>();
}
bool onIsEqual(const GrFragmentProcessor&) const override;
void onComputeInvariantOutput(GrInvariantOutput* inout) const override;
+ GrColor4f constantOutputForConstantInput(GrColor4f input) const override;
GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
typedef GrGLSLFragmentProcessor INHERITED;
};
-
private:
- ColorMatrixEffect(const SkScalar matrix[20]) {
+ // 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) {
memcpy(fMatrix, matrix, sizeof(SkScalar) * 20);
this->initClassID<ColorMatrixEffect>();
}
// premul'd.
class LightingFP : public GrFragmentProcessor {
public:
- LightingFP(sk_sp<GrFragmentProcessor> normalFP, sk_sp<SkLights> lights) {
-
+ LightingFP(sk_sp<GrFragmentProcessor> normalFP, sk_sp<SkLights> lights)
+ : INHERITED(kPreservesOpaqueInput_OptimizationFlag) {
// fuse all ambient lights into a single one
fAmbientColor = lights->ambientLightColor();
for (int i = 0; i < lights->numLights(); ++i) {
SkTArray<SkLights::Light> fDirectionalLights;
SkColor3f fAmbientColor;
+
+ typedef GrFragmentProcessor INHERITED;
};
////////////////////////////////////////////////////////////////////////////
class NormalBevelFP : public GrFragmentProcessor {
public:
NormalBevelFP(SkNormalSource::BevelType bevelType, SkScalar bevelWidth, SkScalar bevelHeight)
- : fBevelType(bevelType)
- , fBevelWidth(bevelWidth)
- , fBevelHeight(bevelHeight) {
+ : INHERITED(kNone_OptimizationFlags)
+ , fBevelType(bevelType)
+ , fBevelWidth(bevelWidth)
+ , fBevelHeight(bevelHeight) {
this->initClassID<NormalBevelFP>();
- fUsesDistanceVectorField = true;
+ this->setWillUseDistanceVectorField();
}
class GLSLNormalBevelFP : public GLSLNormalFP {
SkNormalSource::BevelType fBevelType;
SkScalar fBevelWidth;
SkScalar fBevelHeight;
+
+ typedef GrFragmentProcessor INHERITED;
};
sk_sp<GrFragmentProcessor> SkNormalBevelSourceImpl::asFragmentProcessor(
class NormalFlatFP : public GrFragmentProcessor {
public:
- NormalFlatFP() {
+ NormalFlatFP() : INHERITED(kConstantOutputForConstantInput_OptimizationFlag) {
this->initClassID<NormalFlatFP>();
}
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();
}
-
-private:
+ GrColor4f constantOutputForConstantInput(GrColor4f) const override {
+ return GrColor4f(0, 0, 1, 0);
+ }
GrGLSLFragmentProcessor* onCreateGLSLInstance() const override { return new GLSLNormalFlatFP; }
bool onIsEqual(const GrFragmentProcessor&) const override { return true; }
+
+ typedef GrFragmentProcessor INHERITED;
};
sk_sp<GrFragmentProcessor> SkNormalFlatSourceImpl::asFragmentProcessor(
class NormalMapFP : public GrFragmentProcessor {
public:
NormalMapFP(sk_sp<GrFragmentProcessor> mapFP, const SkMatrix& invCTM)
- : fInvCTM(invCTM) {
+ : INHERITED(kNone_OptimizationFlags), fInvCTM(invCTM) {
this->registerChildProcessor(mapFP);
this->initClassID<NormalMapFP>();
}
SkMatrix fInvCTM;
+
+ typedef GrFragmentProcessor INHERITED;
};
sk_sp<GrFragmentProcessor> SkNormalMapSourceImpl::asFragmentProcessor(
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,
float innerThreshold,
float outerThreshold,
const SkIRect& bounds)
- : 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) {
+ : 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) {
this->initClassID<GrAlphaThresholdFragmentProcessor>();
this->addCoordTransform(&fImageCoordTransform);
this->addTextureSampler(&fImageTextureSampler);
GrColorSpaceXform* colorSpaceXform() const { return fColorSpaceXform.get(); }
private:
+ static OptimizationFlags OptFlags(float outerThreshold);
+
GrAlphaThresholdFragmentProcessor(GrTexture* texture,
sk_sp<GrColorSpaceXform> colorSpaceXform,
GrTexture* maskTexture,
float textureRadius,
float solidRadius,
GrTexture* blurProfile)
- : fCircle(circle)
- , fSolidRadius(solidRadius)
- , fTextureRadius(textureRadius)
- , fBlurProfileSampler(blurProfile, GrSamplerParams::kBilerp_FilterMode) {
+ : INHERITED(kModulatesInput_OptimizationFlag)
+ , fCircle(circle)
+ , fSolidRadius(solidRadius)
+ , fTextureRadius(textureRadius)
+ , fBlurProfileSampler(blurProfile, GrSamplerParams::kBilerp_FilterMode) {
this->initClassID<GrCircleBlurFragmentProcessor>();
this->addTextureSampler(&fBlurProfileSampler);
}
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)
- : fK1(k1), fK2(k2), fK3(k3), fK4(k4), fEnforcePMColor(enforcePMColor) {
+ : INHERITED(kNone_OptimizationFlags)
+ , fK1(k1)
+ , fK2(k2)
+ , fK3(k3)
+ , fK4(k4)
+ , fEnforcePMColor(enforcePMColor) {
this->initClassID<ArithmeticFP>();
SkASSERT(dst);
SkDEBUGCODE(int dstIndex =) this->registerChildProcessor(std::move(dst));
return blurProfile;
}
-GrRectBlurEffect::GrRectBlurEffect(const SkRect& rect, float sigma, GrTexture *blurProfile,
+GrRectBlurEffect::GrRectBlurEffect(const SkRect& rect, float sigma, GrTexture* blurProfile,
GrSLPrecision precision)
- : fRect(rect)
- , fSigma(sigma)
- , fBlurProfileSampler(blurProfile)
- , fPrecision(precision) {
+ : INHERITED(kModulatesInput_OptimizationFlag)
+ , fRect(rect)
+ , fSigma(sigma)
+ , fBlurProfileSampler(blurProfile)
+ , fPrecision(precision) {
this->initClassID<GrRectBlurEffect>();
this->addTextureSampler(&fBlurProfileSampler);
}
inout->mulByUnknownSingleComponent();
}
-GrRRectBlurEffect::GrRRectBlurEffect(float sigma, const SkRRect& rrect, GrTexture *ninePatchTexture)
- : fRRect(rrect),
- fSigma(sigma),
- fNinePatchSampler(ninePatchTexture) {
+GrRRectBlurEffect::GrRRectBlurEffect(float sigma, const SkRRect& rrect, GrTexture* ninePatchTexture)
+ : INHERITED(kModulatesInput_OptimizationFlag)
+ , fRRect(rrect)
+ , fSigma(sigma)
+ , fNinePatchSampler(ninePatchTexture) {
this->initClassID<GrRRectBlurEffect>();
this->addTextureSampler(&fNinePatchSampler);
}
}
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)
- : 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)
+ : 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) {
this->initClassID<GrDisplacementMapEffect>();
this->addCoordTransform(&fDisplacementTransform);
this->addTextureSampler(&fDisplacementSampler);
class GaussianEdgeFP : public GrFragmentProcessor {
public:
- GaussianEdgeFP() {
+ GaussianEdgeFP() : INHERITED(kNone_OptimizationFlags) {
this->initClassID<GaussianEdgeFP>();
// enable output of distance information for shape
- fUsesDistanceVectorField = true;
+ this->setWillUseDistanceVectorField();
}
class GLSLGaussianEdgeFP : public GrGLSLFragmentProcessor {
}
bool onIsEqual(const GrFragmentProcessor& proc) const override { return true; }
+
+ typedef GrFragmentProcessor INHERITED;
};
////////////////////////////////////////////////////////////////////////////
}
-class GrGLLightingEffect : public GrGLSLFragmentProcessor {
+class GrGLLightingEffect : public GrGLSLFragmentProcessor {
public:
GrGLLightingEffect() : fLight(nullptr) { }
virtual ~GrGLLightingEffect() { delete fLight; }
const SkMatrix& matrix,
BoundaryMode boundaryMode,
const SkIRect* srcBounds)
- : INHERITED(texture, nullptr, SkMatrix::I())
- , fLight(light)
- , fSurfaceScale(surfaceScale)
- , fFilterMatrix(matrix)
- , fBoundaryMode(boundaryMode)
- , fDomain(create_domain(texture, srcBounds, GrTextureDomain::kDecal_Mode)) {
+ // 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)) {
fLight->ref();
}
};
private:
- LumaColorFilterEffect() {
+ LumaColorFilterEffect() : INHERITED(kConstantOutputForConstantInput_OptimizationFlag) {
this->initClassID<LumaColorFilterEffect>();
}
// 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 {
#include "../private/GrGLSL.h"
class GrMagnifierEffect : public GrSingleTextureEffect {
-
public:
static sk_sp<GrFragmentProcessor> Make(GrTexture* texture,
sk_sp<GrColorSpaceXform> colorSpaceXform,
float yInvZoom,
float xInvInset,
float yInvInset)
- : INHERITED(texture, std::move(colorSpaceXform), SkMatrix::I())
- , fBounds(bounds)
- , fXOffset(xOffset)
- , fYOffset(yOffset)
- , fXInvZoom(xInvZoom)
- , fYInvZoom(yInvZoom)
- , fXInvInset(xInvInset)
- , fYInvInset(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) {
this->initClassID<GrMagnifierEffect>();
}
* color.
*/
class GrMorphologyEffect : public Gr1DKernelEffect {
-
public:
-
enum MorphologyType {
kErode_MorphologyType,
kDilate_MorphologyType,
Direction direction,
int radius,
MorphologyType type)
- : INHERITED(texture, direction, radius)
- , fType(type)
- , fUseRange(false) {
+ : INHERITED(texture, direction, radius, ModulationFlags(texture->config()))
+ , fType(type)
+ , fUseRange(false) {
this->initClassID<GrMorphologyEffect>();
}
int radius,
MorphologyType type,
const float range[2])
- : INHERITED(texture, direction, radius)
- , fType(type)
- , fUseRange(true) {
+ : INHERITED(texture, direction, radius, ModulationFlags(texture->config()))
+ , fType(type)
+ , fUseRange(true) {
this->initClassID<GrMorphologyEffect>();
fRange[0] = range[0];
fRange[1] = range[1];
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 {}
return sk_sp<OverdrawFragmentProcessor>(new OverdrawFragmentProcessor(grColors));
}
-OverdrawFragmentProcessor::OverdrawFragmentProcessor(const GrColor4f* colors) {
+// 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) {
this->initClassID<OverdrawFragmentProcessor>();
memcpy(fColors, colors, SkOverdrawColorFilter::kNumColors * sizeof(GrColor4f));
}
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)
- : fType(type)
- , fCoordTransform(matrix)
- , fNumOctaves(numOctaves)
- , fStitchTiles(stitchTiles)
- , fPermutationsSampler(permutationsTexture)
- , fNoiseSampler(noiseTexture)
- , fPaintingData(paintingData) {
+ : INHERITED(kNone_OptimizationFlags)
+ , fType(type)
+ , fCoordTransform(matrix)
+ , fNumOctaves(numOctaves)
+ , fStitchTiles(stitchTiles)
+ , fPermutationsSampler(permutationsTexture)
+ , fNoiseSampler(noiseTexture)
+ , fPaintingData(paintingData) {
this->initClassID<GrPerlinNoiseEffect>();
this->addTextureSampler(&fPermutationsSampler);
this->addTextureSampler(&fNoiseSampler);
};
RRectsGaussianEdgeFP(const SkRRect& first, const SkRRect& second, SkScalar radius)
- : fFirst(first)
- , fSecond(second)
- , fRadius(radius) {
+ : INHERITED(kNone_OptimizationFlags), fFirst(first), fSecond(second), fRadius(radius) {
this->initClassID<RRectsGaussianEdgeFP>();
fFirstMode = ComputeMode(fFirst);
ColorTableEffect::ColorTableEffect(GrTexture* texture, GrTextureStripAtlas* atlas, int row,
unsigned flags)
- : fTextureSampler(texture)
- , fFlags(flags)
- , fAtlas(atlas)
- , fRow(row) {
+ : INHERITED(kNone_OptimizationFlags) // Not bothering with table-specific optimizations.
+ , fTextureSampler(texture)
+ , fFlags(flags)
+ , fAtlas(atlas)
+ , fRow(row) {
this->initClassID<ColorTableEffect>();
this->addTextureSampler(&fTextureSampler);
}
/////////////////////////////////////////////////////////////////////
-GrGradientEffect::GrGradientEffect(const CreateArgs& args) {
+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)) {
const SkGradientShaderBase& shader(*args.fShader);
fIsOpaque = shader.isOpaque();
class GLSLProcessor;
- GrGradientEffect(const CreateArgs&);
-
virtual ~GrGradientEffect();
bool useAtlas() const { return SkToBool(-1 != fRow); }
}
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
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;
const char* name() const override { return "Linear Gradient"; }
private:
- GrLinearGradient(const CreateArgs& args)
- : INHERITED(args) {
+ GrLinearGradient(const CreateArgs& args) : INHERITED(args, args.fShader->colorsAreOpaque()) {
this->initClassID<GrLinearGradient>();
}
const char* name() const override { return "Radial Gradient"; }
private:
- GrRadialGradient(const CreateArgs& args)
- : INHERITED(args) {
+ GrRadialGradient(const CreateArgs& args) : INHERITED(args, args.fShader->colorsAreOpaque()) {
this->initClassID<GrRadialGradient>();
}
const char* name() const override { return "Sweep Gradient"; }
private:
- GrSweepGradient(const CreateArgs& args)
- : INHERITED(args) {
+ GrSweepGradient(const CreateArgs& args) : INHERITED(args, args.fShader->colorsAreOpaque()) {
this->initClassID<GrSweepGradient>();
}
}
Edge2PtConicalEffect(const CreateArgs& args)
- : INHERITED(args) {
+ : INHERITED(args, false /* opaque: draws transparent black outside of the cone. */) {
const SkTwoPointConicalGradient& shader =
*static_cast<const SkTwoPointConicalGradient*>(args.fShader);
fCenterX1 = shader.getCenterX1();
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)
- , fFocalX(focalX)
- , fIsFlipped(static_cast<const SkTwoPointConicalGradient*>(args.fShader)->isFlippedGrad()) {
+ : INHERITED(args, false /* opaque: draws transparent black outside of the cone. */)
+ , fFocalX(focalX)
+ , fIsFlipped(IsFlipped(args)) {
this->initClassID<FocalOutside2PtConicalEffect>();
}
typedef GrGradientEffect INHERITED;
};
-class FocalOutside2PtConicalEffect::GLSLFocalOutside2PtConicalProcessor
+class FocalOutside2PtConicalEffect::GLSLFocalOutside2PtConicalProcessor
: public GrGradientEffect::GLSLProcessor {
public:
GLSLFocalOutside2PtConicalProcessor(const GrProcessor&);
}
FocalInside2PtConicalEffect(const CreateArgs& args, SkScalar focalX)
- : INHERITED(args), fFocalX(focalX) {
+ : INHERITED(args, args.fShader->colorsAreOpaque()), fFocalX(focalX) {
this->initClassID<FocalInside2PtConicalEffect>();
}
}
CircleInside2PtConicalEffect(const CreateArgs& args, const CircleConicalInfo& info)
- : INHERITED(args), fInfo(info) {
+ : INHERITED(args, args.fShader->colorsAreOpaque()), fInfo(info) {
this->initClassID<CircleInside2PtConicalEffect>();
}
}
CircleOutside2PtConicalEffect(const CreateArgs& args, const CircleConicalInfo& info)
- : INHERITED(args), fInfo(info) {
+ : INHERITED(args, false /* opaque: draws transparent black outside of the cone. */)
+ , fInfo(info) {
this->initClassID<CircleOutside2PtConicalEffect>();
const SkTwoPointConicalGradient& shader =
*static_cast<const SkTwoPointConicalGradient*>(args.fShader);
//
class ShadowEdgeFP : public GrFragmentProcessor {
public:
- ShadowEdgeFP() {
- this->initClassID<ShadowEdgeFP>();
- }
+ ShadowEdgeFP() : INHERITED(kNone_OptimizationFlags) { this->initClassID<ShadowEdgeFP>(); }
class GLSLShadowEdgeFP : public GrGLSLFragmentProcessor {
public:
}
bool onIsEqual(const GrFragmentProcessor& proc) const override { return true; }
+
+ typedef GrFragmentProcessor INHERITED;
};
///////////////////////////////////////////////////////////////////////////////////////////////////
void GrFragmentProcessor::addCoordTransform(const GrCoordTransform* transform) {
fCoordTransforms.push_back(transform);
- fUsesLocalCoords = true;
+ fFlags |= kUsesLocalCoords_Flag;
SkDEBUGCODE(transform->setInProcessor();)
}
this->combineRequiredFeatures(*child);
if (child->usesLocalCoords()) {
- fUsesLocalCoords = true;
+ fFlags |= kUsesLocalCoords_Flag;
}
if (child->usesDistanceVectorField()) {
- fUsesDistanceVectorField = true;
+ fFlags |= kUsesDistanceVectorField_Flag;
}
int index = fChildProcessors.count();
class PremulInputFragmentProcessor : public GrFragmentProcessor {
public:
- PremulInputFragmentProcessor() {
+ PremulInputFragmentProcessor()
+ : INHERITED(kPreservesOpaqueInput_OptimizationFlag |
+ kConstantOutputForConstantInput_OptimizationFlag) {
this->initClassID<PremulInputFragmentProcessor>();
}
const char* name() const override { return "PremultiplyInput"; }
-
private:
GrGLSLFragmentProcessor* onCreateGLSLInstance() const override {
class GLFP : public GrGLSLFragmentProcessor {
void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
inout->premulFourChannelColor();
}
+ GrColor4f constantOutputForConstantInput(GrColor4f input) const override {
+ return input.premul();
+ }
+
+ typedef GrFragmentProcessor INHERITED;
};
if (!fp) {
return nullptr;
class PremulFragmentProcessor : public GrFragmentProcessor {
public:
- PremulFragmentProcessor(sk_sp<GrFragmentProcessor> processor) {
+ PremulFragmentProcessor(sk_sp<GrFragmentProcessor> processor)
+ : INHERITED(OptFlags(processor.get())) {
this->initClassID<PremulFragmentProcessor>();
this->registerChildProcessor(processor);
}
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)) {
}
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;
class ReplaceInputFragmentProcessor : public GrFragmentProcessor {
public:
ReplaceInputFragmentProcessor(sk_sp<GrFragmentProcessor> child, GrColor4f color)
- : fColor(color) {
+ : INHERITED(OptFlags(child.get(), color)), fColor(color) {
this->initClassID<ReplaceInputFragmentProcessor>();
this->registerChildProcessor(std::move(child));
}
}
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
{}
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);
int cnt) {
class SeriesFragmentProcessor : public GrFragmentProcessor {
public:
- SeriesFragmentProcessor(sk_sp<GrFragmentProcessor>* children, int cnt){
+ SeriesFragmentProcessor(sk_sp<GrFragmentProcessor>* children, int cnt)
+ : INHERITED(OptFlags(children, cnt)) {
SkASSERT(cnt > 1);
this->initClassID<SeriesFragmentProcessor>();
for (int i = 0; i < cnt; ++i) {
};
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; }
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) {
#ifndef SkGrPriv_DEFINED
#define SkGrPriv_DEFINED
-#include "GrTypes.h"
#include "GrBlend.h"
+#include "GrTypes.h"
#include "SkImageInfo.h"
#include "SkMatrix.h"
+#include "SkPM4f.h"
#include "SkXfermodePriv.h"
class GrCaps;
//////////////////////////////////////////////////////////////////////////////
+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*);
kY_Direction,
};
- Gr1DKernelEffect(GrTexture* texture,
- Direction direction,
- int radius)
- : INHERITED(texture, nullptr, SkMatrix::I())
- , fDirection(direction)
- , fRadius(radius) {}
+ Gr1DKernelEffect(GrTexture* texture, Direction direction, int radius,
+ OptimizationFlags optFlags)
+ : INHERITED(texture, nullptr, SkMatrix::I(), optFlags)
+ , fDirection(direction)
+ , fRadius(radius) {}
virtual ~Gr1DKernelEffect() {}
}
private:
-
Direction fDirection;
int fRadius;
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))
- , fDomain(GrTextureDomain::IgnoredDomain()) {
+ : INHERITED(texture, std::move(colorSpaceXform), matrix,
+ GrSamplerParams(tileModes, GrSamplerParams::kNone_FilterMode),
+ ModulationFlags(texture->config()))
+ , 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))
- , fDomain(texture, domain, GrTextureDomain::kClamp_Mode) {
+ : INHERITED(texture, std::move(colorSpaceXform), matrix,
+ GrSamplerParams(SkShader::kClamp_TileMode, GrSamplerParams::kNone_FilterMode),
+ ModulationFlags(texture->config()))
+ , fDomain(texture, domain, GrTextureDomain::kClamp_Mode) {
this->initClassID<GrBicubicEffect>();
}
const GrSwizzle& swizzle,
PMConversion pmConversion,
const SkMatrix& matrix)
- : INHERITED(texture, nullptr, matrix)
- , fSwizzle(swizzle)
- , fPMConversion(pmConversion) {
+ : INHERITED(texture, nullptr, matrix, ModulationFlags(texture->config()))
+ , 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.
const GrSwizzle& swizzle,
PMConversion pmConversion,
const SkMatrix& matrix)
- : INHERITED(context, proxy, nullptr, matrix)
+ : INHERITED(context, ModulationFlags(proxy->config()), proxy, nullptr, matrix)
, fSwizzle(swizzle)
, fPMConversion(pmConversion) {
this->initClassID<GrConfigConversionEffect>();
static void TestForPreservingPMConversions(GrContext* context,
PMConversion* PMToUPMRule,
PMConversion* UPMToPMRule);
-
private:
GrConfigConversionEffect(GrTexture*, const GrSwizzle&, PMConversion, const SkMatrix& matrix);
}
}
+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);
private:
AARectEffect(GrPrimitiveEdgeType edgeType, const SkRect& rect)
- : fRect(rect), fEdgeType(edgeType) {
+ : INHERITED(kModulatesInput_OptimizationFlag), fRect(rect), fEdgeType(edgeType) {
this->initClassID<AARectEffect>();
}
}
GrConvexPolyEffect::GrConvexPolyEffect(GrPrimitiveEdgeType edgeType, int n, const SkScalar edges[])
- : fEdgeType(edgeType)
- , fEdgeCount(n) {
+ : INHERITED(kModulatesInput_OptimizationFlag), fEdgeType(edgeType), fEdgeCount(n) {
this->initClassID<GrConvexPolyEffect>();
// Factory function should have already ensured this.
SkASSERT(n <= kMaxEdges);
const char* name() const override { return "Dither"; }
private:
- DitherEffect() {
- this->initClassID<DitherEffect>();
- }
+ DitherEffect() : INHERITED(kNone_OptimizationFlags) { this->initClassID<DitherEffect>(); }
GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;
float gaussianSigma,
bool useBounds,
float bounds[2])
- : INHERITED(texture, direction, radius), fUseBounds(useBounds) {
+ : INHERITED(texture, direction, radius, ModulationFlags(texture->config()))
+ , fUseBounds(useBounds) {
this->initClassID<GrGaussianConvolutionFragmentProcessor>();
SkASSERT(radius <= kMaxKernelRadius);
int width = this->width();
const SkIPoint& kernelOffset,
GrTextureDomain::Mode tileMode,
bool convolveAlpha)
- : INHERITED(texture, nullptr, SkMatrix::I()),
- fKernelSize(kernelSize),
- fGain(SkScalarToFloat(gain)),
- fBias(SkScalarToFloat(bias) / 255.0f),
- fConvolveAlpha(convolveAlpha),
- fDomain(texture, GrTextureDomain::MakeTexelDomainForMode(bounds, tileMode), tileMode) {
+ // 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) {
this->initClassID<GrMatrixConvolutionEffect>();
for (int i = 0; i < kernelSize.width() * kernelSize.height(); i++) {
fKernel[i] = SkScalarToFloat(kernel[i]);
}
CircleEffect::CircleEffect(GrPrimitiveEdgeType edgeType, const SkPoint& c, SkScalar r)
- : fCenter(c)
- , fRadius(r)
- , fEdgeType(edgeType) {
+ : INHERITED(kModulatesInput_OptimizationFlag), fCenter(c), fRadius(r), fEdgeType(edgeType) {
this->initClassID<CircleEffect>();
}
inout->mulByUnknownSingleComponent();
}
-EllipseEffect::EllipseEffect(GrPrimitiveEdgeType edgeType, const SkPoint& c, SkScalar rx, SkScalar ry)
- : fCenter(c)
- , fRadii(SkVector::Make(rx, ry))
- , fEdgeType(edgeType) {
+EllipseEffect::EllipseEffect(GrPrimitiveEdgeType edgeType, const SkPoint& c, SkScalar rx,
+ SkScalar ry)
+ : INHERITED(kModulatesInput_OptimizationFlag)
+ , fCenter(c)
+ , fRadii(SkVector::Make(rx, ry))
+ , fEdgeType(edgeType) {
this->initClassID<EllipseEffect>();
}
CircularRRectEffect::CircularRRectEffect(GrPrimitiveEdgeType edgeType, uint32_t circularCornerFlags,
const SkRRect& rrect)
- : fRRect(rrect)
- , fEdgeType(edgeType)
- , fCircularCornerFlags(circularCornerFlags) {
+ : INHERITED(kModulatesInput_OptimizationFlag)
+ , fRRect(rrect)
+ , fEdgeType(edgeType)
+ , fCircularCornerFlags(circularCornerFlags) {
this->initClassID<CircularRRectEffect>();
}
void onComputeInvariantOutput(GrInvariantOutput* inout) const override;
- SkRRect fRRect;
- GrPrimitiveEdgeType fEdgeType;
+ SkRRect fRRect;
+ GrPrimitiveEdgeType fEdgeType;
GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
}
EllipticalRRectEffect::EllipticalRRectEffect(GrPrimitiveEdgeType edgeType, const SkRRect& rrect)
- : fRRect(rrect)
- , fEdgeType(edgeType) {
+ : INHERITED(kModulatesInput_OptimizationFlag), fRRect(rrect), fEdgeType(edgeType) {
this->initClassID<EllipticalRRectEffect>();
}
///////////////////////////////////////////////////////////////////////////////
GrSRGBEffect::GrSRGBEffect(Mode mode)
- : fMode(mode) {
+ : INHERITED(kPreservesOpaqueInput_OptimizationFlag |
+ kConstantOutputForConstantInput_OptimizationFlag)
+ , fMode(mode) {
this->initClassID<GrSRGBEffect>();
}
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);
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;
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
sk_sp<GrColorSpaceXform> colorSpaceXform,
const SkMatrix& matrix,
GrSamplerParams::FilterMode filterMode)
- : GrSingleTextureEffect(texture, std::move(colorSpaceXform), matrix, filterMode) {
+ : INHERITED(texture, std::move(colorSpaceXform), matrix, filterMode,
+ ModulationFlags(texture->config())) {
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)
- : GrSingleTextureEffect(ctx, std::move(proxy), std::move(colorSpaceXform),
- matrix, filterMode) {
+ : INHERITED{ctx,
+ ModulationFlags(proxy->config()),
+ PROXY_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)
- : GrSingleTextureEffect(texture, std::move(colorSpaceXform), matrix, params) {
+ : INHERITED(texture, std::move(colorSpaceXform), matrix, params,
+ ModulationFlags(texture->config())) {
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)
- : GrSingleTextureEffect(ctx, std::move(proxy), std::move(colorSpaceXform), matrix, params) {
+ : INHERITED{ctx,
+ ModulationFlags(proxy->config()),
+ PROXY_MOVE(proxy),
+ std::move(colorSpaceXform),
+ matrix,
+ params} {
this->initClassID<GrSimpleTextureEffect>();
}
typedef GrSingleTextureEffect INHERITED;
};
+#undef PROXY_MOVE
+
#endif
GrSingleTextureEffect::GrSingleTextureEffect(GrTexture* texture,
sk_sp<GrColorSpaceXform> colorSpaceXform,
- const SkMatrix& m)
- : fCoordTransform(m, texture, GrSamplerParams::kNone_FilterMode)
- , fTextureSampler(texture)
- , fColorSpaceXform(std::move(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)
- : fCoordTransform(m, texture, filterMode)
- , fTextureSampler(texture, filterMode)
- , fColorSpaceXform(std::move(colorSpaceXform)) {
+ 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)
- : fCoordTransform(m, texture, params.filterMode())
- , fTextureSampler(texture, params)
- , fColorSpaceXform(std::move(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, sk_sp<GrTextureProxy> proxy,
+GrSingleTextureEffect::GrSingleTextureEffect(GrContext* ctx, OptimizationFlags optFlags,
+ 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)) {
+ : INHERITED(optFlags)
+ , 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,
+GrSingleTextureEffect::GrSingleTextureEffect(GrContext* ctx, OptimizationFlags optFlags,
+ 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)) {
+ : INHERITED(optFlags)
+ , 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,
+GrSingleTextureEffect::GrSingleTextureEffect(GrContext* ctx, OptimizationFlags optFlags,
+ 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)) {
+ 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)) {
this->addCoordTransform(&fCoordTransform);
this->addTextureSampler(&fTextureSampler);
}
-
-GrSingleTextureEffect::~GrSingleTextureEffect() {
-}
*/
class GrSingleTextureEffect : public GrFragmentProcessor {
public:
- ~GrSingleTextureEffect() override;
-
SkString dumpInfo() const override {
SkString str;
str.appendf("Texture: %d", fTextureSampler.texture()->uniqueID().asUInt());
protected:
/** unfiltered, clamp mode */
- GrSingleTextureEffect(GrTexture*, sk_sp<GrColorSpaceXform>, const SkMatrix&);
+ GrSingleTextureEffect(GrTexture*, sk_sp<GrColorSpaceXform>, const SkMatrix&,
+ OptimizationFlags optFlags);
/** clamp mode */
GrSingleTextureEffect(GrTexture*, sk_sp<GrColorSpaceXform>, const SkMatrix&,
- GrSamplerParams::FilterMode filterMode);
+ GrSamplerParams::FilterMode filterMode, OptimizationFlags optFlags);
GrSingleTextureEffect(GrTexture*,
sk_sp<GrColorSpaceXform>,
const SkMatrix&,
- const GrSamplerParams&);
+ const GrSamplerParams&,
+ OptimizationFlags optFlags);
/** unfiltered, clamp mode */
- GrSingleTextureEffect(GrContext*,
- sk_sp<GrTextureProxy>, sk_sp<GrColorSpaceXform>, const SkMatrix&);
+ GrSingleTextureEffect(GrContext*, OptimizationFlags, sk_sp<GrTextureProxy>,
+ sk_sp<GrColorSpaceXform>, const SkMatrix&);
/** clamp mode */
- GrSingleTextureEffect(GrContext*,
- sk_sp<GrTextureProxy>, sk_sp<GrColorSpaceXform>, const SkMatrix&,
+ GrSingleTextureEffect(GrContext*, OptimizationFlags, sk_sp<GrTextureProxy>,
+ sk_sp<GrColorSpaceXform>, const SkMatrix&,
GrSamplerParams::FilterMode filterMode);
- GrSingleTextureEffect(GrContext*,
- sk_sp<GrTextureProxy>, sk_sp<GrColorSpaceXform>, const SkMatrix&,
- const GrSamplerParams&);
+ GrSingleTextureEffect(GrContext*, OptimizationFlags, sk_sp<GrTextureProxy>,
+ sk_sp<GrColorSpaceXform>, const SkMatrix&, const GrSamplerParams&);
/**
* Can be used as a helper to implement subclass onComputeInvariantOutput(). It assumes that
}
}
+ /**
+ * 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;
}
}
+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)
- , fTextureDomain(texture, domain, mode) {
+ : GrSingleTextureEffect(texture, std::move(colorSpaceXform), matrix, filterMode,
+ OptFlags(texture, mode))
+ , fTextureDomain(texture, domain, mode) {
SkASSERT(mode != GrTextureDomain::kRepeat_Mode ||
filterMode == GrSamplerParams::kNone_FilterMode);
this->initClassID<GrTextureDomainEffect>();
GrDeviceSpaceTextureDecalFragmentProcessor::GrDeviceSpaceTextureDecalFragmentProcessor(
GrTexture* texture, const SkIRect& subset, const SkIPoint& deviceSpaceOffset)
- : fTextureSampler(texture, GrSamplerParams::ClampNoFilter())
+ : INHERITED(kModulatesInput_OptimizationFlag)
+ , fTextureSampler(texture, GrSamplerParams::ClampNoFilter())
, fTextureDomain(texture, GrTextureDomain::MakeTexelDomain(subset),
GrTextureDomain::kDecal_Mode) {
this->addTextureSampler(&fTextureSampler);
GrTextureDomain::Mode,
GrSamplerParams::FilterMode);
+ static OptimizationFlags OptFlags(GrTexture* texture, GrTextureDomain::Mode mode);
+
GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;
void onGetGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const override;
public:
ComposeTwoFragmentProcessor(sk_sp<GrFragmentProcessor> src, sk_sp<GrFragmentProcessor> dst,
SkBlendMode mode)
- : fMode(mode) {
+ : INHERITED(OptFlags(src.get(), dst.get(), mode)), fMode(mode) {
this->initClassID<ComposeTwoFragmentProcessor>();
SkDEBUGCODE(int shaderAChildIndex = )this->registerChildProcessor(std::move(src));
SkDEBUGCODE(int shaderBChildIndex = )this->registerChildProcessor(std::move(dst));
SkBlendMode getMode() const { return fMode; }
-protected:
+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;
+ }
+
bool onIsEqual(const GrFragmentProcessor& other) const override {
const ComposeTwoFragmentProcessor& cs = other.cast<ComposeTwoFragmentProcessor>();
return fMode == cs.fMode;
inout->setToUnknown();
}
-private:
+ 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);
+ }
+
GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;
SkBlendMode fMode;
};
ComposeOneFragmentProcessor(sk_sp<GrFragmentProcessor> dst, SkBlendMode mode, Child child)
- : fMode(mode)
- , fChild(child) {
+ : INHERITED(OptFlags(dst.get(), mode)), fMode(mode), fChild(child) {
this->initClassID<ComposeOneFragmentProcessor>();
SkDEBUGCODE(int dstIndex = )this->registerChildProcessor(std::move(dst));
SkASSERT(0 == dstIndex);
Child child() const { return fChild; }
-protected:
+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;
+ }
+
bool onIsEqual(const GrFragmentProcessor& that) const override {
return fMode == that.cast<ComposeOneFragmentProcessor>().fMode;
}
}
}
+ 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;
};
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)
- : 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)
+ : 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) {
this->initClassID<YUVtoRGBEffect>();
this->addCoordTransform(&fYTransform);
this->addTextureSampler(&fYSampler);
RGBToYUVEffect(sk_sp<GrFragmentProcessor> rgbFP, SkYUVColorSpace colorSpace,
OutputChannels output)
- : fColorSpace(colorSpace)
- , fOutputChannels(output) {
+ // This could advertise kConstantOutputForConstantInput, but doesn't seem useful.
+ : INHERITED(kPreservesOpaqueInput_OptimizationFlag)
+ , fColorSpace(colorSpace)
+ , fOutputChannels(output) {
this->initClassID<RGBToYUVEffect>();
this->registerChildProcessor(std::move(rgbFP));
}
}
private:
- BigKeyProcessor() {
- this->initClassID<BigKeyProcessor>();
- }
+ BigKeyProcessor() : INHERITED(kNone_OptimizationFlags) { this->initClassID<BigKeyProcessor>(); }
virtual void onGetGLSLProcessorKey(const GrShaderCaps& caps,
GrProcessorKeyBuilder* b) const override {
GLBigKeyProcessor::GenKey(*this, caps, b);
typedef GrGLSLFragmentProcessor INHERITED;
};
- BlockInputFragmentProcessor(sk_sp<GrFragmentProcessor> child) {
+ BlockInputFragmentProcessor(sk_sp<GrFragmentProcessor> child)
+ : INHERITED(kNone_OptimizationFlags) {
this->initClassID<BlockInputFragmentProcessor>();
this->registerChildProcessor(std::move(child));
}
private:
TestFP(sk_sp<GrTexture> texture, GrSLMemoryModel mm, GrSLRestrict restrict)
- : fImageStorageAccess(std::move(texture), kRead_GrIOType, mm, restrict) {
+ : INHERITED(kNone_OptimizationFlags)
+ , fImageStorageAccess(std::move(texture), kRead_GrIOType, mm, restrict) {
this->initClassID<TestFP>();
this->addImageStorageAccess(&fImageStorageAccess);
}
}
ImageStorageAccess fImageStorageAccess;
+ typedef GrFragmentProcessor INHERITED;
};
static constexpr int kS = 256;
private:
TestFP(const SkTArray<sk_sp<GrTexture>>& textures, const SkTArray<sk_sp<GrBuffer>>& buffers,
const SkTArray<Image>& images)
- : fSamplers(4), fBuffers(4), fImages(4) {
+ : INHERITED(kNone_OptimizationFlags), fSamplers(4), fBuffers(4), fImages(4) {
for (const auto& texture : textures) {
this->addTextureSampler(&fSamplers.emplace_back(texture.get()));
}
}
}
- TestFP(sk_sp<GrFragmentProcessor> child) : fSamplers(4), fBuffers(4), fImages(4) {
+ TestFP(sk_sp<GrFragmentProcessor> child)
+ : INHERITED(kNone_OptimizationFlags), fSamplers(4), fBuffers(4), fImages(4) {
this->registerChildProcessor(std::move(child));
}
GrTAllocator<TextureSampler> fSamplers;
GrTAllocator<BufferAccess> fBuffers;
GrTAllocator<ImageStorageAccess> fImages;
+ typedef GrFragmentProcessor INHERITED;
};
}
}
}
}
+
+// 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) {
+ // This tests code under development but not used in skia lib. Leaving this disabled until
+ // some platform-specific issues are addressed.
+ if (1) {
+ return;
+ }
+ 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
projects / platform / upstream / libSkiaSharp.git / commitdiff