*/
#include "GrDistanceFieldTextureEffect.h"
-#include "gl/GrGLEffect.h"
-#include "gl/GrGLShaderBuilder.h"
+#include "gl/builders/GrGLFullProgramBuilder.h"
+#include "gl/GrGLProcessor.h"
#include "gl/GrGLSL.h"
#include "gl/GrGLTexture.h"
-#include "gl/GrGLVertexEffect.h"
-#include "GrTBackendEffectFactory.h"
+#include "gl/GrGLGeometryProcessor.h"
+#include "GrTBackendProcessorFactory.h"
#include "GrTexture.h"
#include "SkDistanceFieldGen.h"
// Assuming a radius of the diagonal of the fragment, hence a factor of sqrt(2)/2
#define SK_DistanceFieldAAFactor "0.7071"
-class GrGLDistanceFieldTextureEffect : public GrGLVertexEffect {
+class GrGLDistanceFieldTextureEffect : public GrGLGeometryProcessor {
public:
- GrGLDistanceFieldTextureEffect(const GrBackendEffectFactory& factory,
- const GrDrawEffect& drawEffect)
+ GrGLDistanceFieldTextureEffect(const GrBackendProcessorFactory& factory,
+ const GrProcessor&)
: INHERITED (factory)
- , fTextureSize(SkISize::Make(-1,-1)) {}
+ , fTextureSize(SkISize::Make(-1,-1))
+#ifdef SK_GAMMA_APPLY_TO_A8
+ , fLuminance(-1.0f)
+#endif
+ {}
- virtual void emitCode(GrGLFullShaderBuilder* builder,
- const GrDrawEffect& drawEffect,
- const GrEffectKey& key,
+ virtual void emitCode(GrGLFullProgramBuilder* builder,
+ const GrGeometryProcessor& geometryProcessor,
+ const GrProcessorKey& key,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray& samplers) SK_OVERRIDE {
- SkASSERT(1 == drawEffect.castEffect<GrDistanceFieldTextureEffect>().numVertexAttribs());
-
- SkAssertResult(builder->enableFeature(GrGLShaderBuilder::kStandardDerivatives_GLSLFeature));
const GrDistanceFieldTextureEffect& dfTexEffect =
- drawEffect.castEffect<GrDistanceFieldTextureEffect>();
+ geometryProcessor.cast<GrDistanceFieldTextureEffect>();
+ SkASSERT(1 == dfTexEffect.getVertexAttribs().count());
+
+ GrGLProcessorFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder();
+ SkAssertResult(fsBuilder->enableFeature(
+ GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature));
SkString fsCoordName;
const char* vsCoordName;
builder->addVarying(kVec2f_GrSLType, "textureCoords", &vsCoordName, &fsCoordNamePtr);
fsCoordName = fsCoordNamePtr;
- const char* attrName0 =
- builder->getEffectAttributeName(drawEffect.getVertexAttribIndices()[0])->c_str();
- builder->vsCodeAppendf("\t%s = %s;\n", vsCoordName, attrName0);
+ GrGLVertexShaderBuilder* vsBuilder = builder->getVertexShaderBuilder();
+ vsBuilder->codeAppendf("\t%s = %s;\n", vsCoordName, dfTexEffect.inTextureCoords().c_str());
const char* textureSizeUniName = NULL;
- fTextureSizeUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility,
+ fTextureSizeUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
kVec2f_GrSLType, "TextureSize",
&textureSizeUniName);
- builder->fsCodeAppend("\tvec4 texColor = ");
- builder->fsAppendTextureLookup(samplers[0],
+ fsBuilder->codeAppend("\tvec4 texColor = ");
+ fsBuilder->appendTextureLookup(samplers[0],
fsCoordName.c_str(),
kVec2f_GrSLType);
- builder->fsCodeAppend(";\n");
- builder->fsCodeAppend("\tfloat distance = "
+ fsBuilder->codeAppend(";\n");
+ fsBuilder->codeAppend("\tfloat distance = "
SK_DistanceFieldMultiplier "*(texColor.r - " SK_DistanceFieldThreshold ")"
"+ " SK_DistanceFieldNonLCDFactor ";\n");
// we adjust for the effect of the transformation on the distance by using
// the length of the gradient of the texture coordinates. We use st coordinates
// to ensure we're mapping 1:1 from texel space to pixel space.
- builder->fsCodeAppendf("\tvec2 uv = %s;\n", fsCoordName.c_str());
- builder->fsCodeAppendf("\tvec2 st = uv*%s;\n", textureSizeUniName);
- builder->fsCodeAppend("\tfloat afwidth;\n");
+ fsBuilder->codeAppendf("\tvec2 uv = %s;\n", fsCoordName.c_str());
+ fsBuilder->codeAppendf("\tvec2 st = uv*%s;\n", textureSizeUniName);
+ fsBuilder->codeAppend("\tfloat afwidth;\n");
if (dfTexEffect.getFlags() & kSimilarity_DistanceFieldEffectFlag) {
// this gives us a smooth step across approximately one fragment
- builder->fsCodeAppend("\tafwidth = " SK_DistanceFieldAAFactor "*dFdx(st.x);\n");
+ fsBuilder->codeAppend("\tafwidth = " SK_DistanceFieldAAFactor "*dFdx(st.x);\n");
} else {
- builder->fsCodeAppend("\tvec2 Jdx = dFdx(st);\n");
- builder->fsCodeAppend("\tvec2 Jdy = dFdy(st);\n");
+ fsBuilder->codeAppend("\tvec2 Jdx = dFdx(st);\n");
+ fsBuilder->codeAppend("\tvec2 Jdy = dFdy(st);\n");
- builder->fsCodeAppend("\tvec2 uv_grad;\n");
+ fsBuilder->codeAppend("\tvec2 uv_grad;\n");
if (builder->ctxInfo().caps()->dropsTileOnZeroDivide()) {
// this is to compensate for the Adreno, which likes to drop tiles on division by 0
- builder->fsCodeAppend("\tfloat uv_len2 = dot(uv, uv);\n");
- builder->fsCodeAppend("\tif (uv_len2 < 0.0001) {\n");
- builder->fsCodeAppend("\t\tuv_grad = vec2(0.7071, 0.7071);\n");
- builder->fsCodeAppend("\t} else {\n");
- builder->fsCodeAppend("\t\tuv_grad = uv*inversesqrt(uv_len2);\n");
- builder->fsCodeAppend("\t}\n");
+ fsBuilder->codeAppend("\tfloat uv_len2 = dot(uv, uv);\n");
+ fsBuilder->codeAppend("\tif (uv_len2 < 0.0001) {\n");
+ fsBuilder->codeAppend("\t\tuv_grad = vec2(0.7071, 0.7071);\n");
+ fsBuilder->codeAppend("\t} else {\n");
+ fsBuilder->codeAppend("\t\tuv_grad = uv*inversesqrt(uv_len2);\n");
+ fsBuilder->codeAppend("\t}\n");
} else {
- builder->fsCodeAppend("\tuv_grad = normalize(uv);\n");
+ fsBuilder->codeAppend("\tuv_grad = normalize(uv);\n");
}
- builder->fsCodeAppend("\tvec2 grad = vec2(uv_grad.x*Jdx.x + uv_grad.y*Jdy.x,\n");
- builder->fsCodeAppend("\t uv_grad.x*Jdx.y + uv_grad.y*Jdy.y);\n");
+ fsBuilder->codeAppend("\tvec2 grad = vec2(uv_grad.x*Jdx.x + uv_grad.y*Jdy.x,\n");
+ fsBuilder->codeAppend("\t uv_grad.x*Jdx.y + uv_grad.y*Jdy.y);\n");
// this gives us a smooth step across approximately one fragment
- builder->fsCodeAppend("\tafwidth = " SK_DistanceFieldAAFactor "*length(grad);\n");
+ fsBuilder->codeAppend("\tafwidth = " SK_DistanceFieldAAFactor "*length(grad);\n");
}
- builder->fsCodeAppend("\tfloat val = smoothstep(-afwidth, afwidth, distance);\n");
+ fsBuilder->codeAppend("\tfloat val = smoothstep(-afwidth, afwidth, distance);\n");
#ifdef SK_GAMMA_APPLY_TO_A8
// adjust based on gamma
const char* luminanceUniName = NULL;
// width, height, 1/(3*width)
- fLuminanceUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility,
+ fLuminanceUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
kFloat_GrSLType, "Luminance",
&luminanceUniName);
- builder->fsCodeAppendf("\tuv = vec2(val, %s);\n", luminanceUniName);
- builder->fsCodeAppend("\tvec4 gammaColor = ");
- builder->fsAppendTextureLookup(samplers[1], "uv", kVec2f_GrSLType);
- builder->fsCodeAppend(";\n");
- builder->fsCodeAppend("\tval = gammaColor.r;\n");
+ fsBuilder->codeAppendf("\tuv = vec2(val, %s);\n", luminanceUniName);
+ fsBuilder->codeAppend("\tvec4 gammaColor = ");
+ fsBuilder->appendTextureLookup(samplers[1], "uv", kVec2f_GrSLType);
+ fsBuilder->codeAppend(";\n");
+ fsBuilder->codeAppend("\tval = gammaColor.r;\n");
#endif
- builder->fsCodeAppendf("\t%s = %s;\n", outputColor,
+ fsBuilder->codeAppendf("\t%s = %s;\n", outputColor,
(GrGLSLExpr4(inputColor) * GrGLSLExpr1("val")).c_str());
}
virtual void setData(const GrGLProgramDataManager& pdman,
- const GrDrawEffect& drawEffect) SK_OVERRIDE {
+ const GrProcessor& effect) SK_OVERRIDE {
SkASSERT(fTextureSizeUni.isValid());
- GrTexture* texture = drawEffect.effect()->texture(0);
+ GrTexture* texture = effect.texture(0);
if (texture->width() != fTextureSize.width() ||
texture->height() != fTextureSize.height()) {
fTextureSize = SkISize::Make(texture->width(), texture->height());
}
#ifdef SK_GAMMA_APPLY_TO_A8
const GrDistanceFieldTextureEffect& dfTexEffect =
- drawEffect.castEffect<GrDistanceFieldTextureEffect>();
+ effect.cast<GrDistanceFieldTextureEffect>();
float luminance = dfTexEffect.getLuminance();
if (luminance != fLuminance) {
pdman.set1f(fLuminanceUni, luminance);
#endif
}
- static inline void GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&,
- GrEffectKeyBuilder* b) {
+ static inline void GenKey(const GrProcessor& processor, const GrGLCaps&,
+ GrProcessorKeyBuilder* b) {
const GrDistanceFieldTextureEffect& dfTexEffect =
- drawEffect.castEffect<GrDistanceFieldTextureEffect>();
+ processor.cast<GrDistanceFieldTextureEffect>();
b->add32(dfTexEffect.getFlags());
}
GrGLProgramDataManager::UniformHandle fLuminanceUni;
float fLuminance;
- typedef GrGLVertexEffect INHERITED;
+ typedef GrGLGeometryProcessor INHERITED;
};
///////////////////////////////////////////////////////////////////////////////
, fGammaTextureAccess(gamma, gammaParams)
, fLuminance(luminance)
#endif
- , fFlags(flags & kNonLCD_DistanceFieldEffectMask) {
+ , fFlags(flags & kNonLCD_DistanceFieldEffectMask)
+ , fInTextureCoords(this->addVertexAttrib(GrShaderVar("inTextureCoords",
+ kVec2f_GrSLType,
+ GrShaderVar::kAttribute_TypeModifier))) {
SkASSERT(!(flags & ~kNonLCD_DistanceFieldEffectMask));
this->addTextureAccess(&fTextureAccess);
#ifdef SK_GAMMA_APPLY_TO_A8
this->addTextureAccess(&fGammaTextureAccess);
#endif
- this->addVertexAttrib(kVec2f_GrSLType);
}
-bool GrDistanceFieldTextureEffect::onIsEqual(const GrEffect& other) const {
- const GrDistanceFieldTextureEffect& cte = CastEffect<GrDistanceFieldTextureEffect>(other);
+bool GrDistanceFieldTextureEffect::onIsEqual(const GrProcessor& other) const {
+ const GrDistanceFieldTextureEffect& cte = other.cast<GrDistanceFieldTextureEffect>();
return fTextureAccess == cte.fTextureAccess &&
#ifdef SK_GAMMA_APPLY_TO_A8
fGammaTextureAccess == cte.fGammaTextureAccess &&
}
}
-const GrBackendEffectFactory& GrDistanceFieldTextureEffect::getFactory() const {
- return GrTBackendEffectFactory<GrDistanceFieldTextureEffect>::getInstance();
+const GrBackendGeometryProcessorFactory& GrDistanceFieldTextureEffect::getFactory() const {
+ return GrTBackendGeometryProcessorFactory<GrDistanceFieldTextureEffect>::getInstance();
}
///////////////////////////////////////////////////////////////////////////////
-GR_DEFINE_EFFECT_TEST(GrDistanceFieldTextureEffect);
+GR_DEFINE_GEOMETRY_PROCESSOR_TEST(GrDistanceFieldTextureEffect);
-GrEffect* GrDistanceFieldTextureEffect::TestCreate(SkRandom* random,
- GrContext*,
- const GrDrawTargetCaps&,
- GrTexture* textures[]) {
- int texIdx = random->nextBool() ? GrEffectUnitTest::kSkiaPMTextureIdx :
- GrEffectUnitTest::kAlphaTextureIdx;
+GrGeometryProcessor* GrDistanceFieldTextureEffect::TestCreate(SkRandom* random,
+ GrContext*,
+ const GrDrawTargetCaps&,
+ GrTexture* textures[]) {
+ int texIdx = random->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx :
+ GrProcessorUnitTest::kAlphaTextureIdx;
#ifdef SK_GAMMA_APPLY_TO_A8
- int texIdx2 = random->nextBool() ? GrEffectUnitTest::kSkiaPMTextureIdx :
- GrEffectUnitTest::kAlphaTextureIdx;
+ int texIdx2 = random->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx :
+ GrProcessorUnitTest::kAlphaTextureIdx;
#endif
static const SkShader::TileMode kTileModes[] = {
SkShader::kClamp_TileMode,
///////////////////////////////////////////////////////////////////////////////
-class GrGLDistanceFieldLCDTextureEffect : public GrGLVertexEffect {
+class GrGLDistanceFieldLCDTextureEffect : public GrGLGeometryProcessor {
public:
- GrGLDistanceFieldLCDTextureEffect(const GrBackendEffectFactory& factory,
- const GrDrawEffect& drawEffect)
+ GrGLDistanceFieldLCDTextureEffect(const GrBackendProcessorFactory& factory,
+ const GrProcessor&)
: INHERITED (factory)
- , fTextureSize(SkISize::Make(-1,-1)) {}
+ , fTextureSize(SkISize::Make(-1,-1))
+ , fTextColor(GrColor_ILLEGAL) {}
- virtual void emitCode(GrGLFullShaderBuilder* builder,
- const GrDrawEffect& drawEffect,
- const GrEffectKey& key,
+ virtual void emitCode(GrGLFullProgramBuilder* builder,
+ const GrGeometryProcessor& geometryProcessor,
+ const GrProcessorKey& key,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray& samplers) SK_OVERRIDE {
- SkASSERT(1 == drawEffect.castEffect<GrDistanceFieldLCDTextureEffect>().numVertexAttribs());
-
- SkAssertResult(builder->enableFeature(GrGLShaderBuilder::kStandardDerivatives_GLSLFeature));
const GrDistanceFieldLCDTextureEffect& dfTexEffect =
- drawEffect.castEffect<GrDistanceFieldLCDTextureEffect>();
+ geometryProcessor.cast<GrDistanceFieldLCDTextureEffect>();
+ SkASSERT(1 == dfTexEffect.getVertexAttribs().count());
SkString fsCoordName;
const char* vsCoordName;
builder->addVarying(kVec2f_GrSLType, "textureCoords", &vsCoordName, &fsCoordNamePtr);
fsCoordName = fsCoordNamePtr;
- const char* attrName0 =
- builder->getEffectAttributeName(drawEffect.getVertexAttribIndices()[0])->c_str();
- builder->vsCodeAppendf("\t%s = %s;\n", vsCoordName, attrName0);
+ GrGLVertexShaderBuilder* vsBuilder = builder->getVertexShaderBuilder();
+ vsBuilder->codeAppendf("\t%s = %s;\n", vsCoordName, dfTexEffect.inTextureCoords().c_str());
const char* textureSizeUniName = NULL;
// width, height, 1/(3*width)
- fTextureSizeUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility,
+ fTextureSizeUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
kVec3f_GrSLType, "TextureSize",
&textureSizeUniName);
+ GrGLProcessorFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder();
+
+ SkAssertResult(fsBuilder->enableFeature(
+ GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature));
+
// create LCD offset adjusted by inverse of transform
- builder->fsCodeAppendf("\tvec2 uv = %s;\n", fsCoordName.c_str());
- builder->fsCodeAppendf("\tvec2 st = uv*%s.xy;\n", textureSizeUniName);
+ fsBuilder->codeAppendf("\tvec2 uv = %s;\n", fsCoordName.c_str());
+ fsBuilder->codeAppendf("\tvec2 st = uv*%s.xy;\n", textureSizeUniName);
bool isUniformScale = !!(dfTexEffect.getFlags() & kUniformScale_DistanceFieldEffectMask);
if (isUniformScale) {
- builder->fsCodeAppend("\tfloat dx = dFdx(st.x);\n");
- builder->fsCodeAppendf("\tvec2 offset = vec2(dx*%s.z, 0.0);\n", textureSizeUniName);
+ fsBuilder->codeAppend("\tfloat dx = dFdx(st.x);\n");
+ fsBuilder->codeAppendf("\tvec2 offset = vec2(dx*%s.z, 0.0);\n", textureSizeUniName);
} else {
- builder->fsCodeAppend("\tvec2 Jdx = dFdx(st);\n");
- builder->fsCodeAppend("\tvec2 Jdy = dFdy(st);\n");
- builder->fsCodeAppendf("\tvec2 offset = %s.z*Jdx;\n", textureSizeUniName);
+ fsBuilder->codeAppend("\tvec2 Jdx = dFdx(st);\n");
+ fsBuilder->codeAppend("\tvec2 Jdy = dFdy(st);\n");
+ fsBuilder->codeAppendf("\tvec2 offset = %s.z*Jdx;\n", textureSizeUniName);
}
// green is distance to uv center
- builder->fsCodeAppend("\tvec4 texColor = ");
- builder->fsAppendTextureLookup(samplers[0], "uv", kVec2f_GrSLType);
- builder->fsCodeAppend(";\n");
- builder->fsCodeAppend("\tvec3 distance;\n");
- builder->fsCodeAppend("\tdistance.y = texColor.r;\n");
+ fsBuilder->codeAppend("\tvec4 texColor = ");
+ fsBuilder->appendTextureLookup(samplers[0], "uv", kVec2f_GrSLType);
+ fsBuilder->codeAppend(";\n");
+ fsBuilder->codeAppend("\tvec3 distance;\n");
+ fsBuilder->codeAppend("\tdistance.y = texColor.r;\n");
// red is distance to left offset
- builder->fsCodeAppend("\tvec2 uv_adjusted = uv - offset;\n");
- builder->fsCodeAppend("\ttexColor = ");
- builder->fsAppendTextureLookup(samplers[0], "uv_adjusted", kVec2f_GrSLType);
- builder->fsCodeAppend(";\n");
- builder->fsCodeAppend("\tdistance.x = texColor.r;\n");
+ fsBuilder->codeAppend("\tvec2 uv_adjusted = uv - offset;\n");
+ fsBuilder->codeAppend("\ttexColor = ");
+ fsBuilder->appendTextureLookup(samplers[0], "uv_adjusted", kVec2f_GrSLType);
+ fsBuilder->codeAppend(";\n");
+ fsBuilder->codeAppend("\tdistance.x = texColor.r;\n");
// blue is distance to right offset
- builder->fsCodeAppend("\tuv_adjusted = uv + offset;\n");
- builder->fsCodeAppend("\ttexColor = ");
- builder->fsAppendTextureLookup(samplers[0], "uv_adjusted", kVec2f_GrSLType);
- builder->fsCodeAppend(";\n");
- builder->fsCodeAppend("\tdistance.z = texColor.r;\n");
+ fsBuilder->codeAppend("\tuv_adjusted = uv + offset;\n");
+ fsBuilder->codeAppend("\ttexColor = ");
+ fsBuilder->appendTextureLookup(samplers[0], "uv_adjusted", kVec2f_GrSLType);
+ fsBuilder->codeAppend(";\n");
+ fsBuilder->codeAppend("\tdistance.z = texColor.r;\n");
- builder->fsCodeAppend("\tdistance = "
+ fsBuilder->codeAppend("\tdistance = "
"vec3(" SK_DistanceFieldMultiplier ")*(distance - vec3(" SK_DistanceFieldThreshold"))"
"+ vec3(" SK_DistanceFieldLCDFactor ");\n");
// for each color component. However, this is only important when using perspective
// transformations, and even then using a single factor seems like a reasonable
// trade-off between quality and speed.
- builder->fsCodeAppend("\tfloat afwidth;\n");
+ fsBuilder->codeAppend("\tfloat afwidth;\n");
if (isUniformScale) {
// this gives us a smooth step across approximately one fragment
- builder->fsCodeAppend("\tafwidth = " SK_DistanceFieldAAFactor "*dx;\n");
+ fsBuilder->codeAppend("\tafwidth = " SK_DistanceFieldAAFactor "*dx;\n");
} else {
- builder->fsCodeAppend("\tvec2 uv_grad;\n");
+ fsBuilder->codeAppend("\tvec2 uv_grad;\n");
if (builder->ctxInfo().caps()->dropsTileOnZeroDivide()) {
// this is to compensate for the Adreno, which likes to drop tiles on division by 0
- builder->fsCodeAppend("\tfloat uv_len2 = dot(uv, uv);\n");
- builder->fsCodeAppend("\tif (uv_len2 < 0.0001) {\n");
- builder->fsCodeAppend("\t\tuv_grad = vec2(0.7071, 0.7071);\n");
- builder->fsCodeAppend("\t} else {\n");
- builder->fsCodeAppend("\t\tuv_grad = uv*inversesqrt(uv_len2);\n");
- builder->fsCodeAppend("\t}\n");
+ fsBuilder->codeAppend("\tfloat uv_len2 = dot(uv, uv);\n");
+ fsBuilder->codeAppend("\tif (uv_len2 < 0.0001) {\n");
+ fsBuilder->codeAppend("\t\tuv_grad = vec2(0.7071, 0.7071);\n");
+ fsBuilder->codeAppend("\t} else {\n");
+ fsBuilder->codeAppend("\t\tuv_grad = uv*inversesqrt(uv_len2);\n");
+ fsBuilder->codeAppend("\t}\n");
} else {
- builder->fsCodeAppend("\tuv_grad = normalize(uv);\n");
+ fsBuilder->codeAppend("\tuv_grad = normalize(uv);\n");
}
- builder->fsCodeAppend("\tvec2 grad = vec2(uv_grad.x*Jdx.x + uv_grad.y*Jdy.x,\n");
- builder->fsCodeAppend("\t uv_grad.x*Jdx.y + uv_grad.y*Jdy.y);\n");
+ fsBuilder->codeAppend("\tvec2 grad = vec2(uv_grad.x*Jdx.x + uv_grad.y*Jdy.x,\n");
+ fsBuilder->codeAppend("\t uv_grad.x*Jdx.y + uv_grad.y*Jdy.y);\n");
// this gives us a smooth step across approximately one fragment
- builder->fsCodeAppend("\tafwidth = " SK_DistanceFieldAAFactor "*length(grad);\n");
+ fsBuilder->codeAppend("\tafwidth = " SK_DistanceFieldAAFactor "*length(grad);\n");
}
- builder->fsCodeAppend("\tvec4 val = vec4(smoothstep(vec3(-afwidth), vec3(afwidth), distance), 1.0);\n");
+ fsBuilder->codeAppend("\tvec4 val = vec4(smoothstep(vec3(-afwidth), vec3(afwidth), distance), 1.0);\n");
// adjust based on gamma
const char* textColorUniName = NULL;
// width, height, 1/(3*width)
- fTextColorUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility,
+ fTextColorUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
kVec3f_GrSLType, "TextColor",
&textColorUniName);
- builder->fsCodeAppendf("\tuv = vec2(val.x, %s.x);\n", textColorUniName);
- builder->fsCodeAppend("\tvec4 gammaColor = ");
- builder->fsAppendTextureLookup(samplers[1], "uv", kVec2f_GrSLType);
- builder->fsCodeAppend(";\n");
- builder->fsCodeAppend("\tval.x = gammaColor.r;\n");
-
- builder->fsCodeAppendf("\tuv = vec2(val.y, %s.y);\n", textColorUniName);
- builder->fsCodeAppend("\tgammaColor = ");
- builder->fsAppendTextureLookup(samplers[1], "uv", kVec2f_GrSLType);
- builder->fsCodeAppend(";\n");
- builder->fsCodeAppend("\tval.y = gammaColor.r;\n");
-
- builder->fsCodeAppendf("\tuv = vec2(val.z, %s.z);\n", textColorUniName);
- builder->fsCodeAppend("\tgammaColor = ");
- builder->fsAppendTextureLookup(samplers[1], "uv", kVec2f_GrSLType);
- builder->fsCodeAppend(";\n");
- builder->fsCodeAppend("\tval.z = gammaColor.r;\n");
-
- builder->fsCodeAppendf("\t%s = %s;\n", outputColor,
+ fsBuilder->codeAppendf("\tuv = vec2(val.x, %s.x);\n", textColorUniName);
+ fsBuilder->codeAppend("\tvec4 gammaColor = ");
+ fsBuilder->appendTextureLookup(samplers[1], "uv", kVec2f_GrSLType);
+ fsBuilder->codeAppend(";\n");
+ fsBuilder->codeAppend("\tval.x = gammaColor.r;\n");
+
+ fsBuilder->codeAppendf("\tuv = vec2(val.y, %s.y);\n", textColorUniName);
+ fsBuilder->codeAppend("\tgammaColor = ");
+ fsBuilder->appendTextureLookup(samplers[1], "uv", kVec2f_GrSLType);
+ fsBuilder->codeAppend(";\n");
+ fsBuilder->codeAppend("\tval.y = gammaColor.r;\n");
+
+ fsBuilder->codeAppendf("\tuv = vec2(val.z, %s.z);\n", textColorUniName);
+ fsBuilder->codeAppend("\tgammaColor = ");
+ fsBuilder->appendTextureLookup(samplers[1], "uv", kVec2f_GrSLType);
+ fsBuilder->codeAppend(";\n");
+ fsBuilder->codeAppend("\tval.z = gammaColor.r;\n");
+
+ fsBuilder->codeAppendf("\t%s = %s;\n", outputColor,
(GrGLSLExpr4(inputColor) * GrGLSLExpr4("val")).c_str());
}
virtual void setData(const GrGLProgramDataManager& pdman,
- const GrDrawEffect& drawEffect) SK_OVERRIDE {
+ const GrProcessor& processor) SK_OVERRIDE {
SkASSERT(fTextureSizeUni.isValid());
SkASSERT(fTextColorUni.isValid());
const GrDistanceFieldLCDTextureEffect& dfTexEffect =
- drawEffect.castEffect<GrDistanceFieldLCDTextureEffect>();
- GrTexture* texture = drawEffect.effect()->texture(0);
+ processor.cast<GrDistanceFieldLCDTextureEffect>();
+ GrTexture* texture = processor.texture(0);
if (texture->width() != fTextureSize.width() ||
texture->height() != fTextureSize.height()) {
fTextureSize = SkISize::Make(texture->width(), texture->height());
}
}
- static inline void GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&,
- GrEffectKeyBuilder* b) {
+ static inline void GenKey(const GrProcessor& processor, const GrGLCaps&,
+ GrProcessorKeyBuilder* b) {
const GrDistanceFieldLCDTextureEffect& dfTexEffect =
- drawEffect.castEffect<GrDistanceFieldLCDTextureEffect>();
+ processor.cast<GrDistanceFieldLCDTextureEffect>();
b->add32(dfTexEffect.getFlags());
}
GrGLProgramDataManager::UniformHandle fTextColorUni;
SkColor fTextColor;
- typedef GrGLVertexEffect INHERITED;
+ typedef GrGLGeometryProcessor INHERITED;
};
///////////////////////////////////////////////////////////////////////////////
: fTextureAccess(texture, params)
, fGammaTextureAccess(gamma, gParams)
, fTextColor(textColor)
- , fFlags(flags & kLCD_DistanceFieldEffectMask) {
+ , fFlags(flags & kLCD_DistanceFieldEffectMask)
+ , fInTextureCoords(this->addVertexAttrib(GrShaderVar("inTextureCoords",
+ kVec2f_GrSLType,
+ GrShaderVar::kAttribute_TypeModifier))) {
SkASSERT(!(flags & ~kLCD_DistanceFieldEffectMask) && (flags & kUseLCD_DistanceFieldEffectFlag));
this->addTextureAccess(&fTextureAccess);
this->addTextureAccess(&fGammaTextureAccess);
- this->addVertexAttrib(kVec2f_GrSLType);
}
-bool GrDistanceFieldLCDTextureEffect::onIsEqual(const GrEffect& other) const {
- const GrDistanceFieldLCDTextureEffect& cte =
- CastEffect<GrDistanceFieldLCDTextureEffect>(other);
+bool GrDistanceFieldLCDTextureEffect::onIsEqual(const GrProcessor& other) const {
+ const GrDistanceFieldLCDTextureEffect& cte = other.cast<GrDistanceFieldLCDTextureEffect>();
return (fTextureAccess == cte.fTextureAccess &&
fGammaTextureAccess == cte.fGammaTextureAccess &&
fTextColor == cte.fTextColor &&
}
}
-const GrBackendEffectFactory& GrDistanceFieldLCDTextureEffect::getFactory() const {
- return GrTBackendEffectFactory<GrDistanceFieldLCDTextureEffect>::getInstance();
+const GrBackendGeometryProcessorFactory& GrDistanceFieldLCDTextureEffect::getFactory() const {
+ return GrTBackendGeometryProcessorFactory<GrDistanceFieldLCDTextureEffect>::getInstance();
}
///////////////////////////////////////////////////////////////////////////////
-GR_DEFINE_EFFECT_TEST(GrDistanceFieldLCDTextureEffect);
+GR_DEFINE_GEOMETRY_PROCESSOR_TEST(GrDistanceFieldLCDTextureEffect);
-GrEffect* GrDistanceFieldLCDTextureEffect::TestCreate(SkRandom* random,
- GrContext*,
- const GrDrawTargetCaps&,
- GrTexture* textures[]) {
- int texIdx = random->nextBool() ? GrEffectUnitTest::kSkiaPMTextureIdx :
- GrEffectUnitTest::kAlphaTextureIdx;
- int texIdx2 = random->nextBool() ? GrEffectUnitTest::kSkiaPMTextureIdx :
- GrEffectUnitTest::kAlphaTextureIdx;
+GrGeometryProcessor* GrDistanceFieldLCDTextureEffect::TestCreate(SkRandom* random,
+ GrContext*,
+ const GrDrawTargetCaps&,
+ GrTexture* textures[]) {
+ int texIdx = random->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx :
+ GrProcessorUnitTest::kAlphaTextureIdx;
+ int texIdx2 = random->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx :
+ GrProcessorUnitTest::kAlphaTextureIdx;
static const SkShader::TileMode kTileModes[] = {
SkShader::kClamp_TileMode,
SkShader::kRepeat_TileMode,
projects / platform / framework / web / crosswalk.git / blobdiff