#include "SkTwoPointConicalGradient.h"
#if SK_SUPPORT_GPU
-#include "GrTBackendEffectFactory.h"
+#include "GrTBackendProcessorFactory.h"
+#include "gl/builders/GrGLProgramBuilder.h"
// For brevity
-typedef GrGLUniformManager::UniformHandle UniformHandle;
+typedef GrGLProgramDataManager::UniformHandle UniformHandle;
static const SkScalar kErrorTol = 0.00001f;
static const SkScalar kEdgeErrorTol = 5.f * kErrorTol;
class Edge2PtConicalEffect : public GrGradientEffect {
public:
- static GrEffectRef* Create(GrContext* ctx,
- const SkTwoPointConicalGradient& shader,
- const SkMatrix& matrix,
- SkShader::TileMode tm) {
- AutoEffectUnref effect(SkNEW_ARGS(Edge2PtConicalEffect, (ctx, shader, matrix, tm)));
- return CreateEffectRef(effect);
+ static GrFragmentProcessor* Create(GrContext* ctx,
+ const SkTwoPointConicalGradient& shader,
+ const SkMatrix& matrix,
+ SkShader::TileMode tm) {
+ return SkNEW_ARGS(Edge2PtConicalEffect, (ctx, shader, matrix, tm));
}
virtual ~Edge2PtConicalEffect() {}
static const char* Name() { return "Two-Point Conical Gradient Edge Touching"; }
- virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE;
+ virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
// The radial gradient parameters can collapse to a linear (instead of quadratic) equation.
SkScalar center() const { return fCenterX1; }
SkScalar diffRadius() const { return fDiffRadius; }
SkScalar radius() const { return fRadius0; }
- typedef GLEdge2PtConicalEffect GLEffect;
+ typedef GLEdge2PtConicalEffect GLProcessor;
private:
- virtual bool onIsEqual(const GrEffect& sBase) const SK_OVERRIDE {
- const Edge2PtConicalEffect& s = CastEffect<Edge2PtConicalEffect>(sBase);
+ virtual bool onIsEqual(const GrFragmentProcessor& sBase) const SK_OVERRIDE {
+ const Edge2PtConicalEffect& s = sBase.cast<Edge2PtConicalEffect>();
return (INHERITED::onIsEqual(sBase) &&
this->fCenterX1 == s.fCenterX1 &&
this->fRadius0 == s.fRadius0 &&
fDiffRadius(shader.getDiffRadius()){
// We should only be calling this shader if we are degenerate case with touching circles
// When deciding if we are in edge case, we scaled by the end radius for cases when the
- // start radius was close to zero, otherwise we scaled by the start radius
- SkASSERT(SkScalarAbs(SkScalarAbs(fDiffRadius) - SkScalarAbs(fCenterX1)) <
- kEdgeErrorTol * (fRadius0 < kErrorTol ? shader.getEndRadius() : fRadius0));
+ // start radius was close to zero, otherwise we scaled by the start radius. In addition
+ // Our test for the edge case in set_matrix_circle_conical has a higher tolerance so we
+ // need the sqrt value below
+ SkASSERT(SkScalarAbs(SkScalarAbs(fDiffRadius) - fCenterX1) <
+ (fRadius0 < kErrorTol ? shader.getEndRadius() * kEdgeErrorTol :
+ fRadius0 * sqrt(kEdgeErrorTol)));
// We pass the linear part of the quadratic as a varying.
// float b = -2.0 * (fCenterX1 * x + fRadius0 * fDiffRadius * z)
this->addCoordTransform(&fBTransform);
}
- GR_DECLARE_EFFECT_TEST;
+ GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
// @{
// Cache of values - these can change arbitrarily, EXCEPT
class GLEdge2PtConicalEffect : public GrGLGradientEffect {
public:
- GLEdge2PtConicalEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&);
+ GLEdge2PtConicalEffect(const GrBackendProcessorFactory& factory, const GrProcessor&);
virtual ~GLEdge2PtConicalEffect() { }
- virtual void emitCode(GrGLShaderBuilder*,
- const GrDrawEffect&,
- EffectKey,
+ virtual void emitCode(GrGLFPBuilder*,
+ const GrFragmentProcessor&,
+ const GrProcessorKey&,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray&) SK_OVERRIDE;
- virtual void setData(const GrGLUniformManager&, const GrDrawEffect&) SK_OVERRIDE;
+ virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
- static EffectKey GenKey(const GrDrawEffect&, const GrGLCaps& caps);
+ static void GenKey(const GrProcessor&, const GrGLCaps& caps, GrProcessorKeyBuilder* b);
protected:
UniformHandle fParamUni;
};
-const GrBackendEffectFactory& Edge2PtConicalEffect::getFactory() const {
- return GrTBackendEffectFactory<Edge2PtConicalEffect>::getInstance();
+const GrBackendFragmentProcessorFactory& Edge2PtConicalEffect::getFactory() const {
+ return GrTBackendFragmentProcessorFactory<Edge2PtConicalEffect>::getInstance();
}
-GR_DEFINE_EFFECT_TEST(Edge2PtConicalEffect);
+GR_DEFINE_FRAGMENT_PROCESSOR_TEST(Edge2PtConicalEffect);
-GrEffectRef* Edge2PtConicalEffect::TestCreate(SkRandom* random,
- GrContext* context,
- const GrDrawTargetCaps&,
- GrTexture**) {
+/*
+ * All Two point conical gradient test create functions may occasionally create edge case shaders
+ */
+GrFragmentProcessor* Edge2PtConicalEffect::TestCreate(SkRandom* random,
+ GrContext* context,
+ const GrDrawTargetCaps&,
+ GrTexture**) {
SkPoint center1 = {random->nextUScalar1(), random->nextUScalar1()};
SkScalar radius1 = random->nextUScalar1();
SkPoint center2;
colors, stops, colorCount,
tm));
SkPaint paint;
- GrEffectRef* effect;
- GrColor grColor;
- shader->asNewEffect(context, paint, NULL, &grColor, &effect);
- return effect;
+ GrFragmentProcessor* fp;
+ GrColor paintColor;
+ SkAssertResult(shader->asFragmentProcessor(context, paint, NULL, &paintColor, &fp));
+ return fp;
}
-GLEdge2PtConicalEffect::GLEdge2PtConicalEffect(const GrBackendEffectFactory& factory,
- const GrDrawEffect& drawEffect)
+GLEdge2PtConicalEffect::GLEdge2PtConicalEffect(const GrBackendProcessorFactory& factory,
+ const GrProcessor&)
: INHERITED(factory)
, fVSVaryingName(NULL)
, fFSVaryingName(NULL)
, fCachedRadius(-SK_ScalarMax)
, fCachedDiffRadius(-SK_ScalarMax) {}
-void GLEdge2PtConicalEffect::emitCode(GrGLShaderBuilder* builder,
- const GrDrawEffect&,
- EffectKey key,
+void GLEdge2PtConicalEffect::emitCode(GrGLFPBuilder* builder,
+ const GrFragmentProcessor&,
+ const GrProcessorKey& key,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray& coords,
const TextureSamplerArray& samplers) {
- this->emitUniforms(builder, key);
- fParamUni = builder->addUniformArray(GrGLShaderBuilder::kFragment_Visibility,
+ uint32_t baseKey = key.get32(0);
+ this->emitUniforms(builder, baseKey);
+ fParamUni = builder->addUniformArray(GrGLProgramBuilder::kFragment_Visibility,
kFloat_GrSLType, "Conical2FSParams", 3);
SkString cName("c");
builder->getUniformVariable(fParamUni).appendArrayAccess(2, &p2);
// We interpolate the linear component in coords[1].
- SkASSERT(coords[0].type() == coords[1].type());
+ SkASSERT(coords[0].getType() == coords[1].getType());
const char* coords2D;
SkString bVar;
- if (kVec3f_GrSLType == coords[0].type()) {
- builder->fsCodeAppendf("\tvec3 interpolants = vec3(%s.xy / %s.z, %s.x / %s.z);\n",
- coords[0].c_str(), coords[0].c_str(), coords[1].c_str(), coords[1].c_str());
+ GrGLFPFragmentBuilder* fsBuilder = builder->getFragmentShaderBuilder();
+ if (kVec3f_GrSLType == coords[0].getType()) {
+ fsBuilder->codeAppendf("\tvec3 interpolants = vec3(%s.xy / %s.z, %s.x / %s.z);\n",
+ coords[0].c_str(), coords[0].c_str(), coords[1].c_str(),
+ coords[1].c_str());
coords2D = "interpolants.xy";
bVar = "interpolants.z";
} else {
// output will default to transparent black (we simply won't write anything
// else to it if invalid, instead of discarding or returning prematurely)
- builder->fsCodeAppendf("\t%s = vec4(0.0,0.0,0.0,0.0);\n", outputColor);
+ fsBuilder->codeAppendf("\t%s = vec4(0.0,0.0,0.0,0.0);\n", outputColor);
// c = (x^2)+(y^2) - params[1]
- builder->fsCodeAppendf("\tfloat %s = dot(%s, %s) - %s;\n",
+ fsBuilder->codeAppendf("\tfloat %s = dot(%s, %s) - %s;\n",
cName.c_str(), coords2D, coords2D, p1.c_str());
// linear case: t = -c/b
- builder->fsCodeAppendf("\tfloat %s = -(%s / %s);\n", tName.c_str(),
+ fsBuilder->codeAppendf("\tfloat %s = -(%s / %s);\n", tName.c_str(),
cName.c_str(), bVar.c_str());
// if r(t) > 0, then t will be the x coordinate
- builder->fsCodeAppendf("\tif (%s * %s + %s > 0.0) {\n", tName.c_str(),
+ fsBuilder->codeAppendf("\tif (%s * %s + %s > 0.0) {\n", tName.c_str(),
p2.c_str(), p0.c_str());
- builder->fsCodeAppend("\t");
- this->emitColor(builder, tName.c_str(), key, outputColor, inputColor, samplers);
- builder->fsCodeAppend("\t}\n");
+ fsBuilder->codeAppend("\t");
+ this->emitColor(builder, tName.c_str(), baseKey, outputColor, inputColor, samplers);
+ fsBuilder->codeAppend("\t}\n");
}
-void GLEdge2PtConicalEffect::setData(const GrGLUniformManager& uman,
- const GrDrawEffect& drawEffect) {
- INHERITED::setData(uman, drawEffect);
- const Edge2PtConicalEffect& data = drawEffect.castEffect<Edge2PtConicalEffect>();
+void GLEdge2PtConicalEffect::setData(const GrGLProgramDataManager& pdman,
+ const GrProcessor& processor) {
+ INHERITED::setData(pdman, processor);
+ const Edge2PtConicalEffect& data = processor.cast<Edge2PtConicalEffect>();
SkScalar radius0 = data.radius();
SkScalar diffRadius = data.diffRadius();
SkScalarToFloat(diffRadius)
};
- uman.set1fv(fParamUni, 3, values);
+ pdman.set1fv(fParamUni, 3, values);
fCachedRadius = radius0;
fCachedDiffRadius = diffRadius;
}
}
-GrGLEffect::EffectKey GLEdge2PtConicalEffect::GenKey(const GrDrawEffect& drawEffect,
- const GrGLCaps&) {
- return GenBaseGradientKey(drawEffect);
+void GLEdge2PtConicalEffect::GenKey(const GrProcessor& processor,
+ const GrGLCaps&, GrProcessorKeyBuilder* b) {
+ b->add32(GenBaseGradientKey(processor));
}
//////////////////////////////////////////////////////////////////////////////
class FocalOutside2PtConicalEffect : public GrGradientEffect {
public:
- static GrEffectRef* Create(GrContext* ctx,
- const SkTwoPointConicalGradient& shader,
- const SkMatrix& matrix,
- SkShader::TileMode tm,
- SkScalar focalX) {
- AutoEffectUnref effect(SkNEW_ARGS(FocalOutside2PtConicalEffect, (ctx, shader, matrix, tm, focalX)));
- return CreateEffectRef(effect);
+ static GrFragmentProcessor* Create(GrContext* ctx,
+ const SkTwoPointConicalGradient& shader,
+ const SkMatrix& matrix,
+ SkShader::TileMode tm,
+ SkScalar focalX) {
+ return SkNEW_ARGS(FocalOutside2PtConicalEffect, (ctx, shader, matrix, tm, focalX));
}
virtual ~FocalOutside2PtConicalEffect() { }
static const char* Name() { return "Two-Point Conical Gradient Focal Outside"; }
- virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE;
+ virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
bool isFlipped() const { return fIsFlipped; }
SkScalar focal() const { return fFocalX; }
- typedef GLFocalOutside2PtConicalEffect GLEffect;
+ typedef GLFocalOutside2PtConicalEffect GLProcessor;
private:
- virtual bool onIsEqual(const GrEffect& sBase) const SK_OVERRIDE {
- const FocalOutside2PtConicalEffect& s = CastEffect<FocalOutside2PtConicalEffect>(sBase);
+ virtual bool onIsEqual(const GrFragmentProcessor& sBase) const SK_OVERRIDE {
+ const FocalOutside2PtConicalEffect& s = sBase.cast<FocalOutside2PtConicalEffect>();
return (INHERITED::onIsEqual(sBase) &&
this->fFocalX == s.fFocalX &&
this->fIsFlipped == s.fIsFlipped);
SkScalar focalX)
: INHERITED(ctx, shader, matrix, tm), fFocalX(focalX), fIsFlipped(shader.isFlippedGrad()) {}
- GR_DECLARE_EFFECT_TEST;
+ GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
SkScalar fFocalX;
bool fIsFlipped;
class GLFocalOutside2PtConicalEffect : public GrGLGradientEffect {
public:
- GLFocalOutside2PtConicalEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&);
+ GLFocalOutside2PtConicalEffect(const GrBackendProcessorFactory& factory, const GrProcessor&);
virtual ~GLFocalOutside2PtConicalEffect() { }
- virtual void emitCode(GrGLShaderBuilder*,
- const GrDrawEffect&,
- EffectKey,
+ virtual void emitCode(GrGLFPBuilder*,
+ const GrFragmentProcessor&,
+ const GrProcessorKey&,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray&) SK_OVERRIDE;
- virtual void setData(const GrGLUniformManager&, const GrDrawEffect&) SK_OVERRIDE;
+ virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
- static EffectKey GenKey(const GrDrawEffect&, const GrGLCaps& caps);
+ static void GenKey(const GrProcessor&, const GrGLCaps& caps, GrProcessorKeyBuilder* b);
protected:
UniformHandle fParamUni;
};
-const GrBackendEffectFactory& FocalOutside2PtConicalEffect::getFactory() const {
- return GrTBackendEffectFactory<FocalOutside2PtConicalEffect>::getInstance();
+const GrBackendFragmentProcessorFactory& FocalOutside2PtConicalEffect::getFactory() const {
+ return GrTBackendFragmentProcessorFactory<FocalOutside2PtConicalEffect>::getInstance();
}
-GR_DEFINE_EFFECT_TEST(FocalOutside2PtConicalEffect);
+GR_DEFINE_FRAGMENT_PROCESSOR_TEST(FocalOutside2PtConicalEffect);
-GrEffectRef* FocalOutside2PtConicalEffect::TestCreate(SkRandom* random,
- GrContext* context,
- const GrDrawTargetCaps&,
- GrTexture**) {
+/*
+ * All Two point conical gradient test create functions may occasionally create edge case shaders
+ */
+GrFragmentProcessor* FocalOutside2PtConicalEffect::TestCreate(SkRandom* random,
+ GrContext* context,
+ const GrDrawTargetCaps&,
+ GrTexture**) {
SkPoint center1 = {random->nextUScalar1(), random->nextUScalar1()};
SkScalar radius1 = 0.f;
SkPoint center2;
colors, stops, colorCount,
tm));
SkPaint paint;
- GrEffectRef* effect;
- GrColor grColor;
- shader->asNewEffect(context, paint, NULL, &grColor, &effect);
+ GrFragmentProcessor* effect;
+ GrColor paintColor;
+ SkAssertResult(shader->asFragmentProcessor(context, paint, NULL, &paintColor, &effect));
return effect;
}
-GLFocalOutside2PtConicalEffect::GLFocalOutside2PtConicalEffect(const GrBackendEffectFactory& factory,
- const GrDrawEffect& drawEffect)
+GLFocalOutside2PtConicalEffect::GLFocalOutside2PtConicalEffect(const GrBackendProcessorFactory& factory,
+ const GrProcessor& processor)
: INHERITED(factory)
, fVSVaryingName(NULL)
, fFSVaryingName(NULL)
, fCachedFocal(SK_ScalarMax) {
- const FocalOutside2PtConicalEffect& data = drawEffect.castEffect<FocalOutside2PtConicalEffect>();
+ const FocalOutside2PtConicalEffect& data = processor.cast<FocalOutside2PtConicalEffect>();
fIsFlipped = data.isFlipped();
}
-void GLFocalOutside2PtConicalEffect::emitCode(GrGLShaderBuilder* builder,
- const GrDrawEffect&,
- EffectKey key,
+void GLFocalOutside2PtConicalEffect::emitCode(GrGLFPBuilder* builder,
+ const GrFragmentProcessor&,
+ const GrProcessorKey& key,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray& coords,
const TextureSamplerArray& samplers) {
- this->emitUniforms(builder, key);
- fParamUni = builder->addUniformArray(GrGLShaderBuilder::kFragment_Visibility,
+ uint32_t baseKey = key.get32(0);
+ this->emitUniforms(builder, baseKey);
+ fParamUni = builder->addUniformArray(GrGLProgramBuilder::kFragment_Visibility,
kFloat_GrSLType, "Conical2FSParams", 2);
SkString tName("t");
SkString p0; // focalX
builder->getUniformVariable(fParamUni).appendArrayAccess(1, &p1);
// if we have a vec3 from being in perspective, convert it to a vec2 first
- SkString coords2DString = builder->ensureFSCoords2D(coords, 0);
+ GrGLFPFragmentBuilder* fsBuilder = builder->getFragmentShaderBuilder();
+ SkString coords2DString = fsBuilder->ensureFSCoords2D(coords, 0);
const char* coords2D = coords2DString.c_str();
// t = p.x * focal.x +/- sqrt(p.x^2 + (1 - focal.x^2) * p.y^2)
// output will default to transparent black (we simply won't write anything
// else to it if invalid, instead of discarding or returning prematurely)
- builder->fsCodeAppendf("\t%s = vec4(0.0,0.0,0.0,0.0);\n", outputColor);
+ fsBuilder->codeAppendf("\t%s = vec4(0.0,0.0,0.0,0.0);\n", outputColor);
- builder->fsCodeAppendf("\tfloat xs = %s.x * %s.x;\n", coords2D, coords2D);
- builder->fsCodeAppendf("\tfloat ys = %s.y * %s.y;\n", coords2D, coords2D);
- builder->fsCodeAppendf("\tfloat d = xs + %s * ys;\n", p1.c_str());
+ fsBuilder->codeAppendf("\tfloat xs = %s.x * %s.x;\n", coords2D, coords2D);
+ fsBuilder->codeAppendf("\tfloat ys = %s.y * %s.y;\n", coords2D, coords2D);
+ fsBuilder->codeAppendf("\tfloat d = xs + %s * ys;\n", p1.c_str());
// Must check to see if we flipped the circle order (to make sure start radius < end radius)
// If so we must also flip sign on sqrt
if (!fIsFlipped) {
- builder->fsCodeAppendf("\tfloat %s = %s.x * %s + sqrt(d);\n", tName.c_str(),
+ fsBuilder->codeAppendf("\tfloat %s = %s.x * %s + sqrt(d);\n", tName.c_str(),
coords2D, p0.c_str());
} else {
- builder->fsCodeAppendf("\tfloat %s = %s.x * %s - sqrt(d);\n", tName.c_str(),
+ fsBuilder->codeAppendf("\tfloat %s = %s.x * %s - sqrt(d);\n", tName.c_str(),
coords2D, p0.c_str());
}
- builder->fsCodeAppendf("\tif (%s >= 0.0 && d >= 0.0) {\n", tName.c_str());
- builder->fsCodeAppend("\t\t");
- this->emitColor(builder, tName.c_str(), key, outputColor, inputColor, samplers);
- builder->fsCodeAppend("\t}\n");
+ fsBuilder->codeAppendf("\tif (%s >= 0.0 && d >= 0.0) {\n", tName.c_str());
+ fsBuilder->codeAppend("\t\t");
+ this->emitColor(builder, tName.c_str(), baseKey, outputColor, inputColor, samplers);
+ fsBuilder->codeAppend("\t}\n");
}
-void GLFocalOutside2PtConicalEffect::setData(const GrGLUniformManager& uman,
- const GrDrawEffect& drawEffect) {
- INHERITED::setData(uman, drawEffect);
- const FocalOutside2PtConicalEffect& data = drawEffect.castEffect<FocalOutside2PtConicalEffect>();
+void GLFocalOutside2PtConicalEffect::setData(const GrGLProgramDataManager& pdman,
+ const GrProcessor& processor) {
+ INHERITED::setData(pdman, processor);
+ const FocalOutside2PtConicalEffect& data = processor.cast<FocalOutside2PtConicalEffect>();
SkASSERT(data.isFlipped() == fIsFlipped);
SkScalar focal = data.focal();
SkScalarToFloat(oneMinus2F),
};
- uman.set1fv(fParamUni, 2, values);
+ pdman.set1fv(fParamUni, 2, values);
fCachedFocal = focal;
}
}
-GrGLEffect::EffectKey GLFocalOutside2PtConicalEffect::GenKey(const GrDrawEffect& drawEffect,
- const GrGLCaps&) {
- enum {
- kIsFlipped = 1 << kBaseKeyBitCnt,
- };
-
- EffectKey key = GenBaseGradientKey(drawEffect);
-
- if (drawEffect.castEffect<FocalOutside2PtConicalEffect>().isFlipped()) {
- key |= kIsFlipped;
- }
- return key;
+void GLFocalOutside2PtConicalEffect::GenKey(const GrProcessor& processor,
+ const GrGLCaps&, GrProcessorKeyBuilder* b) {
+ uint32_t* key = b->add32n(2);
+ key[0] = GenBaseGradientKey(processor);
+ key[1] = processor.cast<FocalOutside2PtConicalEffect>().isFlipped();
}
//////////////////////////////////////////////////////////////////////////////
class FocalInside2PtConicalEffect : public GrGradientEffect {
public:
- static GrEffectRef* Create(GrContext* ctx,
- const SkTwoPointConicalGradient& shader,
- const SkMatrix& matrix,
- SkShader::TileMode tm,
- SkScalar focalX) {
- AutoEffectUnref effect(SkNEW_ARGS(FocalInside2PtConicalEffect, (ctx, shader, matrix, tm, focalX)));
- return CreateEffectRef(effect);
+ static GrFragmentProcessor* Create(GrContext* ctx,
+ const SkTwoPointConicalGradient& shader,
+ const SkMatrix& matrix,
+ SkShader::TileMode tm,
+ SkScalar focalX) {
+ return SkNEW_ARGS(FocalInside2PtConicalEffect, (ctx, shader, matrix, tm, focalX));
}
virtual ~FocalInside2PtConicalEffect() {}
static const char* Name() { return "Two-Point Conical Gradient Focal Inside"; }
- virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE;
+ virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
SkScalar focal() const { return fFocalX; }
- typedef GLFocalInside2PtConicalEffect GLEffect;
+ typedef GLFocalInside2PtConicalEffect GLProcessor;
private:
- virtual bool onIsEqual(const GrEffect& sBase) const SK_OVERRIDE {
- const FocalInside2PtConicalEffect& s = CastEffect<FocalInside2PtConicalEffect>(sBase);
+ virtual bool onIsEqual(const GrFragmentProcessor& sBase) const SK_OVERRIDE {
+ const FocalInside2PtConicalEffect& s = sBase.cast<FocalInside2PtConicalEffect>();
return (INHERITED::onIsEqual(sBase) &&
this->fFocalX == s.fFocalX);
}
SkScalar focalX)
: INHERITED(ctx, shader, matrix, tm), fFocalX(focalX) {}
- GR_DECLARE_EFFECT_TEST;
+ GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
SkScalar fFocalX;
class GLFocalInside2PtConicalEffect : public GrGLGradientEffect {
public:
- GLFocalInside2PtConicalEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&);
+ GLFocalInside2PtConicalEffect(const GrBackendProcessorFactory& factory, const GrProcessor&);
virtual ~GLFocalInside2PtConicalEffect() {}
- virtual void emitCode(GrGLShaderBuilder*,
- const GrDrawEffect&,
- EffectKey,
+ virtual void emitCode(GrGLFPBuilder*,
+ const GrFragmentProcessor&,
+ const GrProcessorKey&,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray&) SK_OVERRIDE;
- virtual void setData(const GrGLUniformManager&, const GrDrawEffect&) SK_OVERRIDE;
+ virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
- static EffectKey GenKey(const GrDrawEffect&, const GrGLCaps& caps);
+ static void GenKey(const GrProcessor&, const GrGLCaps& caps, GrProcessorKeyBuilder* b);
protected:
UniformHandle fFocalUni;
};
-const GrBackendEffectFactory& FocalInside2PtConicalEffect::getFactory() const {
- return GrTBackendEffectFactory<FocalInside2PtConicalEffect>::getInstance();
+const GrBackendFragmentProcessorFactory& FocalInside2PtConicalEffect::getFactory() const {
+ return GrTBackendFragmentProcessorFactory<FocalInside2PtConicalEffect>::getInstance();
}
-GR_DEFINE_EFFECT_TEST(FocalInside2PtConicalEffect);
+GR_DEFINE_FRAGMENT_PROCESSOR_TEST(FocalInside2PtConicalEffect);
-GrEffectRef* FocalInside2PtConicalEffect::TestCreate(SkRandom* random,
- GrContext* context,
- const GrDrawTargetCaps&,
- GrTexture**) {
+/*
+ * All Two point conical gradient test create functions may occasionally create edge case shaders
+ */
+GrFragmentProcessor* FocalInside2PtConicalEffect::TestCreate(SkRandom* random,
+ GrContext* context,
+ const GrDrawTargetCaps&,
+ GrTexture**) {
SkPoint center1 = {random->nextUScalar1(), random->nextUScalar1()};
SkScalar radius1 = 0.f;
SkPoint center2;
colors, stops, colorCount,
tm));
SkPaint paint;
- GrColor grColor;
- GrEffectRef* grEffect;
- shader->asNewEffect(context, paint, NULL, &grColor, &grEffect);
- return grEffect;
+ GrColor paintColor;
+ GrFragmentProcessor* fp;
+ SkAssertResult(shader->asFragmentProcessor(context, paint, NULL, &paintColor, &fp));
+ return fp;
}
-GLFocalInside2PtConicalEffect::GLFocalInside2PtConicalEffect(const GrBackendEffectFactory& factory,
- const GrDrawEffect& drawEffect)
+GLFocalInside2PtConicalEffect::GLFocalInside2PtConicalEffect(const GrBackendProcessorFactory& factory,
+ const GrProcessor&)
: INHERITED(factory)
, fVSVaryingName(NULL)
, fFSVaryingName(NULL)
, fCachedFocal(SK_ScalarMax) {}
-void GLFocalInside2PtConicalEffect::emitCode(GrGLShaderBuilder* builder,
- const GrDrawEffect&,
- EffectKey key,
+void GLFocalInside2PtConicalEffect::emitCode(GrGLFPBuilder* builder,
+ const GrFragmentProcessor&,
+ const GrProcessorKey& key,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray& coords,
const TextureSamplerArray& samplers) {
- this->emitUniforms(builder, key);
- fFocalUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility,
+ uint32_t baseKey = key.get32(0);
+ this->emitUniforms(builder, baseKey);
+ fFocalUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
kFloat_GrSLType, "Conical2FSParams");
SkString tName("t");
GrGLShaderVar focal = builder->getUniformVariable(fFocalUni);
// if we have a vec3 from being in perspective, convert it to a vec2 first
- SkString coords2DString = builder->ensureFSCoords2D(coords, 0);
+ GrGLFPFragmentBuilder* fsBuilder = builder->getFragmentShaderBuilder();
+ SkString coords2DString = fsBuilder->ensureFSCoords2D(coords, 0);
const char* coords2D = coords2DString.c_str();
// t = p.x * focalX + length(p)
- builder->fsCodeAppendf("\tfloat %s = %s.x * %s + length(%s);\n", tName.c_str(),
+ fsBuilder->codeAppendf("\tfloat %s = %s.x * %s + length(%s);\n", tName.c_str(),
coords2D, focal.c_str(), coords2D);
- this->emitColor(builder, tName.c_str(), key, outputColor, inputColor, samplers);
+ this->emitColor(builder, tName.c_str(), baseKey, outputColor, inputColor, samplers);
}
-void GLFocalInside2PtConicalEffect::setData(const GrGLUniformManager& uman,
- const GrDrawEffect& drawEffect) {
- INHERITED::setData(uman, drawEffect);
- const FocalInside2PtConicalEffect& data = drawEffect.castEffect<FocalInside2PtConicalEffect>();
+void GLFocalInside2PtConicalEffect::setData(const GrGLProgramDataManager& pdman,
+ const GrProcessor& processor) {
+ INHERITED::setData(pdman, processor);
+ const FocalInside2PtConicalEffect& data = processor.cast<FocalInside2PtConicalEffect>();
SkScalar focal = data.focal();
if (fCachedFocal != focal) {
- uman.set1f(fFocalUni, SkScalarToFloat(focal));
+ pdman.set1f(fFocalUni, SkScalarToFloat(focal));
fCachedFocal = focal;
}
}
-GrGLEffect::EffectKey GLFocalInside2PtConicalEffect::GenKey(const GrDrawEffect& drawEffect,
- const GrGLCaps&) {
- return GenBaseGradientKey(drawEffect);
+void GLFocalInside2PtConicalEffect::GenKey(const GrProcessor& processor,
+ const GrGLCaps&, GrProcessorKeyBuilder* b) {
+ b->add32(GenBaseGradientKey(processor));
}
//////////////////////////////////////////////////////////////////////////////
class CircleInside2PtConicalEffect : public GrGradientEffect {
public:
- static GrEffectRef* Create(GrContext* ctx,
- const SkTwoPointConicalGradient& shader,
- const SkMatrix& matrix,
- SkShader::TileMode tm,
- const CircleConicalInfo& info) {
- AutoEffectUnref effect(SkNEW_ARGS(CircleInside2PtConicalEffect, (ctx, shader, matrix, tm, info)));
- return CreateEffectRef(effect);
+ static GrFragmentProcessor* Create(GrContext* ctx,
+ const SkTwoPointConicalGradient& shader,
+ const SkMatrix& matrix,
+ SkShader::TileMode tm,
+ const CircleConicalInfo& info) {
+ return SkNEW_ARGS(CircleInside2PtConicalEffect, (ctx, shader, matrix, tm, info));
}
virtual ~CircleInside2PtConicalEffect() {}
static const char* Name() { return "Two-Point Conical Gradient Inside"; }
- virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE;
+ virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
SkScalar centerX() const { return fInfo.fCenterEnd.fX; }
SkScalar centerY() const { return fInfo.fCenterEnd.fY; }
SkScalar B() const { return fInfo.fB; }
SkScalar C() const { return fInfo.fC; }
- typedef GLCircleInside2PtConicalEffect GLEffect;
+ typedef GLCircleInside2PtConicalEffect GLProcessor;
private:
- virtual bool onIsEqual(const GrEffect& sBase) const SK_OVERRIDE {
- const CircleInside2PtConicalEffect& s = CastEffect<CircleInside2PtConicalEffect>(sBase);
+ virtual bool onIsEqual(const GrFragmentProcessor& sBase) const SK_OVERRIDE {
+ const CircleInside2PtConicalEffect& s = sBase.cast<CircleInside2PtConicalEffect>();
return (INHERITED::onIsEqual(sBase) &&
this->fInfo.fCenterEnd == s.fInfo.fCenterEnd &&
this->fInfo.fA == s.fInfo.fA &&
const CircleConicalInfo& info)
: INHERITED(ctx, shader, matrix, tm), fInfo(info) {}
- GR_DECLARE_EFFECT_TEST;
+ GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
const CircleConicalInfo fInfo;
class GLCircleInside2PtConicalEffect : public GrGLGradientEffect {
public:
- GLCircleInside2PtConicalEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&);
+ GLCircleInside2PtConicalEffect(const GrBackendProcessorFactory& factory, const GrProcessor&);
virtual ~GLCircleInside2PtConicalEffect() {}
- virtual void emitCode(GrGLShaderBuilder*,
- const GrDrawEffect&,
- EffectKey,
+ virtual void emitCode(GrGLFPBuilder*,
+ const GrFragmentProcessor&,
+ const GrProcessorKey&,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray&) SK_OVERRIDE;
- virtual void setData(const GrGLUniformManager&, const GrDrawEffect&) SK_OVERRIDE;
+ virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
- static EffectKey GenKey(const GrDrawEffect&, const GrGLCaps& caps);
+ static void GenKey(const GrProcessor&, const GrGLCaps& caps, GrProcessorKeyBuilder* b);
protected:
UniformHandle fCenterUni;
};
-const GrBackendEffectFactory& CircleInside2PtConicalEffect::getFactory() const {
- return GrTBackendEffectFactory<CircleInside2PtConicalEffect>::getInstance();
+const GrBackendFragmentProcessorFactory& CircleInside2PtConicalEffect::getFactory() const {
+ return GrTBackendFragmentProcessorFactory<CircleInside2PtConicalEffect>::getInstance();
}
-GR_DEFINE_EFFECT_TEST(CircleInside2PtConicalEffect);
+GR_DEFINE_FRAGMENT_PROCESSOR_TEST(CircleInside2PtConicalEffect);
-GrEffectRef* CircleInside2PtConicalEffect::TestCreate(SkRandom* random,
- GrContext* context,
- const GrDrawTargetCaps&,
- GrTexture**) {
+/*
+ * All Two point conical gradient test create functions may occasionally create edge case shaders
+ */
+GrFragmentProcessor* CircleInside2PtConicalEffect::TestCreate(SkRandom* random,
+ GrContext* context,
+ const GrDrawTargetCaps&,
+ GrTexture**) {
SkPoint center1 = {random->nextUScalar1(), random->nextUScalar1()};
SkScalar radius1 = random->nextUScalar1() + 0.0001f; // make sure radius1 != 0
SkPoint center2;
colors, stops, colorCount,
tm));
SkPaint paint;
- GrColor grColor;
- GrEffectRef* grEffect;
- shader->asNewEffect(context, paint, NULL, &grColor, &grEffect);
- return grEffect;
+ GrColor paintColor;
+ GrFragmentProcessor* processor;
+ SkAssertResult(shader->asFragmentProcessor(context, paint, NULL, &paintColor, &processor));
+ return processor;
}
-GLCircleInside2PtConicalEffect::GLCircleInside2PtConicalEffect(const GrBackendEffectFactory& factory,
- const GrDrawEffect& drawEffect)
+GLCircleInside2PtConicalEffect::GLCircleInside2PtConicalEffect(const GrBackendProcessorFactory& factory,
+ const GrProcessor& processor)
: INHERITED(factory)
, fVSVaryingName(NULL)
, fFSVaryingName(NULL)
, fCachedB(SK_ScalarMax)
, fCachedC(SK_ScalarMax) {}
-void GLCircleInside2PtConicalEffect::emitCode(GrGLShaderBuilder* builder,
- const GrDrawEffect&,
- EffectKey key,
+void GLCircleInside2PtConicalEffect::emitCode(GrGLFPBuilder* builder,
+ const GrFragmentProcessor&,
+ const GrProcessorKey& key,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray& coords,
const TextureSamplerArray& samplers) {
- this->emitUniforms(builder, key);
- fCenterUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility,
+ uint32_t baseKey = key.get32(0);
+ this->emitUniforms(builder, baseKey);
+ fCenterUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
kVec2f_GrSLType, "Conical2FSCenter");
- fParamUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility,
+ fParamUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
kVec3f_GrSLType, "Conical2FSParams");
SkString tName("t");
GrGLShaderVar params = builder->getUniformVariable(fParamUni);
// if we have a vec3 from being in perspective, convert it to a vec2 first
- SkString coords2DString = builder->ensureFSCoords2D(coords, 0);
+ GrGLFPFragmentBuilder* fsBuilder = builder->getFragmentShaderBuilder();
+ SkString coords2DString = fsBuilder->ensureFSCoords2D(coords, 0);
const char* coords2D = coords2DString.c_str();
// p = coords2D
// C = 1 / A
// d = dot(e, p) + B
// t = d +/- sqrt(d^2 - A * dot(p, p) + C)
- builder->fsCodeAppendf("\tfloat pDotp = dot(%s, %s);\n", coords2D, coords2D);
- builder->fsCodeAppendf("\tfloat d = dot(%s, %s) + %s.y;\n", coords2D, center.c_str(), params.c_str());
- builder->fsCodeAppendf("\tfloat %s = d + sqrt(d * d - %s.x * pDotp + %s.z);\n",
+ fsBuilder->codeAppendf("\tfloat pDotp = dot(%s, %s);\n", coords2D, coords2D);
+ fsBuilder->codeAppendf("\tfloat d = dot(%s, %s) + %s.y;\n", coords2D, center.c_str(),
+ params.c_str());
+ fsBuilder->codeAppendf("\tfloat %s = d + sqrt(d * d - %s.x * pDotp + %s.z);\n",
tName.c_str(), params.c_str(), params.c_str());
- this->emitColor(builder, tName.c_str(), key, outputColor, inputColor, samplers);
+ this->emitColor(builder, tName.c_str(), baseKey, outputColor, inputColor, samplers);
}
-void GLCircleInside2PtConicalEffect::setData(const GrGLUniformManager& uman,
- const GrDrawEffect& drawEffect) {
- INHERITED::setData(uman, drawEffect);
- const CircleInside2PtConicalEffect& data = drawEffect.castEffect<CircleInside2PtConicalEffect>();
+void GLCircleInside2PtConicalEffect::setData(const GrGLProgramDataManager& pdman,
+ const GrProcessor& processor) {
+ INHERITED::setData(pdman, processor);
+ const CircleInside2PtConicalEffect& data = processor.cast<CircleInside2PtConicalEffect>();
SkScalar centerX = data.centerX();
SkScalar centerY = data.centerY();
SkScalar A = data.A();
if (fCachedCenterX != centerX || fCachedCenterY != centerY ||
fCachedA != A || fCachedB != B || fCachedC != C) {
- uman.set2f(fCenterUni, SkScalarToFloat(centerX), SkScalarToFloat(centerY));
- uman.set3f(fParamUni, SkScalarToFloat(A), SkScalarToFloat(B), SkScalarToFloat(C));
+ pdman.set2f(fCenterUni, SkScalarToFloat(centerX), SkScalarToFloat(centerY));
+ pdman.set3f(fParamUni, SkScalarToFloat(A), SkScalarToFloat(B), SkScalarToFloat(C));
fCachedCenterX = centerX;
fCachedCenterY = centerY;
}
}
-GrGLEffect::EffectKey GLCircleInside2PtConicalEffect::GenKey(const GrDrawEffect& drawEffect,
- const GrGLCaps&) {
- EffectKey key = GenBaseGradientKey(drawEffect);
- return key;
+void GLCircleInside2PtConicalEffect::GenKey(const GrProcessor& processor,
+ const GrGLCaps&, GrProcessorKeyBuilder* b) {
+ b->add32(GenBaseGradientKey(processor));
}
//////////////////////////////////////////////////////////////////////////////
class CircleOutside2PtConicalEffect : public GrGradientEffect {
public:
- static GrEffectRef* Create(GrContext* ctx,
- const SkTwoPointConicalGradient& shader,
- const SkMatrix& matrix,
- SkShader::TileMode tm,
- const CircleConicalInfo& info) {
- AutoEffectUnref effect(SkNEW_ARGS(CircleOutside2PtConicalEffect, (ctx, shader, matrix, tm, info)));
- return CreateEffectRef(effect);
+ static GrFragmentProcessor* Create(GrContext* ctx,
+ const SkTwoPointConicalGradient& shader,
+ const SkMatrix& matrix,
+ SkShader::TileMode tm,
+ const CircleConicalInfo& info) {
+ return SkNEW_ARGS(CircleOutside2PtConicalEffect, (ctx, shader, matrix, tm, info));
}
virtual ~CircleOutside2PtConicalEffect() {}
static const char* Name() { return "Two-Point Conical Gradient Outside"; }
- virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE;
+ virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
SkScalar centerX() const { return fInfo.fCenterEnd.fX; }
SkScalar centerY() const { return fInfo.fCenterEnd.fY; }
SkScalar tLimit() const { return fTLimit; }
bool isFlipped() const { return fIsFlipped; }
- typedef GLCircleOutside2PtConicalEffect GLEffect;
+ typedef GLCircleOutside2PtConicalEffect GLProcessor;
private:
- virtual bool onIsEqual(const GrEffect& sBase) const SK_OVERRIDE {
- const CircleOutside2PtConicalEffect& s = CastEffect<CircleOutside2PtConicalEffect>(sBase);
+ virtual bool onIsEqual(const GrFragmentProcessor& sBase) const SK_OVERRIDE {
+ const CircleOutside2PtConicalEffect& s = sBase.cast<CircleOutside2PtConicalEffect>();
return (INHERITED::onIsEqual(sBase) &&
this->fInfo.fCenterEnd == s.fInfo.fCenterEnd &&
this->fInfo.fA == s.fInfo.fA &&
const CircleConicalInfo& info)
: INHERITED(ctx, shader, matrix, tm), fInfo(info) {
if (shader.getStartRadius() != shader.getEndRadius()) {
- fTLimit = SkScalarDiv(shader.getStartRadius(), (shader.getStartRadius() - shader.getEndRadius()));
+ fTLimit = SkScalarDiv(shader.getStartRadius(),
+ (shader.getStartRadius() - shader.getEndRadius()));
} else {
fTLimit = SK_ScalarMin;
}
fIsFlipped = shader.isFlippedGrad();
}
- GR_DECLARE_EFFECT_TEST;
+ GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
const CircleConicalInfo fInfo;
SkScalar fTLimit;
class GLCircleOutside2PtConicalEffect : public GrGLGradientEffect {
public:
- GLCircleOutside2PtConicalEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&);
+ GLCircleOutside2PtConicalEffect(const GrBackendProcessorFactory&, const GrProcessor&);
virtual ~GLCircleOutside2PtConicalEffect() {}
- virtual void emitCode(GrGLShaderBuilder*,
- const GrDrawEffect&,
- EffectKey,
+ virtual void emitCode(GrGLFPBuilder*,
+ const GrFragmentProcessor&,
+ const GrProcessorKey&,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray&) SK_OVERRIDE;
- virtual void setData(const GrGLUniformManager&, const GrDrawEffect&) SK_OVERRIDE;
+ virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
- static EffectKey GenKey(const GrDrawEffect&, const GrGLCaps& caps);
+ static void GenKey(const GrProcessor&, const GrGLCaps& caps, GrProcessorKeyBuilder* b);
protected:
UniformHandle fCenterUni;
};
-const GrBackendEffectFactory& CircleOutside2PtConicalEffect::getFactory() const {
- return GrTBackendEffectFactory<CircleOutside2PtConicalEffect>::getInstance();
+const GrBackendFragmentProcessorFactory& CircleOutside2PtConicalEffect::getFactory() const {
+ return GrTBackendFragmentProcessorFactory<CircleOutside2PtConicalEffect>::getInstance();
}
-GR_DEFINE_EFFECT_TEST(CircleOutside2PtConicalEffect);
+GR_DEFINE_FRAGMENT_PROCESSOR_TEST(CircleOutside2PtConicalEffect);
-GrEffectRef* CircleOutside2PtConicalEffect::TestCreate(SkRandom* random,
- GrContext* context,
- const GrDrawTargetCaps&,
- GrTexture**) {
+/*
+ * All Two point conical gradient test create functions may occasionally create edge case shaders
+ */
+GrFragmentProcessor* CircleOutside2PtConicalEffect::TestCreate(SkRandom* random,
+ GrContext* context,
+ const GrDrawTargetCaps&,
+ GrTexture**) {
SkPoint center1 = {random->nextUScalar1(), random->nextUScalar1()};
SkScalar radius1 = random->nextUScalar1() + 0.0001f; // make sure radius1 != 0
SkPoint center2;
center2.set(random->nextUScalar1(), random->nextUScalar1());
// If the circles share a center than we can't be in the outside case
} while (center1 == center2);
- SkPoint diff = center2 - center1;
- diffLen = diff.length();
- // Below makes sure that circle one is not contained within circle two
- // and have radius2 >= radius to match sorting on cpu side
- radius2 = radius1 + random->nextRangeF(0.f, diffLen);
+ SkPoint diff = center2 - center1;
+ diffLen = diff.length();
+ // Below makes sure that circle one is not contained within circle two
+ // and have radius2 >= radius to match sorting on cpu side
+ radius2 = radius1 + random->nextRangeF(0.f, diffLen);
SkColor colors[kMaxRandomGradientColors];
SkScalar stopsArray[kMaxRandomGradientColors];
colors, stops, colorCount,
tm));
SkPaint paint;
- GrColor grColor;
- GrEffectRef* grEffect;
- shader->asNewEffect(context, paint, NULL, &grColor, &grEffect);
- return grEffect;
+ GrColor paintColor;
+ GrFragmentProcessor* processor;
+ SkAssertResult(shader->asFragmentProcessor(context, paint, NULL, &paintColor, &processor));
+ return processor;
}
-GLCircleOutside2PtConicalEffect::GLCircleOutside2PtConicalEffect(const GrBackendEffectFactory& factory,
- const GrDrawEffect& drawEffect)
+GLCircleOutside2PtConicalEffect::GLCircleOutside2PtConicalEffect(const GrBackendProcessorFactory& factory,
+ const GrProcessor& processor)
: INHERITED(factory)
, fVSVaryingName(NULL)
, fFSVaryingName(NULL)
, fCachedB(SK_ScalarMax)
, fCachedC(SK_ScalarMax)
, fCachedTLimit(SK_ScalarMax) {
- const CircleOutside2PtConicalEffect& data = drawEffect.castEffect<CircleOutside2PtConicalEffect>();
+ const CircleOutside2PtConicalEffect& data = processor.cast<CircleOutside2PtConicalEffect>();
fIsFlipped = data.isFlipped();
}
-void GLCircleOutside2PtConicalEffect::emitCode(GrGLShaderBuilder* builder,
- const GrDrawEffect&,
- EffectKey key,
+void GLCircleOutside2PtConicalEffect::emitCode(GrGLFPBuilder* builder,
+ const GrFragmentProcessor&,
+ const GrProcessorKey& key,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray& coords,
const TextureSamplerArray& samplers) {
- this->emitUniforms(builder, key);
- fCenterUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility,
+ uint32_t baseKey = key.get32(0);
+ this->emitUniforms(builder, baseKey);
+ fCenterUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
kVec2f_GrSLType, "Conical2FSCenter");
- fParamUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility,
+ fParamUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
kVec4f_GrSLType, "Conical2FSParams");
SkString tName("t");
GrGLShaderVar params = builder->getUniformVariable(fParamUni);
// if we have a vec3 from being in perspective, convert it to a vec2 first
- SkString coords2DString = builder->ensureFSCoords2D(coords, 0);
+ GrGLFPFragmentBuilder* fsBuilder = builder->getFragmentShaderBuilder();
+ SkString coords2DString = fsBuilder->ensureFSCoords2D(coords, 0);
const char* coords2D = coords2DString.c_str();
// output will default to transparent black (we simply won't write anything
// else to it if invalid, instead of discarding or returning prematurely)
- builder->fsCodeAppendf("\t%s = vec4(0.0,0.0,0.0,0.0);\n", outputColor);
+ fsBuilder->codeAppendf("\t%s = vec4(0.0,0.0,0.0,0.0);\n", outputColor);
// p = coords2D
// e = center end
// d = dot(e, p) + B
// t = d +/- sqrt(d^2 - A * dot(p, p) + C)
- builder->fsCodeAppendf("\tfloat pDotp = dot(%s, %s);\n", coords2D, coords2D);
- builder->fsCodeAppendf("\tfloat d = dot(%s, %s) + %s.y;\n", coords2D, center.c_str(), params.c_str());
- builder->fsCodeAppendf("\tfloat deter = d * d - %s.x * pDotp + %s.z;\n", params.c_str(), params.c_str());
+ fsBuilder->codeAppendf("\tfloat pDotp = dot(%s, %s);\n", coords2D, coords2D);
+ fsBuilder->codeAppendf("\tfloat d = dot(%s, %s) + %s.y;\n", coords2D, center.c_str(),
+ params.c_str());
+ fsBuilder->codeAppendf("\tfloat deter = d * d - %s.x * pDotp + %s.z;\n", params.c_str(),
+ params.c_str());
// Must check to see if we flipped the circle order (to make sure start radius < end radius)
// If so we must also flip sign on sqrt
if (!fIsFlipped) {
- builder->fsCodeAppendf("\tfloat %s = d + sqrt(deter);\n", tName.c_str());
+ fsBuilder->codeAppendf("\tfloat %s = d + sqrt(deter);\n", tName.c_str());
} else {
- builder->fsCodeAppendf("\tfloat %s = d - sqrt(deter);\n", tName.c_str());
+ fsBuilder->codeAppendf("\tfloat %s = d - sqrt(deter);\n", tName.c_str());
}
- builder->fsCodeAppendf("\tif (%s >= %s.w && deter >= 0.0) {\n", tName.c_str(), params.c_str());
- builder->fsCodeAppend("\t\t");
- this->emitColor(builder, tName.c_str(), key, outputColor, inputColor, samplers);
- builder->fsCodeAppend("\t}\n");
+ fsBuilder->codeAppendf("\tif (%s >= %s.w && deter >= 0.0) {\n", tName.c_str(), params.c_str());
+ fsBuilder->codeAppend("\t\t");
+ this->emitColor(builder, tName.c_str(), baseKey, outputColor, inputColor, samplers);
+ fsBuilder->codeAppend("\t}\n");
}
-void GLCircleOutside2PtConicalEffect::setData(const GrGLUniformManager& uman,
- const GrDrawEffect& drawEffect) {
- INHERITED::setData(uman, drawEffect);
- const CircleOutside2PtConicalEffect& data = drawEffect.castEffect<CircleOutside2PtConicalEffect>();
+void GLCircleOutside2PtConicalEffect::setData(const GrGLProgramDataManager& pdman,
+ const GrProcessor& processor) {
+ INHERITED::setData(pdman, processor);
+ const CircleOutside2PtConicalEffect& data = processor.cast<CircleOutside2PtConicalEffect>();
SkASSERT(data.isFlipped() == fIsFlipped);
SkScalar centerX = data.centerX();
SkScalar centerY = data.centerY();
if (fCachedCenterX != centerX || fCachedCenterY != centerY ||
fCachedA != A || fCachedB != B || fCachedC != C || fCachedTLimit != tLimit) {
- uman.set2f(fCenterUni, SkScalarToFloat(centerX), SkScalarToFloat(centerY));
- uman.set4f(fParamUni, SkScalarToFloat(A), SkScalarToFloat(B), SkScalarToFloat(C),
+ pdman.set2f(fCenterUni, SkScalarToFloat(centerX), SkScalarToFloat(centerY));
+ pdman.set4f(fParamUni, SkScalarToFloat(A), SkScalarToFloat(B), SkScalarToFloat(C),
SkScalarToFloat(tLimit));
fCachedCenterX = centerX;
}
}
-GrGLEffect::EffectKey GLCircleOutside2PtConicalEffect::GenKey(const GrDrawEffect& drawEffect,
- const GrGLCaps&) {
- enum {
- kIsFlipped = 1 << kBaseKeyBitCnt,
- };
-
- EffectKey key = GenBaseGradientKey(drawEffect);
-
- if (drawEffect.castEffect<CircleOutside2PtConicalEffect>().isFlipped()) {
- key |= kIsFlipped;
- }
- return key;
+void GLCircleOutside2PtConicalEffect::GenKey(const GrProcessor& processor,
+ const GrGLCaps&, GrProcessorKeyBuilder* b) {
+ uint32_t* key = b->add32n(2);
+ key[0] = GenBaseGradientKey(processor);
+ key[1] = processor.cast<CircleOutside2PtConicalEffect>().isFlipped();
}
//////////////////////////////////////////////////////////////////////////////
-GrEffectRef* Gr2PtConicalGradientEffect::Create(GrContext* ctx,
- const SkTwoPointConicalGradient& shader,
- SkShader::TileMode tm,
- const SkMatrix* localMatrix) {
+GrFragmentProcessor* Gr2PtConicalGradientEffect::Create(GrContext* ctx,
+ const SkTwoPointConicalGradient& shader,
+ SkShader::TileMode tm,
+ const SkMatrix* localMatrix) {
SkMatrix matrix;
if (!shader.getLocalMatrix().invert(&matrix)) {
return NULL;
projects / platform / framework / web / crosswalk.git / blobdiff