#if SK_SUPPORT_GPU
#include "GrFragmentProcessor.h"
#include "GrCoordTransform.h"
+#include "effects/GrExtractAlphaFragmentProcessor.h"
#include "gl/GrGLProcessor.h"
#include "gl/builders/GrGLProgramBuilder.h"
#include "Resources.h"
buf.writeMatrix(fDeviceMatrix);
}
- bool asFragmentProcessor(GrContext*, const SkPaint& paint, const SkMatrix& viewM,
- const SkMatrix* localMatrix, GrColor* color, GrProcessorDataManager*,
- GrFragmentProcessor** fp) const override;
+ const GrFragmentProcessor* asFragmentProcessor(GrContext*, const SkMatrix& viewM,
+ const SkMatrix* localMatrix, SkFilterQuality, GrProcessorDataManager*) const override;
#ifndef SK_IGNORE_TO_STRING
void toString(SkString* str) const override {
GrCoordTransform fDeviceTransform;
};
-bool DCShader::asFragmentProcessor(GrContext*, const SkPaint& paint, const SkMatrix& viewM,
- const SkMatrix* localMatrix, GrColor* color,
- GrProcessorDataManager* procDataManager,
- GrFragmentProcessor** fp) const {
- *fp = new DCFP(procDataManager, fDeviceMatrix);
- *color = GrColorPackA4(paint.getAlpha());
- return true;
+const GrFragmentProcessor* DCShader::asFragmentProcessor(GrContext*, const SkMatrix& viewM,
+ const SkMatrix* localMatrix, SkFilterQuality, GrProcessorDataManager* procDataManager) const {
+ SkAutoTUnref<const GrFragmentProcessor> inner(new DCFP(procDataManager, fDeviceMatrix));
+ return GrExtractAlphaFragmentProcessor::Create(inner);
}
class DCShaderGM : public GM {
'<(skia_include_path)/gpu/effects/GrConstColorProcessor.h',
'<(skia_include_path)/gpu/effects/GrCoverageSetOpXP.h',
'<(skia_include_path)/gpu/effects/GrCustomXfermode.h',
+ '<(skia_include_path)/gpu/effects/GrExtractAlphaFragmentProcessor.h',
'<(skia_include_path)/gpu/effects/GrPorterDuffXferProcessor.h',
'<(skia_include_path)/gpu/gl/GrGLConfig.h',
'<(skia_src_path)/gpu/effects/GrConfigConversionEffect.cpp',
'<(skia_src_path)/gpu/effects/GrConfigConversionEffect.h',
'<(skia_src_path)/gpu/effects/GrConstColorProcessor.cpp',
+ '<(skia_src_path)/gpu/effects/GrExtractAlphaFragmentProcessor.cpp',
'<(skia_src_path)/gpu/effects/GrCoverageSetOpXP.cpp',
'<(skia_src_path)/gpu/effects/GrCustomXfermode.cpp',
'<(skia_src_path)/gpu/effects/GrCustomXfermodePriv.h',
/**
- * Returns true if the shader subclass succeeds in creating an effect or if none is required.
- * False is returned if it fails or if there is not an implementation of this method in the
- * shader subclass.
+ * Returns a GrFragmentProcessor that implements the shader for the GPU backend. NULL is
+ * returned if there is no GPU implementation.
*
- * On success an implementation of this method must inspect the SkPaint and set paintColor to
- * the color the effect expects as its input color. If the SkShader wishes to emit a solid
- * color then it should set paintColor to that color and not create an effect. Note that
- * GrColor is always premul. The common patterns are to convert paint's SkColor to GrColor or
- * to extract paint's alpha and replicate it to all channels in paintColor. Upon failure
- * paintColor should not be modified. It is not recommended to specialize the effect to
- * the paint's color as then many GPU shaders may be generated.
+ * The GPU device does not call SkShader::createContext(), instead we pass the view matrix,
+ * local matrix, and filter quality directly.
*
- * The GrContext may be used by the effect to create textures. The GPU device does not
- * call createContext. Instead we pass the SkPaint here in case the shader needs paint info.
- *
- * A view matrix is always required to create the correct GrFragmentProcessor. Some shaders
- * may also use the optional localMatrix to define a matrix relevant only for sampling.
+ * The GrContext may be used by the to create textures that are required by the returned
+ * processor.
*/
- virtual bool asFragmentProcessor(GrContext*, const SkPaint&, const SkMatrix& viewM,
- const SkMatrix* localMatrix, GrColor*,
- GrProcessorDataManager*, GrFragmentProcessor**) const;
+ virtual const GrFragmentProcessor* asFragmentProcessor(GrContext*,
+ const SkMatrix& viewMatric,
+ const SkMatrix* localMatrix,
+ SkFilterQuality,
+ GrProcessorDataManager*) const;
/**
* If the shader can represent its "average" luminance in a single color, return true and
typedef SkShader::Context INHERITED;
};
- virtual bool asFragmentProcessor(GrContext* context, const SkPaint&, const SkMatrix& viewM,
- const SkMatrix*, GrColor*, GrProcessorDataManager*,
- GrFragmentProcessor**) const override;
+#if SK_SUPPORT_GPU
+ const GrFragmentProcessor* asFragmentProcessor(GrContext* context, const SkMatrix& viewM,
+ const SkMatrix*, SkFilterQuality,
+ GrProcessorDataManager*) const override;
+#endif
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkPerlinNoiseShader)
#define GrFragmentProcessor_DEFINED
#include "GrProcessor.h"
+#include "GrInvariantOutput.h"
class GrCoordTransform;
class GrGLSLCaps;
* inout to indicate known values of its output. A component of the color member only has
* meaning if the corresponding bit in validFlags is set.
*/
- void computeInvariantOutput(GrInvariantOutput* inout) const;
+ void computeInvariantOutput(GrInvariantOutput* inout) const {
+ this->onComputeInvariantOutput(inout);
+ }
protected:
void addTextureAccess(const GrTextureAccess* textureAccess) override;
class GrProcessorTestFactory : SkNoncopyable {
public:
- typedef Processor* (*CreateProc)(GrProcessorTestData*);
+ typedef const Processor* (*CreateProc)(GrProcessorTestData*);
GrProcessorTestFactory(CreateProc createProc) {
fCreateProc = createProc;
GetFactories()->push_back(this);
}
- static Processor* CreateStage(GrProcessorTestData* data) {
+ static const Processor* CreateStage(GrProcessorTestData* data) {
VerifyFactoryCount();
SkASSERT(GetFactories()->count());
uint32_t idx = data->fRandom->nextRangeU(0, GetFactories()->count() - 1);
*/
#define GR_DECLARE_GEOMETRY_PROCESSOR_TEST \
static GrProcessorTestFactory<GrGeometryProcessor> gTestFactory SK_UNUSED; \
- static GrGeometryProcessor* TestCreate(GrProcessorTestData*)
+ static const GrGeometryProcessor* TestCreate(GrProcessorTestData*)
#define GR_DECLARE_FRAGMENT_PROCESSOR_TEST \
static GrProcessorTestFactory<GrFragmentProcessor> gTestFactory SK_UNUSED; \
- static GrFragmentProcessor* TestCreate(GrProcessorTestData*)
+ static const GrFragmentProcessor* TestCreate(GrProcessorTestData*)
#define GR_DECLARE_XP_FACTORY_TEST \
static GrProcessorTestFactory<GrXPFactory> gTestFactory SK_UNUSED; \
- static GrXPFactory* TestCreate(GrProcessorTestData*)
+ static const GrXPFactory* TestCreate(GrProcessorTestData*)
/** GrProcessor subclasses should insert this macro in their implementation file. They must then
// The unit test relies on static initializers. Just declare the TestCreate function so that
// its definitions will compile.
#define GR_DECLARE_FRAGMENT_PROCESSOR_TEST \
- static GrFragmentProcessor* TestCreate(GrProcessorTestData*)
+ static const GrFragmentProcessor* TestCreate(GrProcessorTestData*)
#define GR_DEFINE_FRAGMENT_PROCESSOR_TEST(X)
// The unit test relies on static initializers. Just declare the TestCreate function so that
// its definitions will compile.
#define GR_DECLARE_XP_FACTORY_TEST \
- static GrXPFactory* TestCreate(GrProcessorTestData*)
+ static const GrXPFactory* TestCreate(GrProcessorTestData*)
#define GR_DEFINE_XP_FACTORY_TEST(X)
// The unit test relies on static initializers. Just declare the TestCreate function so that
// its definitions will compile.
#define GR_DECLARE_GEOMETRY_PROCESSOR_TEST \
- static GrGeometryProcessor* TestCreate(GrProcessorTestData*)
+ static const GrGeometryProcessor* TestCreate(GrProcessorTestData*)
#define GR_DEFINE_GEOMETRY_PROCESSOR_TEST(X)
#endif // !SK_ALLOW_STATIC_GLOBAL_INITIALIZERS
#include "GrFragmentProcessor.h"
-class GrInvariantOutput;
-
/**
* This is a simple GrFragmentProcessor that outputs a constant color. It may do one of the
* following with its input color: ignore it, or multiply it by the constant color, multiply its
return new GrConstColorProcessor(color, mode);
}
- ~GrConstColorProcessor() override {}
-
const char* name() const override { return "Color"; }
GrColor color() const { return fColor; }
--- /dev/null
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrExtractAlphaFragmentProcessor_DEFINED
+#define GrExtractAlphaFragmentProcessor_DEFINED
+
+#include "GrFragmentProcessor.h"
+
+/** This processor extracts the incoming color's alpha, ignores r, g, and b, and feeds
+ the replicated alpha to it's inner processor. */
+class GrExtractAlphaFragmentProcessor : public GrFragmentProcessor {
+public:
+ static GrFragmentProcessor* Create(const GrFragmentProcessor* processor) {
+ if (!processor) {
+ return nullptr;
+ }
+ return SkNEW_ARGS(GrExtractAlphaFragmentProcessor, (processor));
+ }
+
+ ~GrExtractAlphaFragmentProcessor() override {}
+
+ const char* name() const override { return "Extract Alpha"; }
+
+private:
+ GrExtractAlphaFragmentProcessor(const GrFragmentProcessor* processor) {
+ this->initClassID<GrExtractAlphaFragmentProcessor>();
+ this->registerChildProcessor(processor);
+ }
+
+ GrGLFragmentProcessor* onCreateGLInstance() const override;
+
+ void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
+
+ bool onIsEqual(const GrFragmentProcessor&) const override;
+
+ void onComputeInvariantOutput(GrInvariantOutput* inout) const override;
+
+ typedef GrFragmentProcessor INHERITED;
+};
+
+#endif
#if SK_SUPPORT_GPU
#include "effects/GrBicubicEffect.h"
+#include "effects/GrExtractAlphaFragmentProcessor.h"
#include "effects/GrSimpleTextureEffect.h"
#endif
#include "SkGr.h"
#include "effects/GrSimpleTextureEffect.h"
-bool SkBitmapProcShader::asFragmentProcessor(GrContext* context, const SkPaint& paint,
- const SkMatrix& viewM,
- const SkMatrix* localMatrix, GrColor* paintColor,
- GrProcessorDataManager* procDataManager,
- GrFragmentProcessor** fp) const {
+const GrFragmentProcessor* SkBitmapProcShader::asFragmentProcessor(GrContext* context,
+ const SkMatrix& viewM, const SkMatrix* localMatrix,
+ SkFilterQuality filterQuality,
+ GrProcessorDataManager* procDataManager) const {
SkMatrix matrix;
matrix.setIDiv(fRawBitmap.width(), fRawBitmap.height());
SkMatrix lmInverse;
if (!this->getLocalMatrix().invert(&lmInverse)) {
- return false;
+ return nullptr;
}
if (localMatrix) {
SkMatrix inv;
if (!localMatrix->invert(&inv)) {
- return false;
+ return nullptr;
}
lmInverse.postConcat(inv);
}
// are provided by the caller.
bool doBicubic;
GrTextureParams::FilterMode textureFilterMode =
- GrSkFilterQualityToGrFilterMode(paint.getFilterQuality(), viewM, this->getLocalMatrix(),
+ GrSkFilterQualityToGrFilterMode(filterQuality, viewM, this->getLocalMatrix(),
&doBicubic);
GrTextureParams params(tm, textureFilterMode);
SkAutoTUnref<GrTexture> texture(GrRefCachedBitmapTexture(context, fRawBitmap, ¶ms));
if (!texture) {
SkErrorInternals::SetError( kInternalError_SkError,
"Couldn't convert bitmap to texture.");
- return false;
+ return nullptr;
}
- *paintColor = (kAlpha_8_SkColorType == fRawBitmap.colorType()) ?
- SkColor2GrColor(paint.getColor()) :
- SkColor2GrColorJustAlpha(paint.getColor());
-
+ SkAutoTUnref<GrFragmentProcessor> inner;
if (doBicubic) {
- *fp = GrBicubicEffect::Create(procDataManager, texture, matrix, tm);
+ inner.reset(GrBicubicEffect::Create(procDataManager, texture, matrix, tm));
} else {
- *fp = GrSimpleTextureEffect::Create(procDataManager, texture, matrix, params);
+ inner.reset(GrSimpleTextureEffect::Create(procDataManager, texture, matrix, params));
}
- return true;
-}
-
-#else
-
-bool SkBitmapProcShader::asFragmentProcessor(GrContext*, const SkPaint&, const SkMatrix&,
- const SkMatrix*, GrColor*, GrProcessorDataManager*,
- GrFragmentProcessor**) const {
- SkDEBUGFAIL("Should not call in GPU-less build");
- return false;
+ if (kAlpha_8_SkColorType == fRawBitmap.colorType()) {
+ return SkRef(inner.get());
+ }
+ return GrExtractAlphaFragmentProcessor::Create(inner);
}
#endif
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkBitmapProcShader)
-
- bool asFragmentProcessor(GrContext*, const SkPaint&, const SkMatrix& viewM, const SkMatrix*,
- GrColor*, GrProcessorDataManager*,
- GrFragmentProcessor**) const override;
+#if SK_SUPPORT_GPU
+ const GrFragmentProcessor* asFragmentProcessor(GrContext*, const SkMatrix& viewM,
+ const SkMatrix*, SkFilterQuality,
+ GrProcessorDataManager*) const override;
+#endif
class BitmapProcShaderContext : public SkShader::Context {
public:
GradientType asAGradient(GradientInfo* info) const override;
- bool asFragmentProcessor(GrContext*, const SkPaint&, const SkMatrix& viewM,
- const SkMatrix*, GrColor*, GrProcessorDataManager*,
- GrFragmentProcessor**) const override;
+#if SK_SUPPORT_GPU
+ const GrFragmentProcessor* asFragmentProcessor(GrContext*, const SkMatrix& viewM,
+ const SkMatrix*, SkFilterQuality,
+ GrProcessorDataManager*) const override;
+#endif
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkColorShader)
bool isOpaque() const override;
- bool asFragmentProcessor(GrContext*, const SkPaint& paint, const SkMatrix& viewM,
- const SkMatrix* localMatrix, GrColor* color,
- GrProcessorDataManager*, GrFragmentProcessor** fp) const override;
+#if SK_SUPPORT_GPU
+ const GrFragmentProcessor* asFragmentProcessor(GrContext*, const SkMatrix& viewM,
+ const SkMatrix* localMatrix, SkFilterQuality, GrProcessorDataManager*) const override;
+#endif
size_t contextSize() const override;
#include "GrCoordTransform.h"
#include "GrFragmentProcessor.h"
#include "GrTextureAccess.h"
+#include "effects/GrExtractAlphaFragmentProcessor.h"
#include "gl/GrGLProcessor.h"
#include "gl/builders/GrGLProgramBuilder.h"
#include "SkGr.h"
return true;
}
-bool SkLightingShaderImpl::asFragmentProcessor(GrContext* context, const SkPaint& paint,
- const SkMatrix& viewM, const SkMatrix* localMatrix,
- GrColor* color, GrProcessorDataManager* pdm,
- GrFragmentProcessor** fp) const {
+const GrFragmentProcessor* SkLightingShaderImpl::asFragmentProcessor(GrContext* context,
+ const SkMatrix& viewM, const SkMatrix* localMatrix, SkFilterQuality filterQuality,
+ GrProcessorDataManager* pdm) const {
// we assume diffuse and normal maps have same width and height
// TODO: support different sizes
SkASSERT(fDiffuseMap.width() == fNormalMap.width() &&
SkMatrix diffM, normM;
if (!make_mat(fDiffuseMap, this->getLocalMatrix(), localMatrix, &diffM)) {
- return false;
+ return nullptr;
}
if (!make_mat(fNormalMap, fNormLocalMatrix, localMatrix, &normM)) {
- return false;
+ return nullptr;
}
bool doBicubic;
GrTextureParams::FilterMode diffFilterMode = GrSkFilterQualityToGrFilterMode(
- SkTMin(paint.getFilterQuality(), kMedium_SkFilterQuality),
+ SkTMin(filterQuality, kMedium_SkFilterQuality),
viewM,
this->getLocalMatrix(),
&doBicubic);
SkASSERT(!doBicubic);
GrTextureParams::FilterMode normFilterMode = GrSkFilterQualityToGrFilterMode(
- SkTMin(paint.getFilterQuality(), kMedium_SkFilterQuality),
+ SkTMin(filterQuality, kMedium_SkFilterQuality),
viewM,
fNormLocalMatrix,
&doBicubic);
SkAutoTUnref<GrTexture> diffuseTexture(GrRefCachedBitmapTexture(context,
fDiffuseMap, &diffParams));
if (!diffuseTexture) {
- SkErrorInternals::SetError(kInternalError_SkError,
- "Couldn't convert bitmap to texture.");
- return false;
+ SkErrorInternals::SetError(kInternalError_SkError, "Couldn't convert bitmap to texture.");
+ return nullptr;
}
GrTextureParams normParams(kClamp_TileMode, normFilterMode);
SkAutoTUnref<GrTexture> normalTexture(GrRefCachedBitmapTexture(context,
fNormalMap, &normParams));
if (!normalTexture) {
- SkErrorInternals::SetError(kInternalError_SkError,
- "Couldn't convert bitmap to texture.");
- return false;
+ SkErrorInternals::SetError(kInternalError_SkError, "Couldn't convert bitmap to texture.");
+ return nullptr;
}
- *fp = new LightingFP(pdm, diffuseTexture, normalTexture, diffM, normM, diffParams, normParams,
- fLights, fInvNormRotation);
-
- *color = GrColorPackA4(paint.getAlpha());
- return true;
-}
-#else
-
-bool SkLightingShaderImpl::asFragmentProcessor(GrContext* context, const SkPaint& paint,
- const SkMatrix& viewM, const SkMatrix* localMatrix,
- GrColor* color, GrProcessorDataManager*,
- GrFragmentProcessor** fp) const {
- SkDEBUGFAIL("Should not call in GPU-less build");
- return false;
+ SkAutoTUnref<const GrFragmentProcessor> inner (
+ new LightingFP(pdm, diffuseTexture, normalTexture, diffM, normM, diffParams, normParams,
+ fLights, fInvNormRotation));
+ return GrExtractAlphaFragmentProcessor::Create(inner);
}
#endif
}
#if SK_SUPPORT_GPU
-
- virtual bool asFragmentProcessor(GrContext* context, const SkPaint& paint,
- const SkMatrix& viewM, const SkMatrix* localMatrix,
- GrColor* grColor, GrProcessorDataManager* procDataManager,
- GrFragmentProcessor** fp) const override {
+ const GrFragmentProcessor* asFragmentProcessor(GrContext* context, const SkMatrix& viewM,
+ const SkMatrix* localMatrix, SkFilterQuality fq,
+ GrProcessorDataManager* procDataManager) const override {
SkMatrix tmp = this->getLocalMatrix();
if (localMatrix) {
tmp.preConcat(*localMatrix);
}
- return fProxyShader->asFragmentProcessor(context, paint, viewM, &tmp, grColor,
- procDataManager, fp);
+ return fProxyShader->asFragmentProcessor(context, viewM, &tmp, fq, procDataManager);
}
-
-#else
-
- virtual bool asFragmentProcessor(GrContext*, const SkPaint&, const SkMatrix&,
- const SkMatrix*, GrColor*, GrProcessorDataManager*,
- GrFragmentProcessor**) const override {
- SkDEBUGFAIL("Should not call in GPU-less build");
- return false;
- }
-
#endif
SkShader* refAsALocalMatrixShader(SkMatrix* localMatrix) const override {
#endif
#if SK_SUPPORT_GPU
-bool SkPictureShader::asFragmentProcessor(GrContext* context, const SkPaint& paint,
- const SkMatrix& viewM, const SkMatrix* localMatrix,
- GrColor* paintColor,
- GrProcessorDataManager* procDataManager,
- GrFragmentProcessor** fp) const {
+const GrFragmentProcessor* SkPictureShader::asFragmentProcessor(GrContext* context,
+ const SkMatrix& viewM, const SkMatrix* localMatrix, SkFilterQuality fq,
+ GrProcessorDataManager* procDataManager) const {
int maxTextureSize = 0;
if (context) {
maxTextureSize = context->caps()->maxTextureSize();
}
SkAutoTUnref<SkShader> bitmapShader(this->refBitmapShader(viewM, localMatrix, maxTextureSize));
if (!bitmapShader) {
- return false;
+ return nullptr;
}
- return bitmapShader->asFragmentProcessor(context, paint, viewM, nullptr, paintColor,
- procDataManager, fp);
-}
-#else
-bool SkPictureShader::asFragmentProcessor(GrContext*, const SkPaint&, const SkMatrix&,
- const SkMatrix*, GrColor*, GrProcessorDataManager*,
- GrFragmentProcessor**) const {
- SkDEBUGFAIL("Should not call in GPU-less build");
- return false;
+ return bitmapShader->asFragmentProcessor(context, viewM, nullptr, fq, procDataManager);
}
#endif
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkPictureShader)
- bool asFragmentProcessor(GrContext*, const SkPaint&, const SkMatrix& viewM, const SkMatrix*,
- GrColor*, GrProcessorDataManager*,
- GrFragmentProcessor**) const override;
+#if SK_SUPPORT_GPU
+ const GrFragmentProcessor* asFragmentProcessor(GrContext*, const SkMatrix& viewM,
+ const SkMatrix*, SkFilterQuality, GrProcessorDataManager*) const override;
+#endif
protected:
SkPictureShader(SkReadBuffer&);
return kNone_GradientType;
}
-bool SkShader::asFragmentProcessor(GrContext*, const SkPaint&, const SkMatrix&, const SkMatrix*,
- GrColor*, GrProcessorDataManager*,
- GrFragmentProcessor**) const {
- return false;
+const GrFragmentProcessor* SkShader::asFragmentProcessor(GrContext*, const SkMatrix&,
+ const SkMatrix*, SkFilterQuality,
+ GrProcessorDataManager*) const {
+ return nullptr;
}
SkShader* SkShader::refAsALocalMatrixShader(SkMatrix*) const {
#if SK_SUPPORT_GPU
#include "SkGr.h"
-
-bool SkColorShader::asFragmentProcessor(GrContext*, const SkPaint& paint, const SkMatrix&,
- const SkMatrix*, GrColor* paintColor,
- GrProcessorDataManager*, GrFragmentProcessor** fp) const {
- *fp = nullptr;
- SkColor skColor = fColor;
- U8CPU newA = SkMulDiv255Round(SkColorGetA(fColor), paint.getAlpha());
- *paintColor = SkColor2GrColor(SkColorSetA(skColor, newA));
- return true;
-}
-
-#else
-
-bool SkColorShader::asFragmentProcessor(GrContext*, const SkPaint&, const SkMatrix&,
- const SkMatrix*, GrColor*, GrProcessorDataManager*,
- GrFragmentProcessor**) const {
- SkDEBUGFAIL("Should not call in GPU-less build");
- return false;
+#include "effects/GrConstColorProcessor.h"
+const GrFragmentProcessor* SkColorShader::asFragmentProcessor(GrContext*, const SkMatrix&,
+ const SkMatrix*, SkFilterQuality,
+ GrProcessorDataManager*) const {
+ GrColor color = SkColor2GrColor(fColor);
+ return GrConstColorProcessor::Create(color, GrConstColorProcessor::kModulateA_InputMode);
}
#endif
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(AlphaThresholdEffect);
-GrFragmentProcessor* AlphaThresholdEffect::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* AlphaThresholdEffect::TestCreate(GrProcessorTestData* d) {
GrTexture* bmpTex = d->fTextures[GrProcessorUnitTest::kSkiaPMTextureIdx];
GrTexture* maskTex = d->fTextures[GrProcessorUnitTest::kAlphaTextureIdx];
float innerThresh = d->fRandom->nextUScalar1();
///////////////////////////////////////////////////////////////////////////////
-GrFragmentProcessor* GrArithmeticFP::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* GrArithmeticFP::TestCreate(GrProcessorTestData* d) {
float k1 = d->fRandom->nextF();
float k2 = d->fRandom->nextF();
float k3 = d->fRandom->nextF();
GR_DEFINE_XP_FACTORY_TEST(GrArithmeticXPFactory);
-GrXPFactory* GrArithmeticXPFactory::TestCreate(GrProcessorTestData* d) {
+const GrXPFactory* GrArithmeticXPFactory::TestCreate(GrProcessorTestData* d) {
float k1 = d->fRandom->nextF();
float k2 = d->fRandom->nextF();
float k3 = d->fRandom->nextF();
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrRectBlurEffect);
-GrFragmentProcessor* GrRectBlurEffect::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* GrRectBlurEffect::TestCreate(GrProcessorTestData* d) {
float sigma = d->fRandom->nextRangeF(3,8);
float width = d->fRandom->nextRangeF(200,300);
float height = d->fRandom->nextRangeF(200,300);
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrRRectBlurEffect);
-GrFragmentProcessor* GrRRectBlurEffect::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* GrRRectBlurEffect::TestCreate(GrProcessorTestData* d) {
SkScalar w = d->fRandom->nextRangeScalar(100.f, 1000.f);
SkScalar h = d->fRandom->nextRangeScalar(100.f, 1000.f);
SkScalar r = d->fRandom->nextRangeF(1.f, 9.f);
}
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(ModeColorFilterEffect);
-GrFragmentProcessor* ModeColorFilterEffect::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* ModeColorFilterEffect::TestCreate(GrProcessorTestData* d) {
SkXfermode::Mode mode = SkXfermode::kDst_Mode;
while (SkXfermode::kDst_Mode == mode) {
mode = static_cast<SkXfermode::Mode>(d->fRandom->nextRangeU(0, SkXfermode::kLastCoeffMode));
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(ColorMatrixEffect);
-GrFragmentProcessor* ColorMatrixEffect::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* ColorMatrixEffect::TestCreate(GrProcessorTestData* d) {
SkColorMatrix colorMatrix;
for (size_t i = 0; i < SK_ARRAY_COUNT(colorMatrix.fMat); ++i) {
colorMatrix.fMat[i] = d->fRandom->nextSScalar1();
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrDisplacementMapEffect);
-GrFragmentProcessor* GrDisplacementMapEffect::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* GrDisplacementMapEffect::TestCreate(GrProcessorTestData* d) {
int texIdxDispl = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx :
GrProcessorUnitTest::kAlphaTextureIdx;
int texIdxColor = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx :
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrDiffuseLightingEffect);
-GrFragmentProcessor* GrDiffuseLightingEffect::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* GrDiffuseLightingEffect::TestCreate(GrProcessorTestData* d) {
SkScalar surfaceScale = d->fRandom->nextSScalar1();
SkScalar kd = d->fRandom->nextUScalar1();
SkAutoTUnref<SkImageFilterLight> light(create_random_light(d->fRandom));
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrSpecularLightingEffect);
-GrFragmentProcessor* GrSpecularLightingEffect::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* GrSpecularLightingEffect::TestCreate(GrProcessorTestData* d) {
SkScalar surfaceScale = d->fRandom->nextSScalar1();
SkScalar ks = d->fRandom->nextUScalar1();
SkScalar shininess = d->fRandom->nextUScalar1();
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrMagnifierEffect);
-GrFragmentProcessor* GrMagnifierEffect::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* GrMagnifierEffect::TestCreate(GrProcessorTestData* d) {
GrTexture* texture = d->fTextures[0];
const int kMaxWidth = 200;
const int kMaxHeight = 200;
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrMorphologyEffect);
-GrFragmentProcessor* GrMorphologyEffect::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* GrMorphologyEffect::TestCreate(GrProcessorTestData* d) {
int texIdx = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx :
GrProcessorUnitTest::kAlphaTextureIdx;
Direction dir = d->fRandom->nextBool() ? kX_Direction : kY_Direction;
#include "GrCoordTransform.h"
#include "GrInvariantOutput.h"
#include "SkGr.h"
+#include "effects/GrConstColorProcessor.h"
+#include "effects/GrExtractAlphaFragmentProcessor.h"
#include "gl/GrGLFragmentProcessor.h"
#include "gl/builders/GrGLProgramBuilder.h"
#endif
bool fStitchTiles;
int fNumOctaves;
GrGLProgramDataManager::UniformHandle fBaseFrequencyUni;
- GrGLProgramDataManager::UniformHandle fAlphaUni;
private:
typedef GrGLFragmentProcessor INHERITED;
int numOctaves, bool stitchTiles,
SkPerlinNoiseShader::PaintingData* paintingData,
GrTexture* permutationsTexture, GrTexture* noiseTexture,
- const SkMatrix& matrix, uint8_t alpha) {
+ const SkMatrix& matrix) {
return new GrPerlinNoiseEffect(procDataManager, type, numOctaves, stitchTiles, paintingData,
- permutationsTexture, noiseTexture, matrix, alpha);
+ permutationsTexture, noiseTexture, matrix);
}
virtual ~GrPerlinNoiseEffect() { delete fPaintingData; }
const SkVector& baseFrequency() const { return fPaintingData->fBaseFrequency; }
int numOctaves() const { return fNumOctaves; }
const SkMatrix& matrix() const { return fCoordTransform.getMatrix(); }
- uint8_t alpha() const { return fAlpha; }
private:
GrGLFragmentProcessor* onCreateGLInstance() const override {
fPaintingData->fBaseFrequency == s.fPaintingData->fBaseFrequency &&
fNumOctaves == s.fNumOctaves &&
fStitchTiles == s.fStitchTiles &&
- fAlpha == s.fAlpha &&
fPaintingData->fStitchDataInit == s.fPaintingData->fStitchDataInit;
}
int numOctaves, bool stitchTiles,
SkPerlinNoiseShader::PaintingData* paintingData,
GrTexture* permutationsTexture, GrTexture* noiseTexture,
- const SkMatrix& matrix, uint8_t alpha)
+ const SkMatrix& matrix)
: fType(type)
, fNumOctaves(numOctaves)
, fStitchTiles(stitchTiles)
- , fAlpha(alpha)
, fPermutationsAccess(permutationsTexture)
, fNoiseAccess(noiseTexture)
, fPaintingData(paintingData) {
GrCoordTransform fCoordTransform;
int fNumOctaves;
bool fStitchTiles;
- uint8_t fAlpha;
GrTextureAccess fPermutationsAccess;
GrTextureAccess fNoiseAccess;
SkPerlinNoiseShader::PaintingData *fPaintingData;
/////////////////////////////////////////////////////////////////////
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrPerlinNoiseEffect);
-GrFragmentProcessor* GrPerlinNoiseEffect::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* GrPerlinNoiseEffect::TestCreate(GrProcessorTestData* d) {
int numOctaves = d->fRandom->nextRangeU(2, 10);
bool stitchTiles = d->fRandom->nextBool();
SkScalar seed = SkIntToScalar(d->fRandom->nextU());
SkPerlinNoiseShader::CreateTurbulence(baseFrequencyX, baseFrequencyY, numOctaves, seed,
stitchTiles ? &tileSize : nullptr);
- SkPaint paint;
- GrColor paintColor;
GrFragmentProcessor* effect;
GrPaint grPaint;
- SkAssertResult(shader->asFragmentProcessor(d->fContext, paint,
- GrTest::TestMatrix(d->fRandom), nullptr,
- &paintColor, grPaint.getProcessorDataManager(),
- &effect));
+ return shader->asFragmentProcessor(d->fContext,
+ GrTest::TestMatrix(d->fRandom), NULL,
+ kNone_SkFilterQuality,
+ grPaint.getProcessorDataManager());
delete shader;
kVec2f_GrSLType, kDefault_GrSLPrecision,
"baseFrequency");
const char* baseFrequencyUni = args.fBuilder->getUniformCStr(fBaseFrequencyUni);
- fAlphaUni = args.fBuilder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
- kFloat_GrSLType, kDefault_GrSLPrecision,
- "alpha");
- const char* alphaUni = args.fBuilder->getUniformCStr(fAlphaUni);
const char* stitchDataUni = nullptr;
if (fStitchTiles) {
args.fOutputColor,args.fOutputColor);
}
- fsBuilder->codeAppendf("\n\t\t%s.a *= %s;", args.fOutputColor, alphaUni);
-
// Clamp values
fsBuilder->codeAppendf("\n\t\t%s = clamp(%s, 0.0, 1.0);", args.fOutputColor, args.fOutputColor);
const SkVector& baseFrequency = turbulence.baseFrequency();
pdman.set2f(fBaseFrequencyUni, baseFrequency.fX, baseFrequency.fY);
- pdman.set1f(fAlphaUni, SkIntToScalar(turbulence.alpha()) / 255);
if (turbulence.stitchTiles()) {
const SkPerlinNoiseShader::StitchData& stitchData = turbulence.stitchData();
}
/////////////////////////////////////////////////////////////////////
-
-bool SkPerlinNoiseShader::asFragmentProcessor(GrContext* context, const SkPaint& paint,
- const SkMatrix& viewM,
- const SkMatrix* externalLocalMatrix,
- GrColor* paintColor,
- GrProcessorDataManager* procDataManager,
- GrFragmentProcessor** fp) const {
+const GrFragmentProcessor* SkPerlinNoiseShader::asFragmentProcessor(GrContext* context,
+ const SkMatrix& viewM, const SkMatrix* externalLocalMatrix, SkFilterQuality,
+ GrProcessorDataManager* procDataManager) const {
SkASSERT(context);
- *paintColor = SkColor2GrColorJustAlpha(paint.getColor());
-
SkMatrix localMatrix = this->getLocalMatrix();
if (externalLocalMatrix) {
localMatrix.preConcat(*externalLocalMatrix);
if (0 == fNumOctaves) {
if (kFractalNoise_Type == fType) {
- uint32_t alpha = paint.getAlpha() >> 1;
- uint32_t rgb = alpha >> 1;
- *paintColor = GrColorPackRGBA(rgb, rgb, rgb, alpha);
- } else {
- *paintColor = 0;
+ // Extract the incoming alpha and emit rgba = (a/4, a/4, a/4, a/2)
+ SkAutoTUnref<const GrFragmentProcessor> inner(
+ GrConstColorProcessor::Create(0x80404040,
+ GrConstColorProcessor::kModulateRGBA_InputMode));
+ return GrExtractAlphaFragmentProcessor::Create(inner);
}
- return true;
+ // Emit zero.
+ return GrConstColorProcessor::Create(0x0, GrConstColorProcessor::kIgnore_InputMode);
}
// Either we don't stitch tiles, either we have a valid tile size
m.setTranslateX(-localMatrix.getTranslateX() + SK_Scalar1);
m.setTranslateY(-localMatrix.getTranslateY() + SK_Scalar1);
if ((permutationsTexture) && (noiseTexture)) {
- *fp = GrPerlinNoiseEffect::Create(procDataManager,
- fType,
- fNumOctaves,
- fStitchTiles,
- paintingData,
- permutationsTexture, noiseTexture,
- m, paint.getAlpha());
- } else {
- delete paintingData;
- *fp = nullptr;
- }
- return true;
-}
-
-#else
-
-bool SkPerlinNoiseShader::asFragmentProcessor(GrContext*, const SkPaint&, const SkMatrix&,
- const SkMatrix*, GrColor*, GrProcessorDataManager*,
- GrFragmentProcessor**) const {
- SkDEBUGFAIL("Should not call in GPU-less build");
- return false;
+ SkAutoTUnref<GrFragmentProcessor> inner(
+ GrPerlinNoiseEffect::Create(procDataManager,
+ fType,
+ fNumOctaves,
+ fStitchTiles,
+ paintingData,
+ permutationsTexture, noiseTexture,
+ m));
+ return GrExtractAlphaFragmentProcessor::Create(inner);
+ }
+ delete paintingData;
+ return nullptr;
}
#endif
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(ColorTableEffect);
-GrFragmentProcessor* ColorTableEffect::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* ColorTableEffect::TestCreate(GrProcessorTestData* d) {
int flags = 0;
uint8_t luts[256][4];
do {
#if SK_SUPPORT_GPU
+#include "effects/GrExtractAlphaFragmentProcessor.h"
#include "gl/builders/GrGLProgramBuilder.h"
#include "SkGr.h"
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrLinearGradient);
-GrFragmentProcessor* GrLinearGradient::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* GrLinearGradient::TestCreate(GrProcessorTestData* d) {
SkPoint points[] = {{d->fRandom->nextUScalar1(), d->fRandom->nextUScalar1()},
{d->fRandom->nextUScalar1(), d->fRandom->nextUScalar1()}};
SkAutoTUnref<SkShader> shader(SkGradientShader::CreateLinear(points,
colors, stops, colorCount,
tm));
- SkPaint paint;
- GrColor paintColor;
- GrFragmentProcessor* fp;
- SkAssertResult(shader->asFragmentProcessor(d->fContext, paint,
- GrTest::TestMatrix(d->fRandom), nullptr,
- &paintColor, d->fProcDataManager, &fp));
+ const GrFragmentProcessor* fp = shader->asFragmentProcessor(d->fContext,
+ GrTest::TestMatrix(d->fRandom), NULL, kNone_SkFilterQuality, d->fProcDataManager);
+ GrAlwaysAssert(fp);
return fp;
}
/////////////////////////////////////////////////////////////////////
-bool SkLinearGradient::asFragmentProcessor(GrContext* context, const SkPaint& paint,
- const SkMatrix& viewm, const SkMatrix* localMatrix,
- GrColor* paintColor,
- GrProcessorDataManager* procDataManager,
- GrFragmentProcessor** fp) const {
+const GrFragmentProcessor* SkLinearGradient::asFragmentProcessor(
+ GrContext* context, const SkMatrix& viewm, const SkMatrix* localMatrix, SkFilterQuality,
+ GrProcessorDataManager* procDataManager) const {
SkASSERT(context);
SkMatrix matrix;
if (!this->getLocalMatrix().invert(&matrix)) {
- return false;
+ return nullptr;
}
if (localMatrix) {
SkMatrix inv;
if (!localMatrix->invert(&inv)) {
- return false;
+ return nullptr;
}
matrix.postConcat(inv);
}
matrix.postConcat(fPtsToUnit);
- *paintColor = SkColor2GrColorJustAlpha(paint.getColor());
- *fp = GrLinearGradient::Create(context, procDataManager, *this, matrix, fTileMode);
-
- return true;
+ SkAutoTUnref<const GrFragmentProcessor> inner(
+ GrLinearGradient::Create(context, procDataManager, *this, matrix, fTileMode));
+ return GrExtractAlphaFragmentProcessor::Create(inner);
}
-#else
-
-bool SkLinearGradient::asFragmentProcessor(GrContext*, const SkPaint&, const SkMatrix&,
- const SkMatrix*, GrColor*, GrProcessorDataManager*,
- GrFragmentProcessor**) const {
- SkDEBUGFAIL("Should not call in GPU-less build");
- return false;
-}
#endif
};
GradientType asAGradient(GradientInfo* info) const override;
- bool asFragmentProcessor(GrContext*, const SkPaint&, const SkMatrix& viewM,
- const SkMatrix*, GrColor*, GrProcessorDataManager*,
- GrFragmentProcessor**) const override;
+#if SK_SUPPORT_GPU
+ const GrFragmentProcessor* asFragmentProcessor(GrContext*, const SkMatrix& viewM,
+ const SkMatrix*, SkFilterQuality, GrProcessorDataManager*) const override;
+#endif
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkLinearGradient)
#if SK_SUPPORT_GPU
#include "SkGr.h"
+#include "effects/GrExtractAlphaFragmentProcessor.h"
#include "gl/builders/GrGLProgramBuilder.h"
class GrGLRadialGradient : public GrGLGradientEffect {
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrRadialGradient);
-GrFragmentProcessor* GrRadialGradient::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* GrRadialGradient::TestCreate(GrProcessorTestData* d) {
SkPoint center = {d->fRandom->nextUScalar1(), d->fRandom->nextUScalar1()};
SkScalar radius = d->fRandom->nextUScalar1();
SkAutoTUnref<SkShader> shader(SkGradientShader::CreateRadial(center, radius,
colors, stops, colorCount,
tm));
- SkPaint paint;
- GrColor paintColor;
- GrFragmentProcessor* fp;
- SkAssertResult(shader->asFragmentProcessor(d->fContext, paint,
- GrTest::TestMatrix(d->fRandom), nullptr,
- &paintColor, d->fProcDataManager, &fp));
+ const GrFragmentProcessor* fp = shader->asFragmentProcessor(d->fContext,
+ GrTest::TestMatrix(d->fRandom), NULL, kNone_SkFilterQuality, d->fProcDataManager);
+ GrAlwaysAssert(fp);
return fp;
}
/////////////////////////////////////////////////////////////////////
-bool SkRadialGradient::asFragmentProcessor(GrContext* context, const SkPaint& paint,
- const SkMatrix& viewM,
- const SkMatrix* localMatrix, GrColor* paintColor,
- GrProcessorDataManager* procDataManager,
- GrFragmentProcessor** fp) const {
+const GrFragmentProcessor* SkRadialGradient::asFragmentProcessor(GrContext* context,
+ const SkMatrix& viewM, const SkMatrix* localMatrix, SkFilterQuality,
+ GrProcessorDataManager* procDataManager) const {
SkASSERT(context);
SkMatrix matrix;
if (!this->getLocalMatrix().invert(&matrix)) {
- return false;
+ return nullptr;
}
if (localMatrix) {
SkMatrix inv;
if (!localMatrix->invert(&inv)) {
- return false;
+ return nullptr;
}
matrix.postConcat(inv);
}
matrix.postConcat(fPtsToUnit);
-
- *paintColor = SkColor2GrColorJustAlpha(paint.getColor());
- *fp = GrRadialGradient::Create(context, procDataManager, *this, matrix, fTileMode);
-
- return true;
-}
-
-#else
-
-bool SkRadialGradient::asFragmentProcessor(GrContext*, const SkPaint&, const SkMatrix&,
- const SkMatrix*, GrColor*, GrProcessorDataManager*,
- GrFragmentProcessor**) const {
- SkDEBUGFAIL("Should not call in GPU-less build");
- return false;
+ SkAutoTUnref<const GrFragmentProcessor> inner(
+ GrRadialGradient::Create(context, procDataManager, *this, matrix, fTileMode));
+ return GrExtractAlphaFragmentProcessor::Create(inner);
}
#endif
};
GradientType asAGradient(GradientInfo* info) const override;
- bool asFragmentProcessor(GrContext*, const SkPaint&, const SkMatrix& viewM,
- const SkMatrix*, GrColor*, GrProcessorDataManager*,
- GrFragmentProcessor**) const override;
+#if SK_SUPPORT_GPU
+ const GrFragmentProcessor* asFragmentProcessor(GrContext*, const SkMatrix& viewM,
+ const SkMatrix*, SkFilterQuality, GrProcessorDataManager*) const override;
+#endif
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkRadialGradient)
#if SK_SUPPORT_GPU
#include "SkGr.h"
+#include "effects/GrExtractAlphaFragmentProcessor.h"
#include "gl/builders/GrGLProgramBuilder.h"
class GrGLSweepGradient : public GrGLGradientEffect {
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrSweepGradient);
-GrFragmentProcessor* GrSweepGradient::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* GrSweepGradient::TestCreate(GrProcessorTestData* d) {
SkPoint center = {d->fRandom->nextUScalar1(), d->fRandom->nextUScalar1()};
SkColor colors[kMaxRandomGradientColors];
int colorCount = RandomGradientParams(d->fRandom, colors, &stops, &tmIgnored);
SkAutoTUnref<SkShader> shader(SkGradientShader::CreateSweep(center.fX, center.fY,
colors, stops, colorCount));
- SkPaint paint;
- GrFragmentProcessor* fp;
- GrColor paintColor;
- SkAssertResult(shader->asFragmentProcessor(d->fContext, paint,
- GrTest::TestMatrix(d->fRandom), nullptr,
- &paintColor, d->fProcDataManager, &fp));
+ const GrFragmentProcessor* fp = shader->asFragmentProcessor(d->fContext,
+ GrTest::TestMatrix(d->fRandom),
+ NULL, kNone_SkFilterQuality,
+ d->fProcDataManager);
+ GrAlwaysAssert(fp);
return fp;
}
/////////////////////////////////////////////////////////////////////
-bool SkSweepGradient::asFragmentProcessor(GrContext* context, const SkPaint& paint,
- const SkMatrix& viewM,
- const SkMatrix* localMatrix, GrColor* paintColor,
- GrProcessorDataManager* procDataManager,
- GrFragmentProcessor** effect) const {
+const GrFragmentProcessor* SkSweepGradient::asFragmentProcessor(GrContext* context,
+ const SkMatrix& viewM, const SkMatrix* localMatrix, SkFilterQuality,
+ GrProcessorDataManager* procDataManager) const {
SkMatrix matrix;
if (!this->getLocalMatrix().invert(&matrix)) {
- return false;
+ return nullptr;
}
if (localMatrix) {
SkMatrix inv;
if (!localMatrix->invert(&inv)) {
- return false;
+ return nullptr;
}
matrix.postConcat(inv);
}
matrix.postConcat(fPtsToUnit);
- *effect = GrSweepGradient::Create(context, procDataManager, *this, matrix);
- *paintColor = SkColor2GrColorJustAlpha(paint.getColor());
-
- return true;
-}
-
-#else
-
-bool SkSweepGradient::asFragmentProcessor(GrContext*, const SkPaint&, const SkMatrix&,
- const SkMatrix*, GrColor*, GrProcessorDataManager*,
- GrFragmentProcessor**) const {
- SkDEBUGFAIL("Should not call in GPU-less build");
- return false;
+ SkAutoTUnref<const GrFragmentProcessor> inner(
+ GrSweepGradient::Create(context, procDataManager, *this, matrix));
+ return GrExtractAlphaFragmentProcessor::Create(inner);
}
#endif
GradientType asAGradient(GradientInfo* info) const override;
- bool asFragmentProcessor(GrContext*, const SkPaint&, const SkMatrix& viewM,
- const SkMatrix*, GrColor*, GrProcessorDataManager*,
- GrFragmentProcessor**) const override;
+#if SK_SUPPORT_GPU
+ const GrFragmentProcessor* asFragmentProcessor(GrContext*, const SkMatrix& viewM,
+ const SkMatrix*, SkFilterQuality, GrProcessorDataManager*) const override;
+#endif
SK_TO_STRING_OVERRIDE()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkSweepGradient)
#if SK_SUPPORT_GPU
#include "SkGr.h"
+#include "effects/GrExtractAlphaFragmentProcessor.h"
-bool SkTwoPointConicalGradient::asFragmentProcessor(GrContext* context,
- const SkPaint& paint,
- const SkMatrix& viewM,
- const SkMatrix* localMatrix,
- GrColor* paintColor,
- GrProcessorDataManager* procDataManager,
- GrFragmentProcessor** fp) const {
+const GrFragmentProcessor* SkTwoPointConicalGradient::asFragmentProcessor(GrContext* context,
+ const SkMatrix& viewM, const SkMatrix* localMatrix, SkFilterQuality,
+ GrProcessorDataManager* procDataManager) const {
SkASSERT(context);
SkASSERT(fPtsToUnit.isIdentity());
-
- *fp = Gr2PtConicalGradientEffect::Create(context, procDataManager, *this, fTileMode,
- localMatrix);
- *paintColor = SkColor2GrColorJustAlpha(paint.getColor());
- return true;
-}
-
-#else
-
-bool SkTwoPointConicalGradient::asFragmentProcessor(GrContext*, const SkPaint&,
- const SkMatrix&, const SkMatrix*,
- GrColor*, GrProcessorDataManager*,
- GrFragmentProcessor**) const {
- SkDEBUGFAIL("Should not call in GPU-less build");
- return false;
+ SkAutoTUnref<const GrFragmentProcessor> inner(
+ Gr2PtConicalGradientEffect::Create(context, procDataManager, *this, fTileMode,
+ localMatrix));
+ return GrExtractAlphaFragmentProcessor::Create(inner);
}
#endif
};
SkShader::GradientType asAGradient(GradientInfo* info) const override;
- bool asFragmentProcessor(GrContext*, const SkPaint&, const SkMatrix&, const SkMatrix*,
- GrColor*, GrProcessorDataManager*,
- GrFragmentProcessor**) const override;
+#if SK_SUPPORT_GPU
+ const GrFragmentProcessor* asFragmentProcessor(GrContext*, const SkMatrix&, const SkMatrix*,
+ SkFilterQuality, GrProcessorDataManager*) const override;
+#endif
bool isOpaque() const override;
SkScalar getCenterX1() const { return SkPoint::Distance(fCenter1, fCenter2); }
/*
* All Two point conical gradient test create functions may occasionally create edge case shaders
*/
-GrFragmentProcessor* Edge2PtConicalEffect::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* Edge2PtConicalEffect::TestCreate(GrProcessorTestData* d) {
SkPoint center1 = {d->fRandom->nextUScalar1(), d->fRandom->nextUScalar1()};
SkScalar radius1 = d->fRandom->nextUScalar1();
SkPoint center2;
center2, radius2,
colors, stops, colorCount,
tm));
- SkPaint paint;
- GrFragmentProcessor* fp;
- GrColor paintColor;
- SkAssertResult(shader->asFragmentProcessor(d->fContext, paint,
- GrTest::TestMatrix(d->fRandom), nullptr,
- &paintColor, d->fProcDataManager, &fp));
+ const GrFragmentProcessor* fp = shader->asFragmentProcessor(d->fContext,
+ GrTest::TestMatrix(d->fRandom), NULL, kNone_SkFilterQuality, d->fProcDataManager);
+ GrAlwaysAssert(fp);
return fp;
}
/*
* All Two point conical gradient test create functions may occasionally create edge case shaders
*/
-GrFragmentProcessor* FocalOutside2PtConicalEffect::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* FocalOutside2PtConicalEffect::TestCreate(GrProcessorTestData* d) {
SkPoint center1 = {d->fRandom->nextUScalar1(), d->fRandom->nextUScalar1()};
SkScalar radius1 = 0.f;
SkPoint center2;
center2, radius2,
colors, stops, colorCount,
tm));
- SkPaint paint;
- GrFragmentProcessor* effect;
- GrColor paintColor;
- GrPaint grPaint;
- SkAssertResult(shader->asFragmentProcessor(d->fContext, paint,
- GrTest::TestMatrix(d->fRandom), nullptr,
- &paintColor, d->fProcDataManager,
- &effect));
- return effect;
+ const GrFragmentProcessor* fp = shader->asFragmentProcessor(d->fContext,
+ GrTest::TestMatrix(d->fRandom), NULL, kNone_SkFilterQuality, d->fProcDataManager);
+ GrAlwaysAssert(fp);
+ return fp;
}
GLFocalOutside2PtConicalEffect::GLFocalOutside2PtConicalEffect(const GrProcessor& processor)
/*
* All Two point conical gradient test create functions may occasionally create edge case shaders
*/
-GrFragmentProcessor* FocalInside2PtConicalEffect::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* FocalInside2PtConicalEffect::TestCreate(GrProcessorTestData* d) {
SkPoint center1 = {d->fRandom->nextUScalar1(), d->fRandom->nextUScalar1()};
SkScalar radius1 = 0.f;
SkPoint center2;
center2, radius2,
colors, stops, colorCount,
tm));
- SkPaint paint;
- GrColor paintColor;
- GrFragmentProcessor* fp;
- SkAssertResult(shader->asFragmentProcessor(d->fContext, paint,
- GrTest::TestMatrix(d->fRandom), nullptr,
- &paintColor, d->fProcDataManager, &fp));
+ const GrFragmentProcessor* fp = shader->asFragmentProcessor(d->fContext,
+ GrTest::TestMatrix(d->fRandom), NULL, kNone_SkFilterQuality, d->fProcDataManager);
+ GrAlwaysAssert(fp);
return fp;
}
/*
* All Two point conical gradient test create functions may occasionally create edge case shaders
*/
-GrFragmentProcessor*
-CircleInside2PtConicalEffect::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* CircleInside2PtConicalEffect::TestCreate(GrProcessorTestData* d) {
SkPoint center1 = {d->fRandom->nextUScalar1(), d->fRandom->nextUScalar1()};
SkScalar radius1 = d->fRandom->nextUScalar1() + 0.0001f; // make sure radius1 != 0
SkPoint center2;
center2, radius2,
colors, stops, colorCount,
tm));
- SkPaint paint;
- GrColor paintColor;
- GrFragmentProcessor* fp;
- SkAssertResult(shader->asFragmentProcessor(d->fContext, paint,
- GrTest::TestMatrix(d->fRandom), nullptr,
- &paintColor, d->fProcDataManager, &fp));
+ const GrFragmentProcessor* fp = shader->asFragmentProcessor(d->fContext,
+ GrTest::TestMatrix(d->fRandom), NULL, kNone_SkFilterQuality, d->fProcDataManager);
+ GrAlwaysAssert(fp);
return fp;
}
/*
* All Two point conical gradient test create functions may occasionally create edge case shaders
*/
-GrFragmentProcessor* CircleOutside2PtConicalEffect::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* CircleOutside2PtConicalEffect::TestCreate(GrProcessorTestData* d) {
SkPoint center1 = {d->fRandom->nextUScalar1(), d->fRandom->nextUScalar1()};
SkScalar radius1 = d->fRandom->nextUScalar1() + 0.0001f; // make sure radius1 != 0
SkPoint center2;
center2, radius2,
colors, stops, colorCount,
tm));
- SkPaint paint;
- GrColor paintColor;
- GrFragmentProcessor* fp;
- SkAssertResult(shader->asFragmentProcessor(d->fContext, paint,
- GrTest::TestMatrix(d->fRandom), nullptr,
- &paintColor, d->fProcDataManager, &fp));
+ const GrFragmentProcessor* fp = shader->asFragmentProcessor(
+ d->fContext,GrTest::TestMatrix(d->fRandom), NULL, kNone_SkFilterQuality,
+ d->fProcDataManager);
+ GrAlwaysAssert(fp);
return fp;
}
GR_DEFINE_GEOMETRY_PROCESSOR_TEST(QuadEdgeEffect);
-GrGeometryProcessor* QuadEdgeEffect::TestCreate(GrProcessorTestData* d) {
+const GrGeometryProcessor* QuadEdgeEffect::TestCreate(GrProcessorTestData* d) {
// Doesn't work without derivative instructions.
return d->fCaps->shaderCaps()->shaderDerivativeSupport() ?
QuadEdgeEffect::Create(GrRandomColor(d->fRandom),
GR_DEFINE_GEOMETRY_PROCESSOR_TEST(DefaultGeoProc);
-GrGeometryProcessor* DefaultGeoProc::TestCreate(GrProcessorTestData* d) {
+const GrGeometryProcessor* DefaultGeoProc::TestCreate(GrProcessorTestData* d) {
uint32_t flags = 0;
if (d->fRandom->nextBool()) {
flags |= kColor_GPFlag;
GR_DEFINE_GEOMETRY_PROCESSOR_TEST(CircleEdgeEffect);
-GrGeometryProcessor* CircleEdgeEffect::TestCreate(GrProcessorTestData* d) {
+const GrGeometryProcessor* CircleEdgeEffect::TestCreate(GrProcessorTestData* d) {
return CircleEdgeEffect::Create(GrRandomColor(d->fRandom),
d->fRandom->nextBool(),
GrTest::TestMatrix(d->fRandom),
GR_DEFINE_GEOMETRY_PROCESSOR_TEST(EllipseEdgeEffect);
-GrGeometryProcessor* EllipseEdgeEffect::TestCreate(GrProcessorTestData* d) {
+const GrGeometryProcessor* EllipseEdgeEffect::TestCreate(GrProcessorTestData* d) {
return EllipseEdgeEffect::Create(GrRandomColor(d->fRandom),
d->fRandom->nextBool(),
GrTest::TestMatrix(d->fRandom),
GR_DEFINE_GEOMETRY_PROCESSOR_TEST(DIEllipseEdgeEffect);
-GrGeometryProcessor* DIEllipseEdgeEffect::TestCreate(GrProcessorTestData* d) {
+const GrGeometryProcessor* DIEllipseEdgeEffect::TestCreate(GrProcessorTestData* d) {
return DIEllipseEdgeEffect::Create(GrRandomColor(d->fRandom),
GrTest::TestMatrix(d->fRandom),
(Mode)(d->fRandom->nextRangeU(0,2)),
return true;
}
-void GrFragmentProcessor::computeInvariantOutput(GrInvariantOutput* inout) const {
- this->onComputeInvariantOutput(inout);
-}
-
///////////////////////////////////////////////////////////////////////////////////////////////////
// Initial static variable from GrXPFactory
GrColor paintColor = SkColor2GrColor(skPaint.getColor());
- // Start a new block here in order to preserve our context state after calling
- // asFragmentProcessor(). Since these calls get passed back to the client, we don't really
- // want them messing around with the context.
- {
- // Allow the shader to modify paintColor and also create an effect to be installed as
- // the first color effect on the GrPaint.
- GrFragmentProcessor* fp = nullptr;
- if (!shader->asFragmentProcessor(context, skPaint, viewM, nullptr, &paintColor,
- grPaint->getProcessorDataManager(), &fp)) {
- return false;
- }
- if (fp) {
- grPaint->addColorFragmentProcessor(fp)->unref();
- constantColor = false;
- }
+ const GrFragmentProcessor* fp = shader->asFragmentProcessor(context, viewM, NULL,
+ skPaint.getFilterQuality(), grPaint->getProcessorDataManager());
+ if (!fp) {
+ return false;
}
+ grPaint->addColorFragmentProcessor(fp)->unref();
+ constantColor = false;
// The grcolor is automatically set when calling asFragmentProcessor.
// If the shader can be seen as an effect it returns true and adds its effect to the grpaint.
GR_DEFINE_GEOMETRY_PROCESSOR_TEST(GrConicEffect);
-GrGeometryProcessor* GrConicEffect::TestCreate(GrProcessorTestData* d) {
+const GrGeometryProcessor* GrConicEffect::TestCreate(GrProcessorTestData* d) {
GrGeometryProcessor* gp;
do {
GrPrimitiveEdgeType edgeType =
GR_DEFINE_GEOMETRY_PROCESSOR_TEST(GrQuadEffect);
-GrGeometryProcessor* GrQuadEffect::TestCreate(GrProcessorTestData* d) {
+const GrGeometryProcessor* GrQuadEffect::TestCreate(GrProcessorTestData* d) {
GrGeometryProcessor* gp;
do {
GrPrimitiveEdgeType edgeType = static_cast<GrPrimitiveEdgeType>(
GR_DEFINE_GEOMETRY_PROCESSOR_TEST(GrCubicEffect);
-GrGeometryProcessor* GrCubicEffect::TestCreate(GrProcessorTestData* d) {
+const GrGeometryProcessor* GrCubicEffect::TestCreate(GrProcessorTestData* d) {
GrGeometryProcessor* gp;
do {
GrPrimitiveEdgeType edgeType =
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrBicubicEffect);
-GrFragmentProcessor* GrBicubicEffect::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* GrBicubicEffect::TestCreate(GrProcessorTestData* d) {
int texIdx = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx :
GrProcessorUnitTest::kAlphaTextureIdx;
SkScalar coefficients[16];
GR_DEFINE_GEOMETRY_PROCESSOR_TEST(GrBitmapTextGeoProc);
-GrGeometryProcessor* GrBitmapTextGeoProc::TestCreate(GrProcessorTestData* d) {
+const GrGeometryProcessor* GrBitmapTextGeoProc::TestCreate(GrProcessorTestData* d) {
int texIdx = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx :
GrProcessorUnitTest::kAlphaTextureIdx;
static const SkShader::TileMode kTileModes[] = {
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrConfigConversionEffect);
-GrFragmentProcessor* GrConfigConversionEffect::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* GrConfigConversionEffect::TestCreate(GrProcessorTestData* d) {
PMConversion pmConv = static_cast<PMConversion>(d->fRandom->nextULessThan(kPMConversionCnt));
bool swapRB;
if (kNone_PMConversion == pmConv) {
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrConstColorProcessor);
-GrFragmentProcessor* GrConstColorProcessor::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* GrConstColorProcessor::TestCreate(GrProcessorTestData* d) {
GrColor color;
int colorPicker = d->fRandom->nextULessThan(3);
switch (colorPicker) {
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(AARectEffect);
-GrFragmentProcessor* AARectEffect::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* AARectEffect::TestCreate(GrProcessorTestData* d) {
SkRect rect = SkRect::MakeLTRB(d->fRandom->nextSScalar1(),
d->fRandom->nextSScalar1(),
d->fRandom->nextSScalar1(),
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrConvexPolyEffect);
-GrFragmentProcessor* GrConvexPolyEffect::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* GrConvexPolyEffect::TestCreate(GrProcessorTestData* d) {
int count = d->fRandom->nextULessThan(kMaxEdges) + 1;
SkScalar edges[kMaxEdges * 3];
for (int i = 0; i < 3 * count; ++i) {
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrConvolutionEffect);
-GrFragmentProcessor* GrConvolutionEffect::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* GrConvolutionEffect::TestCreate(GrProcessorTestData* d) {
int texIdx = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx :
GrProcessorUnitTest::kAlphaTextureIdx;
Direction dir = d->fRandom->nextBool() ? kX_Direction : kY_Direction;
GR_DEFINE_XP_FACTORY_TEST(GrCoverageSetOpXPFactory);
-GrXPFactory* GrCoverageSetOpXPFactory::TestCreate(GrProcessorTestData* d) {
+const GrXPFactory* GrCoverageSetOpXPFactory::TestCreate(GrProcessorTestData* d) {
SkRegion::Op regionOp = SkRegion::Op(d->fRandom->nextULessThan(SkRegion::kLastOp + 1));
bool invertCoverage = d->fRandom->nextBool();
return GrCoverageSetOpXPFactory::Create(regionOp, invertCoverage);
}
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrCustomXferFP);
-GrFragmentProcessor* GrCustomXferFP::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* GrCustomXferFP::TestCreate(GrProcessorTestData* d) {
int mode = d->fRandom->nextRangeU(SkXfermode::kLastCoeffMode + 1, SkXfermode::kLastSeparableMode);
return new GrCustomXferFP(d->fProcDataManager, static_cast<SkXfermode::Mode>(mode),
}
GR_DEFINE_XP_FACTORY_TEST(GrCustomXPFactory);
-GrXPFactory* GrCustomXPFactory::TestCreate(GrProcessorTestData* d) {
+const GrXPFactory* GrCustomXPFactory::TestCreate(GrProcessorTestData* d) {
int mode = d->fRandom->nextRangeU(SkXfermode::kLastCoeffMode + 1,
SkXfermode::kLastSeparableMode);
GR_DEFINE_GEOMETRY_PROCESSOR_TEST(DashingCircleEffect);
-GrGeometryProcessor* DashingCircleEffect::TestCreate(GrProcessorTestData* d) {
+const GrGeometryProcessor* DashingCircleEffect::TestCreate(GrProcessorTestData* d) {
DashAAMode aaMode = static_cast<DashAAMode>(d->fRandom->nextULessThan(kDashAAModeCount));
return DashingCircleEffect::Create(GrRandomColor(d->fRandom),
aaMode, GrTest::TestMatrix(d->fRandom),
GR_DEFINE_GEOMETRY_PROCESSOR_TEST(DashingLineEffect);
-GrGeometryProcessor* DashingLineEffect::TestCreate(GrProcessorTestData* d) {
+const GrGeometryProcessor* DashingLineEffect::TestCreate(GrProcessorTestData* d) {
DashAAMode aaMode = static_cast<DashAAMode>(d->fRandom->nextULessThan(kDashAAModeCount));
return DashingLineEffect::Create(GrRandomColor(d->fRandom),
aaMode, GrTest::TestMatrix(d->fRandom),
GR_DEFINE_XP_FACTORY_TEST(GrDisableColorXPFactory);
-GrXPFactory* GrDisableColorXPFactory::TestCreate(GrProcessorTestData*) {
+const GrXPFactory* GrDisableColorXPFactory::TestCreate(GrProcessorTestData*) {
return GrDisableColorXPFactory::Create();
}
GR_DEFINE_GEOMETRY_PROCESSOR_TEST(GrDistanceFieldA8TextGeoProc);
-GrGeometryProcessor* GrDistanceFieldA8TextGeoProc::TestCreate(GrProcessorTestData* d) {
+const GrGeometryProcessor* GrDistanceFieldA8TextGeoProc::TestCreate(GrProcessorTestData* d) {
int texIdx = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx :
GrProcessorUnitTest::kAlphaTextureIdx;
static const SkShader::TileMode kTileModes[] = {
GR_DEFINE_GEOMETRY_PROCESSOR_TEST(GrDistanceFieldPathGeoProc);
-GrGeometryProcessor* GrDistanceFieldPathGeoProc::TestCreate(GrProcessorTestData* d) {
+const GrGeometryProcessor* GrDistanceFieldPathGeoProc::TestCreate(GrProcessorTestData* d) {
int texIdx = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx
: GrProcessorUnitTest::kAlphaTextureIdx;
static const SkShader::TileMode kTileModes[] = {
GR_DEFINE_GEOMETRY_PROCESSOR_TEST(GrDistanceFieldLCDTextGeoProc);
-GrGeometryProcessor* GrDistanceFieldLCDTextGeoProc::TestCreate(GrProcessorTestData* d) {
+const GrGeometryProcessor* GrDistanceFieldLCDTextGeoProc::TestCreate(GrProcessorTestData* d) {
int texIdx = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx :
GrProcessorUnitTest::kAlphaTextureIdx;
static const SkShader::TileMode kTileModes[] = {
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(DitherEffect);
-GrFragmentProcessor* DitherEffect::TestCreate(GrProcessorTestData*) {
+const GrFragmentProcessor* DitherEffect::TestCreate(GrProcessorTestData*) {
return DitherEffect::Create();
}
--- /dev/null
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "effects/GrExtractAlphaFragmentProcessor.h"
+#include "gl/GrGLFragmentProcessor.h"
+#include "gl/builders/GrGLProgramBuilder.h"
+
+class GLExtractAlphaFragmentProcessor : public GrGLFragmentProcessor {
+public:
+ GLExtractAlphaFragmentProcessor() {}
+
+ void emitCode(EmitArgs& args) override {
+ GrGLFragmentBuilder* fsBuilder = args.fBuilder->getFragmentShaderBuilder();
+ fsBuilder->codeAppendf("vec4 alpha4 = %s.aaaa;", args.fInputColor);
+ SkString output;
+ this->emitChild(0, "alpha4", &output, args);
+ fsBuilder->codeAppendf("%s = %s;", args.fOutputColor, output.c_str());
+ }
+
+private:
+ typedef GrGLFragmentProcessor INHERITED;
+};
+
+GrGLFragmentProcessor* GrExtractAlphaFragmentProcessor::onCreateGLInstance() const {
+ return SkNEW(GLExtractAlphaFragmentProcessor);
+}
+
+void GrExtractAlphaFragmentProcessor::onGetGLProcessorKey(const GrGLSLCaps&,
+ GrProcessorKeyBuilder*) const {
+}
+
+bool GrExtractAlphaFragmentProcessor::onIsEqual(const GrFragmentProcessor&) const { return true; }
+
+void GrExtractAlphaFragmentProcessor::onComputeInvariantOutput(GrInvariantOutput* inout) const {
+ if (inout->validFlags() & kA_GrColorComponentFlag) {
+ GrColor color = GrColorPackA4(GrColorUnpackA(inout->color()));
+ inout->setToOther(kRGBA_GrColorComponentFlags, color,
+ GrInvariantOutput::kWill_ReadInput);
+ } else {
+ inout->setToUnknown(GrInvariantOutput::kWill_ReadInput);
+ }
+ this->childProcessor(0).computeInvariantOutput(inout);
+}
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrMatrixConvolutionEffect);
-GrFragmentProcessor* GrMatrixConvolutionEffect::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* GrMatrixConvolutionEffect::TestCreate(GrProcessorTestData* d) {
int texIdx = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx :
GrProcessorUnitTest::kAlphaTextureIdx;
int width = d->fRandom->nextRangeU(1, MAX_KERNEL_SIZE);
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(CircleEffect);
-GrFragmentProcessor* CircleEffect::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* CircleEffect::TestCreate(GrProcessorTestData* d) {
SkPoint center;
center.fX = d->fRandom->nextRangeScalar(0.f, 1000.f);
center.fY = d->fRandom->nextRangeScalar(0.f, 1000.f);
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(EllipseEffect);
-GrFragmentProcessor* EllipseEffect::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* EllipseEffect::TestCreate(GrProcessorTestData* d) {
SkPoint center;
center.fX = d->fRandom->nextRangeScalar(0.f, 1000.f);
center.fY = d->fRandom->nextRangeScalar(0.f, 1000.f);
GR_DEFINE_XP_FACTORY_TEST(GrPorterDuffXPFactory);
-GrXPFactory* GrPorterDuffXPFactory::TestCreate(GrProcessorTestData* d) {
+const GrXPFactory* GrPorterDuffXPFactory::TestCreate(GrProcessorTestData* d) {
SkXfermode::Mode mode = SkXfermode::Mode(d->fRandom->nextULessThan(SkXfermode::kLastCoeffMode));
return GrPorterDuffXPFactory::Create(mode);
}
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(CircularRRectEffect);
-GrFragmentProcessor* CircularRRectEffect::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* CircularRRectEffect::TestCreate(GrProcessorTestData* d) {
SkScalar w = d->fRandom->nextRangeScalar(20.f, 1000.f);
SkScalar h = d->fRandom->nextRangeScalar(20.f, 1000.f);
SkScalar r = d->fRandom->nextRangeF(kRadiusMin, 9.f);
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(EllipticalRRectEffect);
-GrFragmentProcessor* EllipticalRRectEffect::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* EllipticalRRectEffect::TestCreate(GrProcessorTestData* d) {
SkScalar w = d->fRandom->nextRangeScalar(20.f, 1000.f);
SkScalar h = d->fRandom->nextRangeScalar(20.f, 1000.f);
SkVector r[4];
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrSimpleTextureEffect);
-GrFragmentProcessor* GrSimpleTextureEffect::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* GrSimpleTextureEffect::TestCreate(GrProcessorTestData* d) {
int texIdx = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx :
GrProcessorUnitTest::kAlphaTextureIdx;
static const SkShader::TileMode kTileModes[] = {
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrTextureDomainEffect);
-GrFragmentProcessor* GrTextureDomainEffect::TestCreate(GrProcessorTestData* d) {
+const GrFragmentProcessor* GrTextureDomainEffect::TestCreate(GrProcessorTestData* d) {
int texIdx = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx :
GrProcessorUnitTest::kAlphaTextureIdx;
SkRect domain;
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(BigKeyProcessor);
-GrFragmentProcessor* BigKeyProcessor::TestCreate(GrProcessorTestData*) {
+const GrFragmentProcessor* BigKeyProcessor::TestCreate(GrProcessorTestData*) {
return BigKeyProcessor::Create();
}
projects / platform / upstream / libSkiaSharp.git / commitdiff