AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

removed appendPrecisionModifier

Browse Source 
skslc always provides support for precision modifiers (ignoring them if
unsupported on the target platform), so the Skia appendPrecisionModifier
function was redundant.

BUG=skia:

GOLD_TRYBOT_URL= https://gold.skia.org/search?issue=5117

Change-Id: I4bcbd47ef8d1f4f1b055086d4c9050254584b48c
Reviewed-on: https://skia-review.googlesource.com/5117
Reviewed-by: Brian Salomon <bsalomon@google.com>
Commit-Queue: Ethan Nicholas <ethannicholas@google.com>
This commit is contained in:
Ethan Nicholas 2016-11-22 09:31:35 -05:00 committed by Skia Commit-Bot
parent 3605ace7dd
commit 1fc83b131a
5 changed files with 37 additions and 77 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
src/gpu/effects/GrDistanceFieldGeoProc.cpp
View File

@ -96,8 +96,7 @@ public:
dfTexEffect.inTextureCoords()->fName);
// Use highp to work around aliasing issues
fragBuilder->appendPrecisionModifier(kHigh_GrSLPrecision);
fragBuilder->codeAppendf("vec2 uv = %s;\n", uv.fsIn());
fragBuilder->codeAppendf("highp vec2 uv = %s;\n", uv.fsIn());
fragBuilder->codeAppend("\tfloat texColor = ");
fragBuilder->appendTextureLookup(args.fTexSamplers[0],
@ -350,8 +349,7 @@ public:
"TextureSize", &textureSizeUniName);
// Use highp to work around aliasing issues
fragBuilder->appendPrecisionModifier(kHigh_GrSLPrecision);
fragBuilder->codeAppendf("vec2 uv = %s;", v.fsIn());
fragBuilder->codeAppendf("highp vec2 uv = %s;", v.fsIn());
fragBuilder->codeAppend("float texColor = ");
fragBuilder->appendTextureLookup(args.fTexSamplers[0],
@ -361,8 +359,7 @@ public:
fragBuilder->codeAppend("float distance = "
SK_DistanceFieldMultiplier "*(texColor - " SK_DistanceFieldThreshold ");");
fragBuilder->appendPrecisionModifier(kHigh_GrSLPrecision);
fragBuilder->codeAppendf("vec2 st = uv*%s;", textureSizeUniName);
fragBuilder->codeAppendf("highp vec2 st = uv*%s;", textureSizeUniName);
fragBuilder->codeAppend("float afwidth;");
bool isUniformScale = (dfTexEffect.getFlags() & kUniformScale_DistanceFieldEffectMask) ==
kUniformScale_DistanceFieldEffectMask;
@ -608,15 +605,13 @@ public:
// create LCD offset adjusted by inverse of transform
// Use highp to work around aliasing issues
fragBuilder->appendPrecisionModifier(kHigh_GrSLPrecision);
fragBuilder->codeAppendf("vec2 uv = %s;\n", uv.fsIn());
fragBuilder->appendPrecisionModifier(kHigh_GrSLPrecision);
fragBuilder->codeAppendf("highp vec2 uv = %s;\n", uv.fsIn());
SkScalar lcdDelta = 1.0f / (3.0f * atlas->width());
if (dfTexEffect.getFlags() & kBGR_DistanceFieldEffectFlag) {
fragBuilder->codeAppendf("float delta = -%.*f;\n", SK_FLT_DECIMAL_DIG, lcdDelta);
fragBuilder->codeAppendf("highp float delta = -%.*f;\n", SK_FLT_DECIMAL_DIG, lcdDelta);
} else {
fragBuilder->codeAppendf("float delta = %.*f;\n", SK_FLT_DECIMAL_DIG, lcdDelta);
fragBuilder->codeAppendf("highp float delta = %.*f;\n", SK_FLT_DECIMAL_DIG, lcdDelta);
}
if (isUniformScale) {
#ifdef SK_VULKAN

6
src/gpu/effects/GrTextureDomain.cpp
View File

@ -103,10 +103,8 @@ void GrTextureDomain::GLDomain::sampleTexture(GrGLSLShaderBuilder* builder,
inCoords.c_str());
builder->codeAppend(";");
builder->appendPrecisionModifier(kHigh_GrSLPrecision);
builder->codeAppendf("float x = (%s).x;", inCoords.c_str());
builder->appendPrecisionModifier(kHigh_GrSLPrecision);
builder->codeAppendf("float y = (%s).y;", inCoords.c_str());
builder->codeAppendf("highp float x = (%s).x;", inCoords.c_str());
builder->codeAppendf("highp float y = (%s).y;", inCoords.c_str());
builder->codeAppendf("x = abs(2.0*(x - %s.x)/(%s.z - %s.x) - 1.0);",
domain, domain, domain);

6
src/gpu/glsl/GrGLSLShaderBuilder.cpp
View File

@ -35,12 +35,6 @@ void GrGLSLShaderBuilder::declAppend(const GrShaderVar& var) {
this->codeAppendf("%s;", tempDecl.c_str());
}
void GrGLSLShaderBuilder::appendPrecisionModifier(GrSLPrecision precision) {
if (fProgramBuilder->glslCaps()->usesPrecisionModifiers()) {
this->codeAppendf("%s ", GrGLSLPrecisionString(precision));
}
}
void GrGLSLShaderBuilder::emitFunction(GrSLType returnType,
const char* name,
int argCnt,

5
src/gpu/glsl/GrGLSLShaderBuilder.h
View File

@ -120,11 +120,6 @@ public:
*/
void declAppend(const GrShaderVar& var);
/**
* Appends a precision qualifier followed by a space, if relevant for the GLSL version.
*/
void appendPrecisionModifier(GrSLPrecision);
/** Emits a helper function outside of main() in the fragment shader. */
void emitFunction(GrSLType returnType,
const char* name,

80
src/gpu/instanced/InstanceProcessor.cpp
View File

@ -108,8 +108,7 @@ public:
void initParams(const SamplerHandle paramsBuffer) {
fParamsBuffer = paramsBuffer;
fVertexBuilder->appendPrecisionModifier(kHigh_GrSLPrecision);
fVertexBuilder->codeAppendf("int paramsIdx = int(%s & 0x%x);",
fVertexBuilder->codeAppendf("highp int paramsIdx = int(%s & 0x%x);",
this->attr(Attrib::kInstanceInfo),
kParamsIdx_InfoMask);
}
@ -635,12 +634,10 @@ void GLSLInstanceProcessor::BackendNonAA::onEmitCode(GrGLSLVertexBuilder*,
if (!fBatchInfo.fCannotDiscard) {
dropFragment = "discard";
} else if (fModifiesCoverage) {
f->appendPrecisionModifier(kLow_GrSLPrecision);
f->codeAppend ("float covered = 1.0;");
f->codeAppend ("lowp float covered = 1.0;");
dropFragment = "covered = 0.0";
} else if (fModifiesColor) {
f->appendPrecisionModifier(kLow_GrSLPrecision);
f->codeAppendf("vec4 color = %s;", fColor.fsIn());
f->codeAppendf("lowp vec4 color = %s;", fColor.fsIn());
dropFragment = "color = vec4(0)";
}
if (fTriangleIsArc.fsIn()) {
@ -975,14 +972,12 @@ void GLSLInstanceProcessor::BackendCoverage::onEmitCode(GrGLSLVertexBuilder* v,
this->emitInnerRect(f, innerCoverageDecl.c_str());
} else {
f->codeAppendf("%s = 0.0;", innerCoverageDecl.c_str());
f->appendPrecisionModifier(kMedium_GrSLPrecision);
f->codeAppendf("vec2 distanceToArcEdge = abs(%s) - %s.xy;",
f->codeAppendf("mediump vec2 distanceToArcEdge = abs(%s) - %s.xy;",
fInnerShapeCoords.fsIn(), fInnerRRect.fsIn());
f->codeAppend ("if (any(lessThan(distanceToArcEdge, vec2(1e-5)))) {");
this->emitInnerRect(f, "innerCoverage");
f->codeAppend ("} else {");
f->appendPrecisionModifier(kMedium_GrSLPrecision);
f->codeAppendf( "vec2 ellipseCoords = distanceToArcEdge * %s.zw;",
f->codeAppendf( "mediump vec2 ellipseCoords = distanceToArcEdge * %s.zw;",
fInnerRRect.fsIn());
this->emitArc(f, "ellipseCoords", fInnerEllipseName.fsIn(),
false /*ellipseCoordsNeedClamp*/,
@ -1015,8 +1010,7 @@ void GLSLInstanceProcessor::BackendCoverage::emitCircle(GrGLSLPPFragmentBuilder*
const char* outCoverage) {
// TODO: circleCoords = max(circleCoords, 0) if we decide to do this optimization on rrects.
SkASSERT(!(kRRect_ShapesMask & fBatchInfo.fShapeTypes));
f->appendPrecisionModifier(kMedium_GrSLPrecision);
f->codeAppendf("float distanceToEdge = %s - length(%s);",
f->codeAppendf("mediump float distanceToEdge = %s - length(%s);",
fBloatedRadius.fsIn(), fEllipseCoords.fsIn());
f->codeAppendf("%s = clamp(distanceToEdge, 0.0, 1.0);", outCoverage);
}
@ -1032,32 +1026,28 @@ void GLSLInstanceProcessor::BackendCoverage::emitArc(GrGLSLPPFragmentBuilder* f,
// This serves two purposes:
// - To restrict the arcs of rounded rects to their positive quadrants.
// - To avoid inversesqrt(0) in the ellipse formula.
f->appendPrecisionModifier(kMedium_GrSLPrecision);
if (ellipseCoordsMayBeNegative) {
f->codeAppendf("vec2 ellipseClampedCoords = max(abs(%s), vec2(1e-4));", ellipseCoords);
f->codeAppendf("mediump vec2 ellipseClampedCoords = max(abs(%s), vec2(1e-4));",
ellipseCoords);
} else {
f->codeAppendf("vec2 ellipseClampedCoords = max(%s, vec2(1e-4));", ellipseCoords);
f->codeAppendf("mediump vec2 ellipseClampedCoords = max(%s, vec2(1e-4));",
ellipseCoords);
}
ellipseCoords = "ellipseClampedCoords";
}
// ellipseCoords are in pixel space and ellipseName is 1 / rx^2, 1 / ry^2.
f->appendPrecisionModifier(kHigh_GrSLPrecision);
f->codeAppendf("vec2 Z = %s * %s;", ellipseCoords, ellipseName);
f->codeAppendf("highp vec2 Z = %s * %s;", ellipseCoords, ellipseName);
// implicit is the evaluation of (x/rx)^2 + (y/ry)^2 - 1.
f->appendPrecisionModifier(kHigh_GrSLPrecision);
f->codeAppendf("float implicit = dot(Z, %s) - 1.0;", ellipseCoords);
f->codeAppendf("highp float implicit = dot(Z, %s) - 1.0;", ellipseCoords);
// gradDot is the squared length of the gradient of the implicit.
f->appendPrecisionModifier(kHigh_GrSLPrecision);
f->codeAppendf("float gradDot = 4.0 * dot(Z, Z);");
f->appendPrecisionModifier(kMedium_GrSLPrecision);
f->codeAppend ("float approxDist = implicit * inversesqrt(gradDot);");
f->codeAppendf("highp float gradDot = 4.0 * dot(Z, Z);");
f->codeAppend ("mediump float approxDist = implicit * inversesqrt(gradDot);");
f->codeAppendf("%s = clamp(0.5 - approxDist, 0.0, 1.0);", outCoverage);
}
void GLSLInstanceProcessor::BackendCoverage::emitInnerRect(GrGLSLPPFragmentBuilder* f,
const char* outCoverage) {
f->appendPrecisionModifier(kLow_GrSLPrecision);
f->codeAppendf("vec2 c = %s - abs(%s);",
f->codeAppendf("lowp vec2 c = %s - abs(%s);",
fInnerShapeBloatedHalfSize.fsIn(), fDistanceToInnerEdge.fsIn());
f->codeAppendf("%s = clamp(min(c.x, c.y), 0.0, 1.0);", outCoverage);
}
@ -1391,8 +1381,7 @@ void GLSLInstanceProcessor::BackendMultisample::onEmitCode(GrGLSLVertexBuilder*,
if (fBatchInfo.fHasPerspective && fBatchInfo.fInnerShapeTypes) {
// This determines if the fragment should consider the inner shape in its sample mask.
// We take the derivative early in case discards may occur before we get to the inner shape.
f->appendPrecisionModifier(kHigh_GrSLPrecision);
f->codeAppendf("vec2 fragInnerShapeApproxHalfSpan = 0.5 * fwidth(%s);",
f->codeAppendf("highp vec2 fragInnerShapeApproxHalfSpan = 0.5 * fwidth(%s);",
fInnerShapeCoords.fsIn());
}
@ -1409,8 +1398,7 @@ void GLSLInstanceProcessor::BackendMultisample::onEmitCode(GrGLSLVertexBuilder*,
if (arcTest && fBatchInfo.fHasPerspective) {
// The non-perspective version accounts for fwidth() in the vertex shader.
// We make sure to take the derivative here, before a neighbor pixel may early accept.
f->appendPrecisionModifier(kHigh_GrSLPrecision);
f->codeAppendf("vec2 arcTest = %s - 0.5 * fwidth(%s);",
f->codeAppendf("highp vec2 arcTest = %s - 0.5 * fwidth(%s);",
fArcTest.fsIn(), fArcTest.fsIn());
arcTest = "arcTest";
}
@ -1494,8 +1482,7 @@ void GLSLInstanceProcessor::BackendMultisample::emitRect(GrGLSLPPFragmentBuilder
}
f->codeAppend ("int rectMask = 0;");
f->codeAppend ("for (int i = 0; i < SAMPLE_COUNT; i++) {");
f->appendPrecisionModifier(kHigh_GrSLPrecision);
f->codeAppend ( "vec2 pt = ");
f->codeAppend ( "highp vec2 pt = ");
this->interpolateAtSample(f, *coords.fVarying, "i", coords.fInverseMatrix);
f->codeAppend ( ";");
f->codeAppend ( "if (all(lessThan(abs(pt), vec2(1)))) rectMask |= (1 << i);");
@ -1530,8 +1517,7 @@ void GLSLInstanceProcessor::BackendMultisample::emitArc(GrGLSLPPFragmentBuilder*
}
f->codeAppend ( "int arcMask = 0;");
f->codeAppend ( "for (int i = 0; i < SAMPLE_COUNT; i++) {");
f->appendPrecisionModifier(kHigh_GrSLPrecision);
f->codeAppend ( "vec2 pt = ");
f->codeAppend ( "highp vec2 pt = ");
this->interpolateAtSample(f, *coords.fVarying, "i", coords.fInverseMatrix);
f->codeAppend ( ";");
if (clampCoords) {
@ -1550,16 +1536,14 @@ void GLSLInstanceProcessor::BackendMultisample::emitSimpleRRect(GrGLSLPPFragment
const EmitShapeCoords& coords,
const char* rrect,
const EmitShapeOpts& opts) {
f->appendPrecisionModifier(kHigh_GrSLPrecision);
f->codeAppendf("vec2 distanceToArcEdge = abs(%s) - %s.xy;", coords.fVarying->fsIn(), rrect);
f->codeAppendf("highp vec2 distanceToArcEdge = abs(%s) - %s.xy;", coords.fVarying->fsIn(),
rrect);
f->codeAppend ("if (any(lessThan(distanceToArcEdge, vec2(0)))) {");
this->emitRect(f, coords, opts);
f->codeAppend ("} else {");
if (coords.fInverseMatrix && coords.fFragHalfSpan) {
f->appendPrecisionModifier(kHigh_GrSLPrecision);
f->codeAppendf("vec2 rrectCoords = distanceToArcEdge * %s.zw;", rrect);
f->appendPrecisionModifier(kHigh_GrSLPrecision);
f->codeAppendf("vec2 fragRRectHalfSpan = %s * %s.zw;", coords.fFragHalfSpan, rrect);
f->codeAppendf("highp vec2 rrectCoords = distanceToArcEdge * %s.zw;", rrect);
f->codeAppendf("highp vec2 fragRRectHalfSpan = %s * %s.zw;", coords.fFragHalfSpan, rrect);
f->codeAppendf("if (%s(rrectCoords + fragRRectHalfSpan) <= 1.0) {", fSquareFun.c_str());
// The entire pixel is inside the round rect.
this->acceptOrRejectWholeFragment(f, true, opts);
@ -1568,16 +1552,12 @@ void GLSLInstanceProcessor::BackendMultisample::emitSimpleRRect(GrGLSLPPFragment
// The entire pixel is outside the round rect.
this->acceptOrRejectWholeFragment(f, false, opts);
f->codeAppend ("} else {");
f->appendPrecisionModifier(kHigh_GrSLPrecision);
f->codeAppendf( "vec2 s = %s.zw * sign(%s);", rrect, coords.fVarying->fsIn());
f->appendPrecisionModifier(kHigh_GrSLPrecision);
f->codeAppendf( "mat2 innerRRectInverseMatrix = %s * mat2(s.x, 0, 0, s.y);",
f->codeAppendf( "highp vec2 s = %s.zw * sign(%s);", rrect, coords.fVarying->fsIn());
f->codeAppendf( "highp mat2 innerRRectInverseMatrix = %s * mat2(s.x, 0, 0, s.y);",
coords.fInverseMatrix);
f->appendPrecisionModifier(kHigh_GrSLPrecision);
f->codeAppend ( "int rrectMask = 0;");
f->codeAppend ( "highp int rrectMask = 0;");
f->codeAppend ( "for (int i = 0; i < SAMPLE_COUNT; i++) {");
f->appendPrecisionModifier(kHigh_GrSLPrecision);
f->codeAppend ( "vec2 pt = rrectCoords + ");
f->codeAppend ( "highp vec2 pt = rrectCoords + ");
f->appendOffsetToSample("i", GrGLSLFPFragmentBuilder::kSkiaDevice_Coordinates);
f->codeAppend ( "* innerRRectInverseMatrix;");
f->codeAppendf( "if (%s(max(pt, vec2(0))) < 1.0) rrectMask |= (1 << i);",
@ -1588,12 +1568,10 @@ void GLSLInstanceProcessor::BackendMultisample::emitSimpleRRect(GrGLSLPPFragment
} else {
f->codeAppend ("int rrectMask = 0;");
f->codeAppend ("for (int i = 0; i < SAMPLE_COUNT; i++) {");
f->appendPrecisionModifier(kHigh_GrSLPrecision);
f->codeAppend ( "vec2 shapePt = ");
f->codeAppend ( "highp vec2 shapePt = ");
this->interpolateAtSample(f, *coords.fVarying, "i", nullptr);
f->codeAppend ( ";");
f->appendPrecisionModifier(kHigh_GrSLPrecision);
f->codeAppendf( "vec2 rrectPt = max(abs(shapePt) - %s.xy, vec2(0)) * %s.zw;",
f->codeAppendf( "highp vec2 rrectPt = max(abs(shapePt) - %s.xy, vec2(0)) * %s.zw;",
rrect, rrect);
f->codeAppendf( "if (%s(rrectPt) < 1.0) rrectMask |= (1 << i);", fSquareFun.c_str());
f->codeAppend ("}");