From 1b112cc5604d294427c0d51f194ab7fb3067d9e2 Mon Sep 17 00:00:00 2001 From: Brian Salomon Date: Tue, 10 Jul 2018 20:34:16 +0000 Subject: Revert "Remove interpolants are inaccurate workaround for Adreno 3xx." This reverts commit a7a278205bb040061cb4ba46839efe18635c7edc. Reason for revert: Chrome change had to be reverted because of new failures on Nexus 9 and 6P. Original change's description: > Remove interpolants are inaccurate workaround for Adreno 3xx. > > The chrome screenshot unit test that led to adding this workaround has > been adjusted to avoid testing AA edges of rendered rectangles. We're > accepting the inaccuracy in favor of increased performance. > > Chrome change: https://chromium-review.googlesource.com/c/chromium/src/+/1129041 > > Bug: chromium:847984 > Change-Id: I9b714ade2a67e956ebb2773ebe3b8632dc3a50c6 > Reviewed-on: https://skia-review.googlesource.com/140180 > Commit-Queue: Brian Salomon > Commit-Queue: Brian Osman > Auto-Submit: Brian Salomon > Reviewed-by: Brian Osman TBR=bsalomon@google.com,brianosman@google.com Change-Id: Ic6b0e5a343556e59d144852f9fa5b561302f9781 No-Presubmit: true No-Tree-Checks: true No-Try: true Bug: chromium:847984 Reviewed-on: https://skia-review.googlesource.com/140380 Reviewed-by: Brian Salomon Commit-Queue: Brian Salomon --- src/gpu/ops/GrTextureOp.cpp | 85 +++++++++++++++++++++++++++++++-------------- 1 file changed, 58 insertions(+), 27 deletions(-) (limited to 'src/gpu/ops') diff --git a/src/gpu/ops/GrTextureOp.cpp b/src/gpu/ops/GrTextureOp.cpp index 2fe8bb0ab4..bced31dbc5 100644 --- a/src/gpu/ops/GrTextureOp.cpp +++ b/src/gpu/ops/GrTextureOp.cpp @@ -203,38 +203,69 @@ public: } args.fFragBuilder->codeAppend(";"); if (textureGP.usesCoverageEdgeAA()) { + const char* aaDistName = nullptr; bool mulByFragCoordW = false; - GrGLSLVarying aaDistVarying(kFloat4_GrSLType, - GrGLSLVarying::Scope::kVertToFrag); - if (kFloat3_GrVertexAttribType == textureGP.fPositions.type()) { - args.fVaryingHandler->addVarying("aaDists", &aaDistVarying); - // The distance from edge equation e to homogenous point p=sk_Position - // is e.x*p.x/p.wx + e.y*p.y/p.w + e.z. However, we want screen space - // interpolation of this distance. We can do this by multiplying the - // varying in the VS by p.w and then multiplying by sk_FragCoord.w in - // the FS. So we output e.x*p.x + e.y*p.y + e.z * p.w - args.fVertBuilder->codeAppendf( - R"(%s = float4(dot(aaEdge0, %s), dot(aaEdge1, %s), - dot(aaEdge2, %s), dot(aaEdge3, %s));)", - aaDistVarying.vsOut(), textureGP.fPositions.name(), - textureGP.fPositions.name(), textureGP.fPositions.name(), - textureGP.fPositions.name()); - mulByFragCoordW = true; + // When interpolation is inaccurate we perform the evaluation of the edge + // equations in the fragment shader rather than interpolating values computed + // in the vertex shader. + if (!args.fShaderCaps->interpolantsAreInaccurate()) { + GrGLSLVarying aaDistVarying(kFloat4_GrSLType, + GrGLSLVarying::Scope::kVertToFrag); + if (kFloat3_GrVertexAttribType == textureGP.fPositions.type()) { + args.fVaryingHandler->addVarying("aaDists", &aaDistVarying); + // The distance from edge equation e to homogenous point p=sk_Position + // is e.x*p.x/p.wx + e.y*p.y/p.w + e.z. However, we want screen space + // interpolation of this distance. We can do this by multiplying the + // varying in the VS by p.w and then multiplying by sk_FragCoord.w in + // the FS. So we output e.x*p.x + e.y*p.y + e.z * p.w + args.fVertBuilder->codeAppendf( + R"(%s = float4(dot(aaEdge0, %s), dot(aaEdge1, %s), + dot(aaEdge2, %s), dot(aaEdge3, %s));)", + aaDistVarying.vsOut(), textureGP.fPositions.name(), + textureGP.fPositions.name(), textureGP.fPositions.name(), + textureGP.fPositions.name()); + mulByFragCoordW = true; + } else { + args.fVaryingHandler->addVarying("aaDists", &aaDistVarying); + args.fVertBuilder->codeAppendf( + R"(%s = float4(dot(aaEdge0.xy, %s.xy) + aaEdge0.z, + dot(aaEdge1.xy, %s.xy) + aaEdge1.z, + dot(aaEdge2.xy, %s.xy) + aaEdge2.z, + dot(aaEdge3.xy, %s.xy) + aaEdge3.z);)", + aaDistVarying.vsOut(), textureGP.fPositions.name(), + textureGP.fPositions.name(), textureGP.fPositions.name(), + textureGP.fPositions.name()); + } + aaDistName = aaDistVarying.fsIn(); } else { - args.fVaryingHandler->addVarying("aaDists", &aaDistVarying); - args.fVertBuilder->codeAppendf( - R"(%s = float4(dot(aaEdge0.xy, %s.xy) + aaEdge0.z, - dot(aaEdge1.xy, %s.xy) + aaEdge1.z, - dot(aaEdge2.xy, %s.xy) + aaEdge2.z, - dot(aaEdge3.xy, %s.xy) + aaEdge3.z);)", - aaDistVarying.vsOut(), textureGP.fPositions.name(), - textureGP.fPositions.name(), textureGP.fPositions.name(), - textureGP.fPositions.name()); + GrGLSLVarying aaEdgeVarying[4]{ + {kFloat3_GrSLType, GrGLSLVarying::Scope::kVertToFrag}, + {kFloat3_GrSLType, GrGLSLVarying::Scope::kVertToFrag}, + {kFloat3_GrSLType, GrGLSLVarying::Scope::kVertToFrag}, + {kFloat3_GrSLType, GrGLSLVarying::Scope::kVertToFrag} + }; + for (int i = 0; i < 4; ++i) { + SkString name; + name.printf("aaEdge%d", i); + args.fVaryingHandler->addVarying(name.c_str(), &aaEdgeVarying[i], + Interpolation::kCanBeFlat); + args.fVertBuilder->codeAppendf( + "%s = aaEdge%d;", aaEdgeVarying[i].vsOut(), i); + } + args.fFragBuilder->codeAppendf( + R"(float4 aaDists = float4(dot(%s.xy, sk_FragCoord.xy) + %s.z, + dot(%s.xy, sk_FragCoord.xy) + %s.z, + dot(%s.xy, sk_FragCoord.xy) + %s.z, + dot(%s.xy, sk_FragCoord.xy) + %s.z);)", + aaEdgeVarying[0].fsIn(), aaEdgeVarying[0].fsIn(), + aaEdgeVarying[1].fsIn(), aaEdgeVarying[1].fsIn(), + aaEdgeVarying[2].fsIn(), aaEdgeVarying[2].fsIn(), + aaEdgeVarying[3].fsIn(), aaEdgeVarying[3].fsIn()); + aaDistName = "aaDists"; } args.fFragBuilder->codeAppendf( "float mindist = min(min(%s.x, %s.y), min(%s.z, %s.w));", - aaDistVarying.fsIn(), aaDistVarying.fsIn(), aaDistVarying.fsIn(), - aaDistVarying.fsIn()); + aaDistName, aaDistName, aaDistName, aaDistName); if (mulByFragCoordW) { args.fFragBuilder->codeAppend("mindist *= sk_FragCoord.w;"); } -- cgit v1.2.3