Switch atlas clients over to using absolute texture coordinates (take 2)
This is a prerequisite for being able to resize the atlas with impunity.
Change-Id: Iccc9c7ced43f38a7d8483a7bd12a458d59a3453a
Reviewed-on: https://skia-review.googlesource.com/38362
Reviewed-by: Jim Van Verth <jvanverth@google.com>
Commit-Queue: Robert Phillips <robertphillips@google.com>
diff --git a/src/gpu/GrShaderVar.cpp b/src/gpu/GrShaderVar.cpp
index e6d774c..09e98f8 100644
--- a/src/gpu/GrShaderVar.cpp
+++ b/src/gpu/GrShaderVar.cpp
@@ -99,18 +99,18 @@
if (this->isArray()) {
if (this->isUnsizedArray()) {
out->appendf("%s %s[]",
- GrGLSLTypeString(effectiveType),
+ GrGLSLTypeString(shaderCaps, effectiveType),
this->getName().c_str());
} else {
SkASSERT(this->getArrayCount() > 0);
out->appendf("%s %s[%d]",
- GrGLSLTypeString(effectiveType),
+ GrGLSLTypeString(shaderCaps, effectiveType),
this->getName().c_str(),
this->getArrayCount());
}
} else {
out->appendf("%s %s",
- GrGLSLTypeString(effectiveType),
+ GrGLSLTypeString(shaderCaps, effectiveType),
this->getName().c_str());
}
}
diff --git a/src/gpu/ccpr/GrCCPRPathProcessor.cpp b/src/gpu/ccpr/GrCCPRPathProcessor.cpp
index 1292553..54ffb9b 100644
--- a/src/gpu/ccpr/GrCCPRPathProcessor.cpp
+++ b/src/gpu/ccpr/GrCCPRPathProcessor.cpp
@@ -56,6 +56,7 @@
this->addInstanceAttrib("view_matrix", kVec4f_GrVertexAttribType, kHigh_GrSLPrecision);
this->addInstanceAttrib("view_translate", kVec2f_GrVertexAttribType, kHigh_GrSLPrecision);
// FIXME: this could be a vector of two shorts if it were supported by Ganesh.
+ // Note: this should be doable now with kVec2us_uint_GrVertexAttribType
this->addInstanceAttrib("atlas_offset", kVec2i_GrVertexAttribType, kHigh_GrSLPrecision);
this->addInstanceAttrib("color", kVec4ub_GrVertexAttribType, kLow_GrSLPrecision);
diff --git a/src/gpu/effects/GrBitmapTextGeoProc.cpp b/src/gpu/effects/GrBitmapTextGeoProc.cpp
index a934ff1..d24ddf8 100644
--- a/src/gpu/effects/GrBitmapTextGeoProc.cpp
+++ b/src/gpu/effects/GrBitmapTextGeoProc.cpp
@@ -17,50 +17,53 @@
class GrGLBitmapTextGeoProc : public GrGLSLGeometryProcessor {
public:
- GrGLBitmapTextGeoProc() : fColor(GrColor_ILLEGAL) {}
+ GrGLBitmapTextGeoProc() : fColor(GrColor_ILLEGAL), fAtlasSize({0,0}) {}
void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override {
- const GrBitmapTextGeoProc& cte = args.fGP.cast<GrBitmapTextGeoProc>();
+ const GrBitmapTextGeoProc& btgp = args.fGP.cast<GrBitmapTextGeoProc>();
GrGLSLVertexBuilder* vertBuilder = args.fVertBuilder;
GrGLSLVaryingHandler* varyingHandler = args.fVaryingHandler;
GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
// emit attributes
- varyingHandler->emitAttributes(cte);
+ varyingHandler->emitAttributes(btgp);
- // compute numbers to be hardcoded to convert texture coordinates from int to float
- SkASSERT(cte.numTextureSamplers() == 1);
- SkDEBUGCODE(GrTexture* atlas = cte.textureSampler(0).peekTexture());
- SkASSERT(atlas && SkIsPow2(atlas->width()) && SkIsPow2(atlas->height()));
+ const char* atlasSizeInvName;
+ fAtlasSizeInvUniform = uniformHandler->addUniform(kVertex_GrShaderFlag,
+ kVec2f_GrSLType,
+ kHigh_GrSLPrecision,
+ "AtlasSizeInv",
+ &atlasSizeInvName);
GrGLSLVertToFrag v(kVec2f_GrSLType);
varyingHandler->addVarying("TextureCoords", &v, kHigh_GrSLPrecision);
- vertBuilder->codeAppendf("%s = %s;", v.vsOut(),
- cte.inTextureCoords()->fName);
+ vertBuilder->codeAppendf("%s = %s * %s;", v.vsOut(),
+ btgp.inTextureCoords()->fName,
+ atlasSizeInvName);
GrGLSLPPFragmentBuilder* fragBuilder = args.fFragBuilder;
// Setup pass through color
- if (cte.hasVertexColor()) {
- varyingHandler->addPassThroughAttribute(cte.inColor(), args.fOutputColor);
+ if (btgp.hasVertexColor()) {
+ varyingHandler->addPassThroughAttribute(btgp.inColor(), args.fOutputColor);
} else {
this->setupUniformColor(fragBuilder, uniformHandler, args.fOutputColor,
&fColorUniform);
}
// Setup position
- this->writeOutputPosition(vertBuilder, gpArgs, cte.inPosition()->fName);
+ this->writeOutputPosition(vertBuilder, gpArgs, btgp.inPosition()->fName);
// emit transforms
this->emitTransforms(vertBuilder,
varyingHandler,
uniformHandler,
gpArgs->fPositionVar,
- cte.inPosition()->fName,
- cte.localMatrix(),
+ btgp.inPosition()->fName,
+ btgp.localMatrix(),
args.fFPCoordTransformHandler);
- if (cte.maskFormat() == kARGB_GrMaskFormat) {
+ if (btgp.maskFormat() == kARGB_GrMaskFormat) {
fragBuilder->codeAppendf("%s = ", args.fOutputColor);
fragBuilder->appendTextureLookupAndModulate(args.fOutputColor,
args.fTexSamplers[0],
@@ -84,31 +87,35 @@
pdman.set4fv(fColorUniform, 1, c);
fColor = btgp.color();
}
+
+ SkASSERT(btgp.numTextureSamplers() == 1);
+ GrTexture* atlas = btgp.textureSampler(0).peekTexture();
+ SkASSERT(atlas && SkIsPow2(atlas->width()) && SkIsPow2(atlas->height()));
+
+ if (fAtlasSize.fWidth != atlas->width() || fAtlasSize.fHeight != atlas->height()) {
+ pdman.set2f(fAtlasSizeInvUniform, 1.0f / atlas->width(), 1.0f / atlas->height());
+ fAtlasSize.set(atlas->width(), atlas->height());
+ }
this->setTransformDataHelper(btgp.localMatrix(), pdman, &transformIter);
}
static inline void GenKey(const GrGeometryProcessor& proc,
const GrShaderCaps&,
GrProcessorKeyBuilder* b) {
- const GrBitmapTextGeoProc& gp = proc.cast<GrBitmapTextGeoProc>();
+ const GrBitmapTextGeoProc& btgp = proc.cast<GrBitmapTextGeoProc>();
uint32_t key = 0;
- key |= (gp.usesLocalCoords() && gp.localMatrix().hasPerspective()) ? 0x1 : 0x0;
- key |= gp.maskFormat() << 1;
+ key |= (btgp.usesLocalCoords() && btgp.localMatrix().hasPerspective()) ? 0x1 : 0x0;
+ key |= btgp.maskFormat() << 1;
b->add32(key);
-
- // Currently we hardcode numbers to convert atlas coordinates to normalized floating point
- SkASSERT(gp.numTextureSamplers() == 1);
- GrTextureProxy* atlas = gp.textureSampler(0).proxy();
- if (atlas) {
- b->add32(atlas->width());
- b->add32(atlas->height());
- }
}
private:
- GrColor fColor;
+ GrColor fColor;
UniformHandle fColorUniform;
+ SkISize fAtlasSize;
+ UniformHandle fAtlasSizeInvUniform;
+
typedef GrGLSLGeometryProcessor INHERITED;
};
@@ -133,7 +140,8 @@
if (hasVertexColor) {
fInColor = &this->addVertexAttrib("inColor", kVec4ub_GrVertexAttribType);
}
- fInTextureCoords = &this->addVertexAttrib("inTextureCoords", kVec2us_GrVertexAttribType,
+
+ fInTextureCoords = &this->addVertexAttrib("inTextureCoords", kVec2us_uint_GrVertexAttribType,
kHigh_GrSLPrecision);
this->addTextureSampler(&fTextureSampler);
}
diff --git a/src/gpu/effects/GrDistanceFieldGeoProc.cpp b/src/gpu/effects/GrDistanceFieldGeoProc.cpp
index 8dd2fa6..87b47e4 100644
--- a/src/gpu/effects/GrDistanceFieldGeoProc.cpp
+++ b/src/gpu/effects/GrDistanceFieldGeoProc.cpp
@@ -23,11 +23,12 @@
class GrGLDistanceFieldA8TextGeoProc : public GrGLSLGeometryProcessor {
public:
GrGLDistanceFieldA8TextGeoProc()
- : fViewMatrix(SkMatrix::InvalidMatrix())
-#ifdef SK_GAMMA_APPLY_TO_A8
- , fDistanceAdjust(-1.0f)
-#endif
- {}
+ : fViewMatrix(SkMatrix::InvalidMatrix())
+ #ifdef SK_GAMMA_APPLY_TO_A8
+ , fDistanceAdjust(-1.0f)
+ #endif
+ , fAtlasSize({0,0}) {
+ }
void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override{
const GrDistanceFieldA8TextGeoProc& dfTexEffect =
@@ -41,6 +42,12 @@
// emit attributes
varyingHandler->emitAttributes(dfTexEffect);
+ const char* atlasSizeInvName;
+ fAtlasSizeInvUniform = uniformHandler->addUniform(kVertex_GrShaderFlag,
+ kVec2f_GrSLType,
+ kHigh_GrSLPrecision,
+ "AtlasSizeInv",
+ &atlasSizeInvName);
#ifdef SK_GAMMA_APPLY_TO_A8
// adjust based on gamma
const char* distanceAdjustUniName = nullptr;
@@ -70,8 +77,17 @@
args.fFPCoordTransformHandler);
// add varyings
- GrGLSLVertToFrag recipScale(kFloat_GrSLType);
GrGLSLVertToFrag uv(kVec2f_GrSLType);
+ varyingHandler->addVarying("TextureCoords", &uv, kHigh_GrSLPrecision);
+ vertBuilder->codeAppendf("%s = %s * %s;", uv.vsOut(),
+ dfTexEffect.inTextureCoords()->fName,
+ atlasSizeInvName);
+
+ GrGLSLVertToFrag st(kVec2f_GrSLType);
+ varyingHandler->addVarying("IntTextureCoords", &st, kHigh_GrSLPrecision);
+ vertBuilder->codeAppendf("%s = %s;", st.vsOut(),
+ dfTexEffect.inTextureCoords()->fName);
+
bool isUniformScale = (dfTexEffect.getFlags() & kUniformScale_DistanceFieldEffectMask) ==
kUniformScale_DistanceFieldEffectMask;
bool isSimilarity = SkToBool(dfTexEffect.getFlags() & kSimilarity_DistanceFieldEffectFlag);
@@ -79,29 +95,14 @@
SkToBool(dfTexEffect.getFlags() & kGammaCorrect_DistanceFieldEffectFlag);
bool isAliased =
SkToBool(dfTexEffect.getFlags() & kAliased_DistanceFieldEffectFlag);
- varyingHandler->addVarying("TextureCoords", &uv, kHigh_GrSLPrecision);
- vertBuilder->codeAppendf("%s = %s;", uv.vsOut(), dfTexEffect.inTextureCoords()->fName);
-
- // compute numbers to be hardcoded to convert texture coordinates from float to int
- SkASSERT(dfTexEffect.numTextureSamplers() == 1);
- GrTexture* atlas = dfTexEffect.textureSampler(0).peekTexture();
- SkASSERT(atlas && SkIsPow2(atlas->width()) && SkIsPow2(atlas->height()));
-
- GrGLSLVertToFrag st(kVec2f_GrSLType);
- varyingHandler->addVarying("IntTextureCoords", &st, kHigh_GrSLPrecision);
- vertBuilder->codeAppendf("%s = float2(%d, %d) * %s;", st.vsOut(),
- atlas->width(), atlas->height(),
- dfTexEffect.inTextureCoords()->fName);
// Use highp to work around aliasing issues
fragBuilder->codeAppendf("highp float2 uv = %s;\n", uv.fsIn());
- fragBuilder->codeAppend("\tfloat texColor = ");
- fragBuilder->appendTextureLookup(args.fTexSamplers[0],
- "uv",
- kVec2f_GrSLType);
- fragBuilder->codeAppend(".r;\n");
- fragBuilder->codeAppend("\tfloat distance = "
+ fragBuilder->codeAppend("float texColor = ");
+ fragBuilder->appendTextureLookup(args.fTexSamplers[0], "uv", kVec2f_GrSLType);
+ fragBuilder->codeAppend(".r;");
+ fragBuilder->codeAppend("float distance = "
SK_DistanceFieldMultiplier "*(texColor - " SK_DistanceFieldThreshold ");");
#ifdef SK_GAMMA_APPLY_TO_A8
// adjust width based on gamma
@@ -177,15 +178,15 @@
void setData(const GrGLSLProgramDataManager& pdman, const GrPrimitiveProcessor& proc,
FPCoordTransformIter&& transformIter) override {
+ const GrDistanceFieldA8TextGeoProc& dfa8gp = proc.cast<GrDistanceFieldA8TextGeoProc>();
+
#ifdef SK_GAMMA_APPLY_TO_A8
- const GrDistanceFieldA8TextGeoProc& dfTexEffect = proc.cast<GrDistanceFieldA8TextGeoProc>();
- float distanceAdjust = dfTexEffect.getDistanceAdjust();
+ float distanceAdjust = dfa8gp.getDistanceAdjust();
if (distanceAdjust != fDistanceAdjust) {
- pdman.set1f(fDistanceAdjustUni, distanceAdjust);
fDistanceAdjust = distanceAdjust;
+ pdman.set1f(fDistanceAdjustUni, distanceAdjust);
}
#endif
- const GrDistanceFieldA8TextGeoProc& dfa8gp = proc.cast<GrDistanceFieldA8TextGeoProc>();
if (!dfa8gp.viewMatrix().isIdentity() && !fViewMatrix.cheapEqualTo(dfa8gp.viewMatrix())) {
fViewMatrix = dfa8gp.viewMatrix();
@@ -193,6 +194,16 @@
GrGLSLGetMatrix<3>(viewMatrix, fViewMatrix);
pdman.setMatrix3f(fViewMatrixUniform, viewMatrix);
}
+
+ SkASSERT(dfa8gp.numTextureSamplers() == 1);
+ GrTexture* atlas = dfa8gp.textureSampler(0).peekTexture();
+ SkASSERT(atlas && SkIsPow2(atlas->width()) && SkIsPow2(atlas->height()));
+
+ if (fAtlasSize.fWidth != atlas->width() || fAtlasSize.fHeight != atlas->height()) {
+ fAtlasSize.set(atlas->width(), atlas->height());
+ pdman.set2f(fAtlasSizeInvUniform, 1.0f / atlas->width(), 1.0f / atlas->height());
+ }
+
this->setTransformDataHelper(SkMatrix::I(), pdman, &transformIter);
}
@@ -203,14 +214,6 @@
uint32_t key = dfTexEffect.getFlags();
key |= ComputePosKey(dfTexEffect.viewMatrix()) << 16;
b->add32(key);
-
- // Currently we hardcode numbers to convert atlas coordinates to normalized floating point
- SkASSERT(gp.numTextureSamplers() == 1);
- GrTextureProxy* atlas = gp.textureSampler(0).proxy();
- if (atlas) {
- b->add32(atlas->width());
- b->add32(atlas->height());
- }
}
private:
@@ -220,6 +223,8 @@
float fDistanceAdjust;
UniformHandle fDistanceAdjustUni;
#endif
+ SkISize fAtlasSize;
+ UniformHandle fAtlasSizeInvUniform;
typedef GrGLSLGeometryProcessor INHERITED;
};
@@ -249,7 +254,7 @@
fInPosition = &this->addVertexAttrib("inPosition", kVec2f_GrVertexAttribType,
kHigh_GrSLPrecision);
fInColor = &this->addVertexAttrib("inColor", kVec4ub_GrVertexAttribType);
- fInTextureCoords = &this->addVertexAttrib("inTextureCoords", kVec2us_GrVertexAttribType,
+ fInTextureCoords = &this->addVertexAttrib("inTextureCoords", kVec2us_uint_GrVertexAttribType,
kHigh_GrSLPrecision);
this->addTextureSampler(&fTextureSampler);
}
@@ -308,8 +313,9 @@
class GrGLDistanceFieldPathGeoProc : public GrGLSLGeometryProcessor {
public:
GrGLDistanceFieldPathGeoProc()
- : fViewMatrix(SkMatrix::InvalidMatrix())
- , fTextureSize(SkISize::Make(-1, -1)) {}
+ : fViewMatrix(SkMatrix::InvalidMatrix())
+ , fAtlasSize({0,0}) {
+ }
void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override{
const GrDistanceFieldPathGeoProc& dfTexEffect = args.fGP.cast<GrDistanceFieldPathGeoProc>();
@@ -323,12 +329,26 @@
// emit attributes
varyingHandler->emitAttributes(dfTexEffect);
- GrGLSLVertToFrag v(kVec2f_GrSLType);
- varyingHandler->addVarying("TextureCoords", &v, kHigh_GrSLPrecision);
+ const char* atlasSizeInvName;
+ fAtlasSizeInvUniform = uniformHandler->addUniform(kVertex_GrShaderFlag,
+ kVec2f_GrSLType,
+ kHigh_GrSLPrecision,
+ "AtlasSizeInv",
+ &atlasSizeInvName);
+
+ GrGLSLVertToFrag uv(kVec2f_GrSLType);
+ varyingHandler->addVarying("TextureCoords", &uv, kHigh_GrSLPrecision);
+ vertBuilder->codeAppendf("%s = %s * %s;", uv.vsOut(),
+ dfTexEffect.inTextureCoords()->fName,
+ atlasSizeInvName);
+
+ GrGLSLVertToFrag st(kVec2f_GrSLType);
+ varyingHandler->addVarying("IntTextureCoords", &st, kHigh_GrSLPrecision);
+ vertBuilder->codeAppendf("%s = %s;", st.vsOut(),
+ dfTexEffect.inTextureCoords()->fName);
// setup pass through color
varyingHandler->addPassThroughAttribute(dfTexEffect.inColor(), args.fOutputColor);
- vertBuilder->codeAppendf("%s = %s;", v.vsOut(), dfTexEffect.inTextureCoords()->fName);
// Setup position
this->writeOutputPosition(vertBuilder,
@@ -346,23 +366,15 @@
dfTexEffect.inPosition()->fName,
args.fFPCoordTransformHandler);
- const char* textureSizeUniName = nullptr;
- fTextureSizeUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kVec2f_GrSLType, kDefault_GrSLPrecision,
- "TextureSize", &textureSizeUniName);
-
// Use highp to work around aliasing issues
- fragBuilder->codeAppendf("highp float2 uv = %s;", v.fsIn());
+ fragBuilder->codeAppendf("highp float2 uv = %s;", uv.fsIn());
fragBuilder->codeAppend("float texColor = ");
- fragBuilder->appendTextureLookup(args.fTexSamplers[0],
- "uv",
- kVec2f_GrSLType);
+ fragBuilder->appendTextureLookup(args.fTexSamplers[0], "uv", kVec2f_GrSLType);
fragBuilder->codeAppend(".r;");
fragBuilder->codeAppend("float distance = "
SK_DistanceFieldMultiplier "*(texColor - " SK_DistanceFieldThreshold ");");
- fragBuilder->codeAppendf("highp float2 st = uv*%s;", textureSizeUniName);
fragBuilder->codeAppend("float afwidth;");
bool isUniformScale = (dfTexEffect.getFlags() & kUniformScale_DistanceFieldEffectMask) ==
kUniformScale_DistanceFieldEffectMask;
@@ -376,10 +388,12 @@
// this gives us a smooth step across approximately one fragment
#ifdef SK_VULKAN
- fragBuilder->codeAppend("afwidth = abs(" SK_DistanceFieldAAFactor "*dFdx(st.x));");
+ fragBuilder->codeAppendf("afwidth = abs(" SK_DistanceFieldAAFactor "*dFdx(%s.x));",
+ st.fsIn());
#else
// We use the y gradient because there is a bug in the Mali 400 in the x direction.
- fragBuilder->codeAppend("afwidth = abs(" SK_DistanceFieldAAFactor "*dFdy(st.y));");
+ fragBuilder->codeAppendf("afwidth = abs(" SK_DistanceFieldAAFactor "*dFdy(%s.y));",
+ st.fsIn());
#endif
} else if (isSimilarity) {
// For similarity transform, we adjust the effect of the transformation on the distance
@@ -388,10 +402,10 @@
// this gives us a smooth step across approximately one fragment
#ifdef SK_VULKAN
- fragBuilder->codeAppend("float st_grad_len = length(dFdx(st));");
+ fragBuilder->codeAppendf("float st_grad_len = length(dFdx(%s));", st.fsIn());
#else
// We use the y gradient because there is a bug in the Mali 400 in the x direction.
- fragBuilder->codeAppend("float st_grad_len = length(dFdy(st));");
+ fragBuilder->codeAppendf("float st_grad_len = length(dFdy(%s));", st.fsIn());
#endif
fragBuilder->codeAppend("afwidth = abs(" SK_DistanceFieldAAFactor "*st_grad_len);");
} else {
@@ -408,8 +422,8 @@
fragBuilder->codeAppend("dist_grad = dist_grad*inversesqrt(dg_len2);");
fragBuilder->codeAppend("}");
- fragBuilder->codeAppend("float2 Jdx = dFdx(st);");
- fragBuilder->codeAppend("float2 Jdy = dFdy(st);");
+ fragBuilder->codeAppendf("float2 Jdx = dFdx(%s);", st.fsIn());
+ fragBuilder->codeAppendf("float2 Jdy = dFdy(%s);", st.fsIn());
fragBuilder->codeAppend("float2 grad = float2(dist_grad.x*Jdx.x + dist_grad.y*Jdy.x,");
fragBuilder->codeAppend(" dist_grad.x*Jdx.y + dist_grad.y*Jdy.y);");
@@ -431,17 +445,6 @@
void setData(const GrGLSLProgramDataManager& pdman, const GrPrimitiveProcessor& proc,
FPCoordTransformIter&& transformIter) override {
- SkASSERT(fTextureSizeUni.isValid());
-
- GrTexture* texture = proc.textureSampler(0).peekTexture();
-
- if (texture->width() != fTextureSize.width() ||
- texture->height() != fTextureSize.height()) {
- fTextureSize = SkISize::Make(texture->width(), texture->height());
- pdman.set2f(fTextureSizeUni,
- SkIntToScalar(fTextureSize.width()),
- SkIntToScalar(fTextureSize.height()));
- }
const GrDistanceFieldPathGeoProc& dfpgp = proc.cast<GrDistanceFieldPathGeoProc>();
@@ -451,6 +454,16 @@
GrGLSLGetMatrix<3>(viewMatrix, fViewMatrix);
pdman.setMatrix3f(fViewMatrixUniform, viewMatrix);
}
+
+ SkASSERT(dfpgp.numTextureSamplers() == 1);
+ GrTexture* atlas = dfpgp.textureSampler(0).peekTexture();
+ SkASSERT(atlas && SkIsPow2(atlas->width()) && SkIsPow2(atlas->height()));
+
+ if (fAtlasSize.fWidth != atlas->width() || fAtlasSize.fHeight != atlas->height()) {
+ fAtlasSize.set(atlas->width(), atlas->height());
+ pdman.set2f(fAtlasSizeInvUniform, 1.0f / atlas->width(), 1.0f / atlas->height());
+ }
+
this->setTransformDataHelper(SkMatrix::I(), pdman, &transformIter);
}
@@ -465,10 +478,11 @@
}
private:
- UniformHandle fTextureSizeUni;
- UniformHandle fViewMatrixUniform;
SkMatrix fViewMatrix;
- SkISize fTextureSize;
+ UniformHandle fViewMatrixUniform;
+
+ SkISize fAtlasSize;
+ UniformHandle fAtlasSizeInvUniform;
typedef GrGLSLGeometryProcessor INHERITED;
};
@@ -491,7 +505,8 @@
fInPosition = &this->addVertexAttrib("inPosition", kVec2f_GrVertexAttribType,
kHigh_GrSLPrecision);
fInColor = &this->addVertexAttrib("inColor", kVec4ub_GrVertexAttribType);
- fInTextureCoords = &this->addVertexAttrib("inTextureCoords", kVec2us_GrVertexAttribType);
+ fInTextureCoords = &this->addVertexAttrib("inTextureCoords", kVec2us_uint_GrVertexAttribType,
+ kHigh_GrSLPrecision);
this->addTextureSampler(&fTextureSampler);
}
@@ -547,7 +562,8 @@
class GrGLDistanceFieldLCDTextGeoProc : public GrGLSLGeometryProcessor {
public:
GrGLDistanceFieldLCDTextGeoProc()
- : fViewMatrix(SkMatrix::InvalidMatrix()) {
+ : fViewMatrix(SkMatrix::InvalidMatrix())
+ , fAtlasSize({0,0}) {
fDistanceAdjust = GrDistanceFieldLCDTextGeoProc::DistanceAdjust::Make(1.0f, 1.0f, 1.0f);
}
@@ -562,6 +578,13 @@
// emit attributes
varyingHandler->emitAttributes(dfTexEffect);
+ const char* atlasSizeInvName;
+ fAtlasSizeInvUniform = uniformHandler->addUniform(kVertex_GrShaderFlag,
+ kVec2f_GrSLType,
+ kHigh_GrSLPrecision,
+ "AtlasSizeInv",
+ &atlasSizeInvName);
+
GrGLSLPPFragmentBuilder* fragBuilder = args.fFragBuilder;
// setup pass through color
@@ -584,39 +607,36 @@
args.fFPCoordTransformHandler);
// set up varyings
+ GrGLSLVertToFrag uv(kVec2f_GrSLType);
+ varyingHandler->addVarying("TextureCoords", &uv, kHigh_GrSLPrecision);
+ vertBuilder->codeAppendf("%s = %s * %s;", uv.vsOut(),
+ dfTexEffect.inTextureCoords()->fName,
+ atlasSizeInvName);
+
+ GrGLSLVertToFrag st(kVec2f_GrSLType);
+ varyingHandler->addVarying("IntTextureCoords", &st, kHigh_GrSLPrecision);
+ vertBuilder->codeAppendf("%s = %s;", st.vsOut(),
+ dfTexEffect.inTextureCoords()->fName);
+
+ GrGLSLVertToFrag delta(kFloat_GrSLType);
+ varyingHandler->addVarying("Delta", &delta, kHigh_GrSLPrecision);
+ if (dfTexEffect.getFlags() & kBGR_DistanceFieldEffectFlag) {
+ vertBuilder->codeAppendf("%s = -%s.x/3.0;", delta.vsOut(), atlasSizeInvName);
+ } else {
+ vertBuilder->codeAppendf("%s = %s.x/3.0;", delta.vsOut(), atlasSizeInvName);
+ }
+
+ // add frag shader code
bool isUniformScale = (dfTexEffect.getFlags() & kUniformScale_DistanceFieldEffectMask) ==
kUniformScale_DistanceFieldEffectMask;
bool isSimilarity = SkToBool(dfTexEffect.getFlags() & kSimilarity_DistanceFieldEffectFlag);
bool isGammaCorrect =
SkToBool(dfTexEffect.getFlags() & kGammaCorrect_DistanceFieldEffectFlag);
- GrGLSLVertToFrag recipScale(kFloat_GrSLType);
- GrGLSLVertToFrag uv(kVec2f_GrSLType);
- varyingHandler->addVarying("TextureCoords", &uv, kHigh_GrSLPrecision);
- vertBuilder->codeAppendf("%s = %s;", uv.vsOut(), dfTexEffect.inTextureCoords()->fName);
-
- // compute numbers to be hardcoded to convert texture coordinates from float to int
- SkASSERT(dfTexEffect.numTextureSamplers() == 1);
- GrTexture* atlas = dfTexEffect.textureSampler(0).peekTexture();
- SkASSERT(atlas && SkIsPow2(atlas->width()) && SkIsPow2(atlas->height()));
-
- GrGLSLVertToFrag st(kVec2f_GrSLType);
- varyingHandler->addVarying("IntTextureCoords", &st, kHigh_GrSLPrecision);
- vertBuilder->codeAppendf("%s = float2(%d, %d) * %s;", st.vsOut(),
- atlas->width(), atlas->height(),
- dfTexEffect.inTextureCoords()->fName);
-
- // add frag shader code
// create LCD offset adjusted by inverse of transform
// Use highp to work around aliasing issues
fragBuilder->codeAppendf("highp float2 uv = %s;\n", uv.fsIn());
- SkScalar lcdDelta = 1.0f / (3.0f * atlas->width());
- if (dfTexEffect.getFlags() & kBGR_DistanceFieldEffectFlag) {
- fragBuilder->codeAppendf("highp float delta = -%.*f;\n", SK_FLT_DECIMAL_DIG, lcdDelta);
- } else {
- fragBuilder->codeAppendf("highp float delta = %.*f;\n", SK_FLT_DECIMAL_DIG, lcdDelta);
- }
if (isUniformScale) {
#ifdef SK_VULKAN
fragBuilder->codeAppendf("float st_grad_len = abs(dFdx(%s.x));", st.fsIn());
@@ -624,18 +644,19 @@
// We use the y gradient because there is a bug in the Mali 400 in the x direction.
fragBuilder->codeAppendf("float st_grad_len = abs(dFdy(%s.y));", st.fsIn());
#endif
- fragBuilder->codeAppend("float2 offset = float2(st_grad_len*delta, 0.0);");
+ fragBuilder->codeAppendf("float2 offset = float2(st_grad_len*%s, 0.0);", delta.fsIn());
} else if (isSimilarity) {
// For a similarity matrix with rotation, the gradient will not be aligned
// with the texel coordinate axes, so we need to calculate it.
#ifdef SK_VULKAN
fragBuilder->codeAppendf("float2 st_grad = dFdx(%s);", st.fsIn());
- fragBuilder->codeAppend("float2 offset = delta*st_grad;");
+ fragBuilder->codeAppendf("float2 offset = %s*st_grad;", delta.fsIn());
#else
// We use dFdy because of a Mali 400 bug, and rotate -90 degrees to
// get the gradient in the x direction.
fragBuilder->codeAppendf("float2 st_grad = dFdy(%s);", st.fsIn());
- fragBuilder->codeAppend("float2 offset = delta*float2(st_grad.y, -st_grad.x);");
+ fragBuilder->codeAppendf("float2 offset = %s*float2(st_grad.y, -st_grad.x);",
+ delta.fsIn());
#endif
fragBuilder->codeAppend("float st_grad_len = length(st_grad);");
} else {
@@ -643,7 +664,7 @@
fragBuilder->codeAppend("float2 Jdx = dFdx(st);");
fragBuilder->codeAppend("float2 Jdy = dFdy(st);");
- fragBuilder->codeAppend("float2 offset = delta*Jdx;");
+ fragBuilder->codeAppendf("float2 offset = %s*Jdx;", delta.fsIn());
}
// green is distance to uv center
@@ -742,6 +763,16 @@
GrGLSLGetMatrix<3>(viewMatrix, fViewMatrix);
pdman.setMatrix3f(fViewMatrixUniform, viewMatrix);
}
+
+ SkASSERT(dflcd.numTextureSamplers() == 1);
+ GrTexture* atlas = dflcd.textureSampler(0).peekTexture();
+ SkASSERT(atlas && SkIsPow2(atlas->width()) && SkIsPow2(atlas->height()));
+
+ if (fAtlasSize.fWidth != atlas->width() || fAtlasSize.fHeight != atlas->height()) {
+ fAtlasSize.set(atlas->width(), atlas->height());
+ pdman.set2f(fAtlasSizeInvUniform, 1.0f / atlas->width(), 1.0f / atlas->height());
+ }
+
this->setTransformDataHelper(SkMatrix::I(), pdman, &transformIter);
}
@@ -753,22 +784,17 @@
uint32_t key = dfTexEffect.getFlags();
key |= ComputePosKey(dfTexEffect.viewMatrix()) << 16;
b->add32(key);
-
- // Currently we hardcode numbers to convert atlas coordinates to normalized floating point
- SkASSERT(gp.numTextureSamplers() == 1);
- GrTextureProxy* atlas = gp.textureSampler(0).proxy();
- if (atlas) {
- b->add32(atlas->width());
- b->add32(atlas->height());
- }
}
private:
- SkMatrix fViewMatrix;
- UniformHandle fViewMatrixUniform;
- UniformHandle fColorUniform;
+ SkMatrix fViewMatrix;
+ UniformHandle fViewMatrixUniform;
+
GrDistanceFieldLCDTextGeoProc::DistanceAdjust fDistanceAdjust;
- UniformHandle fDistanceAdjustUni;
+ UniformHandle fDistanceAdjustUni;
+
+ SkISize fAtlasSize;
+ UniformHandle fAtlasSizeInvUniform;
typedef GrGLSLGeometryProcessor INHERITED;
};
@@ -791,7 +817,7 @@
fInPosition = &this->addVertexAttrib("inPosition", kVec2f_GrVertexAttribType,
kHigh_GrSLPrecision);
fInColor = &this->addVertexAttrib("inColor", kVec4ub_GrVertexAttribType);
- fInTextureCoords = &this->addVertexAttrib("inTextureCoords", kVec2us_GrVertexAttribType,
+ fInTextureCoords = &this->addVertexAttrib("inTextureCoords", kVec2us_uint_GrVertexAttribType,
kHigh_GrSLPrecision);
this->addTextureSampler(&fTextureSampler);
}
diff --git a/src/gpu/gl/GrGLVertexArray.cpp b/src/gpu/gl/GrGLVertexArray.cpp
index 745e532..991de96 100644
--- a/src/gpu/gl/GrGLVertexArray.cpp
+++ b/src/gpu/gl/GrGLVertexArray.cpp
@@ -37,8 +37,10 @@
return {true, 1, GR_GL_UNSIGNED_BYTE};
case kVec4ub_GrVertexAttribType:
return {true, 4, GR_GL_UNSIGNED_BYTE};
- case kVec2us_GrVertexAttribType:
+ case kVec2us_norm_GrVertexAttribType:
return {true, 2, GR_GL_UNSIGNED_SHORT};
+ case kVec2us_uint_GrVertexAttribType:
+ return {false, 2, GR_GL_UNSIGNED_SHORT};
case kInt_GrVertexAttribType:
return {false, 1, GR_GL_INT};
case kUint_GrVertexAttribType:
@@ -48,6 +50,40 @@
return {false, 0, 0};
};
+static bool GrVertexAttribTypeIsIntType(const GrShaderCaps* shaderCaps,
+ GrVertexAttribType type) {
+ switch (type) {
+ case kFloat_GrVertexAttribType:
+ return false;
+ case kVec2f_GrVertexAttribType:
+ return false;
+ case kVec3f_GrVertexAttribType:
+ return false;
+ case kVec4f_GrVertexAttribType:
+ return false;
+ case kVec2i_GrVertexAttribType:
+ return true;
+ case kVec3i_GrVertexAttribType:
+ return true;
+ case kVec4i_GrVertexAttribType:
+ return true;
+ case kUByte_GrVertexAttribType:
+ return false;
+ case kVec4ub_GrVertexAttribType:
+ return false;
+ case kVec2us_norm_GrVertexAttribType:
+ return false;
+ case kVec2us_uint_GrVertexAttribType:
+ return shaderCaps->integerSupport();
+ case kInt_GrVertexAttribType:
+ return true;
+ case kUint_GrVertexAttribType:
+ return true;
+ }
+ SK_ABORT("Unexpected attribute type");
+ return false;
+}
+
void GrGLAttribArrayState::set(GrGLGpu* gpu,
int index,
const GrBuffer* vertexBuffer,
@@ -65,7 +101,7 @@
gpu->bindBuffer(kVertex_GrBufferType, vertexBuffer);
const AttribLayout& layout = attrib_layout(type);
const GrGLvoid* offsetAsPtr = reinterpret_cast<const GrGLvoid*>(offsetInBytes);
- if (!GrVertexAttribTypeIsIntType(type)) {
+ if (!GrVertexAttribTypeIsIntType(gpu->caps()->shaderCaps(), type)) {
GR_GL_CALL(gpu->glInterface(), VertexAttribPointer(index,
layout.fCount,
layout.fType,
diff --git a/src/gpu/glsl/GrGLSL.cpp b/src/gpu/glsl/GrGLSL.cpp
index b580f0b..6fe1e26 100644
--- a/src/gpu/glsl/GrGLSL.cpp
+++ b/src/gpu/glsl/GrGLSL.cpp
@@ -26,6 +26,66 @@
return false;
}
+const char* GrGLSLTypeString(const GrShaderCaps* shaderCaps, GrSLType t) {
+ switch (t) {
+ case kVoid_GrSLType:
+ return "void";
+ case kFloat_GrSLType:
+ return "float";
+ case kVec2f_GrSLType:
+ return "float2";
+ case kVec3f_GrSLType:
+ return "float3";
+ case kVec4f_GrSLType:
+ return "float4";
+ case kVec2us_GrSLType:
+ if (shaderCaps->integerSupport()) {
+ return "uint2";
+ } else {
+ // uint2 (aka uvec2) isn't supported in GLSL ES 1.00/GLSL 1.20
+ return "float2";
+ }
+ case kVec2i_GrSLType:
+ return "int2";
+ case kVec3i_GrSLType:
+ return "int3";
+ case kVec4i_GrSLType:
+ return "int4";
+ case kMat22f_GrSLType:
+ return "float2x2";
+ case kMat33f_GrSLType:
+ return "float3x3";
+ case kMat44f_GrSLType:
+ return "float4x4";
+ case kTexture2DSampler_GrSLType:
+ return "sampler2D";
+ case kITexture2DSampler_GrSLType:
+ return "isampler2D";
+ case kTextureExternalSampler_GrSLType:
+ return "samplerExternalOES";
+ case kTexture2DRectSampler_GrSLType:
+ return "sampler2DRect";
+ case kBufferSampler_GrSLType:
+ return "samplerBuffer";
+ case kBool_GrSLType:
+ return "bool";
+ case kInt_GrSLType:
+ return "int";
+ case kUint_GrSLType:
+ return "uint";
+ case kTexture2D_GrSLType:
+ return "texture2D";
+ case kSampler_GrSLType:
+ return "sampler";
+ case kImageStorage2D_GrSLType:
+ return "image2D";
+ case kIImageStorage2D_GrSLType:
+ return "iimage2D";
+ }
+ SK_ABORT("Unknown shader var type.");
+ return ""; // suppress warning
+}
+
void GrGLSLAppendDefaultFloatPrecisionDeclaration(GrSLPrecision p,
const GrShaderCaps& shaderCaps,
SkString* out) {
diff --git a/src/gpu/glsl/GrGLSLShaderBuilder.cpp b/src/gpu/glsl/GrGLSLShaderBuilder.cpp
index 8f7d23d..4d54c75 100644
--- a/src/gpu/glsl/GrGLSLShaderBuilder.cpp
+++ b/src/gpu/glsl/GrGLSLShaderBuilder.cpp
@@ -46,7 +46,7 @@
const GrShaderVar* args,
const char* body,
SkString* outName) {
- this->functions().append(GrGLSLTypeString(returnType));
+ this->functions().append(GrGLSLTypeString(fProgramBuilder->shaderCaps(), returnType));
fProgramBuilder->nameVariable(outName, '\0', name);
this->functions().appendf(" %s", outName->c_str());
this->functions().append("(");
diff --git a/src/gpu/instanced/InstanceProcessor.cpp b/src/gpu/instanced/InstanceProcessor.cpp
index ab68326..d1d826c 100644
--- a/src/gpu/instanced/InstanceProcessor.cpp
+++ b/src/gpu/instanced/InstanceProcessor.cpp
@@ -112,7 +112,7 @@
const char* attr(Attrib attr) const { return fInstProc.getAttrib((int)attr).fName; }
- void fetchNextParam(GrSLType type = kVec4f_GrSLType) const {
+ void fetchNextParam(const GrShaderCaps* shaderCaps, GrSLType type = kVec4f_GrSLType) const {
SkASSERT(fParamsBuffer.isValid());
switch (type) {
case kVec2f_GrSLType: // fall through
@@ -120,7 +120,7 @@
case kVec4f_GrSLType:
break;
default:
- fVertexBuilder->codeAppendf("%s(", GrGLSLTypeString(type));
+ fVertexBuilder->codeAppendf("%s(", GrGLSLTypeString(shaderCaps, type));
}
fVertexBuilder->appendTexelFetch(fParamsBuffer, "paramsIdx++");
switch (type) {
@@ -156,12 +156,12 @@
void init(GrGLSLVaryingHandler*, GrGLSLVertexBuilder*);
virtual void setupRect(GrGLSLVertexBuilder*) = 0;
virtual void setupOval(GrGLSLVertexBuilder*) = 0;
- void setupRRect(GrGLSLVertexBuilder*, int* usedShapeDefinitions);
+ void setupRRect(const GrShaderCaps*, GrGLSLVertexBuilder*, int* usedShapeDefinitions);
void initInnerShape(GrGLSLVaryingHandler*, GrGLSLVertexBuilder*);
virtual void setupInnerRect(GrGLSLVertexBuilder*) = 0;
virtual void setupInnerOval(GrGLSLVertexBuilder*) = 0;
- void setupInnerSimpleRRect(GrGLSLVertexBuilder*);
+ void setupInnerSimpleRRect(const GrShaderCaps*, GrGLSLVertexBuilder*);
const char* outShapeCoords() {
return fModifiedShapeCoords ? fModifiedShapeCoords : fInputs.attr(Attrib::kShapeCoords);
@@ -200,7 +200,7 @@
void setupSimpleRadii(GrGLSLVertexBuilder*);
void setupNinePatchRadii(GrGLSLVertexBuilder*);
- void setupComplexRadii(GrGLSLVertexBuilder*);
+ void setupComplexRadii(const GrShaderCaps*, GrGLSLVertexBuilder*);
const OpInfo fOpInfo;
const VertexInputs& fInputs;
@@ -241,7 +241,7 @@
v->codeAppendf("if (0 != (%s & uint(PERSPECTIVE_FLAG))) {",
inputs.attr(Attrib::kInstanceInfo));
v->codeAppend ( "shapeMatrix[2] = ");
- inputs.fetchNextParam(kVec3f_GrSLType);
+ inputs.fetchNextParam(args.fShaderCaps, kVec3f_GrSLType);
v->codeAppend ( ";");
v->codeAppend ("}");
}
@@ -264,12 +264,12 @@
} else if (kOval_ShapeFlag == ip.opInfo().fShapeTypes) {
backend->setupOval(v);
} else {
- backend->setupRRect(v, &usedShapeDefinitions);
+ backend->setupRRect(args.fShaderCaps, v, &usedShapeDefinitions);
}
} else {
if (ip.opInfo().fShapeTypes & kRRect_ShapesMask) {
v->codeAppend ("if (shapeType >= uint(SIMPLE_R_RECT_SHAPE_TYPE)) {");
- backend->setupRRect(v, &usedShapeDefinitions);
+ backend->setupRRect(args.fShaderCaps, v, &usedShapeDefinitions);
v->codeAppend ("}");
usedShapeDefinitions |= kSimpleRRect_ShapeFlag;
}
@@ -305,7 +305,7 @@
// Here we take advantage of the fact that outerRect == localRect in recordDRRect.
v->codeAppendf("float4 outer = %s;", inputs.attr(Attrib::kLocalRect));
v->codeAppend ("float4 inner = ");
- inputs.fetchNextParam();
+ inputs.fetchNextParam(args.fShaderCaps);
v->codeAppend (";");
// outer2Inner is a transform from shape coords to inner shape coords:
// e.g. innerShapeCoords = shapeCoords * outer2Inner.xy + outer2Inner.zw
@@ -326,12 +326,12 @@
} else if (kOval_ShapeFlag == ip.opInfo().fInnerShapeTypes) {
backend->setupInnerOval(v);
} else {
- backend->setupInnerSimpleRRect(v);
+ backend->setupInnerSimpleRRect(args.fShaderCaps, v);
}
} else {
if (ip.opInfo().fInnerShapeTypes & kSimpleRRect_ShapeFlag) {
v->codeAppend ("if (uint(SIMPLE_R_RECT_SHAPE_TYPE) == innerShapeType) {");
- backend->setupInnerSimpleRRect(v);
+ backend->setupInnerSimpleRRect(args.fShaderCaps, v);
v->codeAppend("}");
usedShapeDefinitions |= kSimpleRRect_ShapeFlag;
}
@@ -385,10 +385,10 @@
} else {
v->codeAppendf( "float2x3 localMatrix;");
v->codeAppend ( "localMatrix[0] = ");
- inputs.fetchNextParam(kVec3f_GrSLType);
+ inputs.fetchNextParam(args.fShaderCaps, kVec3f_GrSLType);
v->codeAppend ( ";");
v->codeAppend ( "localMatrix[1] = ");
- inputs.fetchNextParam(kVec3f_GrSLType);
+ inputs.fetchNextParam(args.fShaderCaps, kVec3f_GrSLType);
v->codeAppend ( ";");
v->codeAppend ( "localCoords = (float3(localCoords, 1) * localMatrix).xy;");
}
@@ -397,7 +397,7 @@
GrSLType positionType = ip.opInfo().fHasPerspective ? kVec3f_GrSLType : kVec2f_GrSLType;
v->codeAppendf("%s deviceCoords = float3(%s, 1) * shapeMatrix;",
- GrGLSLTypeString(positionType), backend->outShapeCoords());
+ GrGLSLTypeString(args.fShaderCaps, positionType), backend->outShapeCoords());
gpArgs->fPositionVar.set(positionType, "deviceCoords");
this->emitTransforms(v, varyingHandler, uniHandler, gpArgs->fPositionVar, localCoords,
@@ -420,13 +420,15 @@
}
}
-void GLSLInstanceProcessor::Backend::setupRRect(GrGLSLVertexBuilder* v, int* usedShapeDefinitions) {
+void GLSLInstanceProcessor::Backend::setupRRect(const GrShaderCaps* shaderCaps,
+ GrGLSLVertexBuilder* v,
+ int* usedShapeDefinitions) {
v->codeAppendf("uint2 corner = uint2(uint(%s) & 1, (uint(%s) >> 1) & 1);",
fInputs.attr(Attrib::kVertexAttrs), fInputs.attr(Attrib::kVertexAttrs));
v->codeAppend ("float2 cornerSign = float2(corner) * 2.0 - 1.0;");
v->codeAppendf("float2 radii%s;", fNeedsNeighborRadii ? ", neighborRadii" : "");
v->codeAppend ("float2x2 p = ");
- fInputs.fetchNextParam(kMat22f_GrSLType);
+ fInputs.fetchNextParam(shaderCaps, kMat22f_GrSLType);
v->codeAppend (";");
uint8_t types = fOpInfo.fShapeTypes & kRRect_ShapesMask;
if (0 == (types & (types - 1))) {
@@ -435,7 +437,7 @@
} else if (kNinePatch_ShapeFlag == types) {
this->setupNinePatchRadii(v);
} else if (kComplexRRect_ShapeFlag == types) {
- this->setupComplexRadii(v);
+ this->setupComplexRadii(shaderCaps, v);
}
} else {
if (types & kSimpleRRect_ShapeFlag) {
@@ -459,7 +461,7 @@
}
if (types & kComplexRRect_ShapeFlag) {
v->codeAppend ("else {");
- this->setupComplexRadii(v);
+ this->setupComplexRadii(shaderCaps, v);
v->codeAppend ("}");
}
}
@@ -492,7 +494,8 @@
}
}
-void GLSLInstanceProcessor::Backend::setupComplexRadii(GrGLSLVertexBuilder* v) {
+void GLSLInstanceProcessor::Backend::setupComplexRadii(const GrShaderCaps* shaderCaps,
+ GrGLSLVertexBuilder* v) {
/**
* The x and y radii of each arc are stored in separate vectors,
* in the following order:
@@ -508,7 +511,7 @@
*
*/
v->codeAppend("float2x2 p2 = ");
- fInputs.fetchNextParam(kMat22f_GrSLType);
+ fInputs.fetchNextParam(shaderCaps, kMat22f_GrSLType);
v->codeAppend(";");
v->codeAppend("radii = float2(p[corner.x][corner.y], p2[corner.y][corner.x]);");
if (fNeedsNeighborRadii) {
@@ -539,9 +542,10 @@
}
}
-void GLSLInstanceProcessor::Backend::setupInnerSimpleRRect(GrGLSLVertexBuilder* v) {
+void GLSLInstanceProcessor::Backend::setupInnerSimpleRRect(const GrShaderCaps* shaderCaps,
+ GrGLSLVertexBuilder* v) {
v->codeAppend("float2x2 innerP = ");
- fInputs.fetchNextParam(kMat22f_GrSLType);
+ fInputs.fetchNextParam(shaderCaps, kMat22f_GrSLType);
v->codeAppend(";");
v->codeAppend("float2 innerRadii = innerP[0] * 2.0 / innerP[1];");
this->onSetupInnerSimpleRRect(v);
diff --git a/src/gpu/ops/GrSmallPathRenderer.cpp b/src/gpu/ops/GrSmallPathRenderer.cpp
index 69cd669..7e7a496 100644
--- a/src/gpu/ops/GrSmallPathRenderer.cpp
+++ b/src/gpu/ops/GrSmallPathRenderer.cpp
@@ -351,11 +351,11 @@
shapeData = new ShapeData;
if (!this->addBMPathToAtlas(target,
- &flushInfo,
- atlas,
- shapeData,
- args.fShape,
- this->viewMatrix())) {
+ &flushInfo,
+ atlas,
+ shapeData,
+ args.fShape,
+ this->viewMatrix())) {
delete shapeData;
continue;
}
@@ -479,7 +479,6 @@
shapeData->fKey.set(shape, dimension);
shapeData->fID = id;
- // set the bounds rect to the original bounds
shapeData->fBounds = SkRect::Make(devPathBounds);
shapeData->fBounds.offset(-translateX, -translateY);
shapeData->fBounds.fLeft /= scale;
@@ -615,22 +614,10 @@
}
// set up texture coordinates
- SkScalar texLeft = shapeData->fTextureCoords.fLeft;
- SkScalar texTop = shapeData->fTextureCoords.fTop;
- SkScalar texRight = shapeData->fTextureCoords.fRight;
- SkScalar texBottom = shapeData->fTextureCoords.fBottom;
-
- // convert texcoords to unsigned short format
- sk_sp<GrTextureProxy> proxy = atlas->getProxy();
-
- // The proxy must be functionally exact for this normalization to work correctly
- SkASSERT(GrResourceProvider::IsFunctionallyExact(proxy.get()));
- SkScalar uFactor = 65535.f / proxy->width();
- SkScalar vFactor = 65535.f / proxy->height();
- uint16_t l = (uint16_t)(texLeft*uFactor);
- uint16_t t = (uint16_t)(texTop*vFactor);
- uint16_t r = (uint16_t)(texRight*uFactor);
- uint16_t b = (uint16_t)(texBottom*vFactor);
+ uint16_t l = shapeData->fTextureCoords.fLeft;
+ uint16_t t = shapeData->fTextureCoords.fTop;
+ uint16_t r = shapeData->fTextureCoords.fRight;
+ uint16_t b = shapeData->fTextureCoords.fBottom;
// set vertex texture coords
intptr_t textureCoordOffset = offset + sizeof(SkPoint) + sizeof(GrColor);
diff --git a/src/gpu/text/GrAtlasTextBlob_regenInOp.cpp b/src/gpu/text/GrAtlasTextBlob_regenInOp.cpp
index 3150988..96f0080 100644
--- a/src/gpu/text/GrAtlasTextBlob_regenInOp.cpp
+++ b/src/gpu/text/GrAtlasTextBlob_regenInOp.cpp
@@ -21,9 +21,8 @@
template <bool regenPos, bool regenCol, bool regenTexCoords>
inline void regen_vertices(intptr_t vertex, const GrGlyph* glyph, size_t vertexStride,
bool useDistanceFields, SkScalar transX, SkScalar transY,
- int32_t log2Width, int32_t log2Height,
GrColor color) {
- int u0, v0, u1, v1;
+ uint16_t u0, v0, u1, v1;
if (regenTexCoords) {
SkASSERT(glyph);
int width = glyph->fBounds.width();
@@ -40,20 +39,6 @@
u1 = u0 + width;
v1 = v0 + height;
}
-
- // normalize
- u0 *= 65535;
- u0 >>= log2Width;
- u1 *= 65535;
- u1 >>= log2Width;
- v0 *= 65535;
- v0 >>= log2Height;
- v1 *= 65535;
- v1 >>= log2Height;
- SkASSERT(u0 >= 0 && u0 <= 65535);
- SkASSERT(u1 >= 0 && u1 <= 65535);
- SkASSERT(v0 >= 0 && v0 <= 65535);
- SkASSERT(v1 >= 0 && v1 <= 65535);
}
// This is a bit wonky, but sometimes we have LCD text, in which case we won't have color
@@ -75,8 +60,8 @@
if (regenTexCoords) {
uint16_t* textureCoords = reinterpret_cast<uint16_t*>(vertex + texCoordOffset);
- textureCoords[0] = (uint16_t) u0;
- textureCoords[1] = (uint16_t) v0;
+ textureCoords[0] = u0;
+ textureCoords[1] = v0;
}
vertex += vertexStride;
@@ -94,8 +79,8 @@
if (regenTexCoords) {
uint16_t* textureCoords = reinterpret_cast<uint16_t*>(vertex + texCoordOffset);
- textureCoords[0] = (uint16_t)u0;
- textureCoords[1] = (uint16_t)v1;
+ textureCoords[0] = u0;
+ textureCoords[1] = v1;
}
vertex += vertexStride;
@@ -113,8 +98,8 @@
if (regenTexCoords) {
uint16_t* textureCoords = reinterpret_cast<uint16_t*>(vertex + texCoordOffset);
- textureCoords[0] = (uint16_t)u1;
- textureCoords[1] = (uint16_t)v1;
+ textureCoords[0] = u1;
+ textureCoords[1] = v1;
}
vertex += vertexStride;
@@ -132,8 +117,8 @@
if (regenTexCoords) {
uint16_t* textureCoords = reinterpret_cast<uint16_t*>(vertex + texCoordOffset);
- textureCoords[0] = (uint16_t)u1;
- textureCoords[1] = (uint16_t)v0;
+ textureCoords[0] = u1;
+ textureCoords[1] = v0;
}
}
@@ -170,7 +155,6 @@
bool brokenRun = false;
for (int glyphIdx = 0; glyphIdx < glyphCount; glyphIdx++) {
GrGlyph* glyph = nullptr;
- int log2Width = 0, log2Height = 0;
if (regenTexCoords) {
size_t glyphOffset = glyphIdx + info->glyphStartIndex();
@@ -197,8 +181,6 @@
}
fontCache->addGlyphToBulkAndSetUseToken(info->bulkUseToken(), glyph,
target->nextDrawToken());
- log2Width = fontCache->log2Width(info->maskFormat());
- log2Height = fontCache->log2Height(info->maskFormat());
}
intptr_t vertex = reinterpret_cast<intptr_t>(fVertices);
@@ -206,7 +188,7 @@
vertex += vertexStride * glyphIdx * GrAtlasTextOp::kVerticesPerGlyph;
regen_vertices<regenPos, regenCol, regenTexCoords>(vertex, glyph, vertexStride,
info->drawAsDistanceFields(), transX,
- transY, log2Width, log2Height, color);
+ transY, color);
helper->incGlyphCount();
}
diff --git a/src/gpu/vk/GrVkPipeline.cpp b/src/gpu/vk/GrVkPipeline.cpp
index 1a61605..22777df 100644
--- a/src/gpu/vk/GrVkPipeline.cpp
+++ b/src/gpu/vk/GrVkPipeline.cpp
@@ -34,8 +34,10 @@
return VK_FORMAT_R8_UNORM;
case kVec4ub_GrVertexAttribType:
return VK_FORMAT_R8G8B8A8_UNORM;
- case kVec2us_GrVertexAttribType:
+ case kVec2us_norm_GrVertexAttribType:
return VK_FORMAT_R16G16_UNORM;
+ case kVec2us_uint_GrVertexAttribType:
+ return VK_FORMAT_R16G16_UINT;
case kInt_GrVertexAttribType:
return VK_FORMAT_R32_SINT;
case kUint_GrVertexAttribType:
diff --git a/src/gpu/vk/GrVkUniformHandler.cpp b/src/gpu/vk/GrVkUniformHandler.cpp
index be746cd..98a2751 100644
--- a/src/gpu/vk/GrVkUniformHandler.cpp
+++ b/src/gpu/vk/GrVkUniformHandler.cpp
@@ -28,6 +28,8 @@
return 0xF;
case kVec4f_GrSLType:
return 0xF;
+ case kVec2us_GrSLType:
+ return 0x3;
case kVec2i_GrSLType:
return 0x7;
case kVec3i_GrSLType:
@@ -76,6 +78,8 @@
return 3 * sizeof(float);
case kVec4f_GrSLType:
return 4 * sizeof(float);
+ case kVec2us_GrSLType:
+ return 2 * sizeof(uint16_t);
case kVec2i_GrSLType:
return 2 * sizeof(int32_t);
case kVec3i_GrSLType:
diff --git a/src/gpu/vk/GrVkVaryingHandler.cpp b/src/gpu/vk/GrVkVaryingHandler.cpp
index 8e43b76..5912098 100644
--- a/src/gpu/vk/GrVkVaryingHandler.cpp
+++ b/src/gpu/vk/GrVkVaryingHandler.cpp
@@ -21,6 +21,8 @@
return 1;
case kVec4f_GrSLType:
return 1;
+ case kVec2us_GrSLType:
+ return 1;
case kVec2i_GrSLType:
return 1;
case kVec3i_GrSLType: