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

Address CCPR TODOs now that we are in device space

Browse Source 
Bug: skia:
Change-Id: I48619e93108bdbe453155be4f9da821ff0397ee3
Reviewed-on: https://skia-review.googlesource.com/63400
Commit-Queue: Chris Dalton <csmartdalton@google.com>
Reviewed-by: Brian Salomon <bsalomon@google.com>
This commit is contained in:
Chris Dalton 2017-10-24 14:16:52 -06:00 committed by Skia Commit-Bot
parent c17bf32a1b
commit cc0ab7e3c1
8 changed files with 22 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
src/gpu/ccpr/GrCCPRCoverageProcessor.cpp
View File

@ -76,18 +76,13 @@ void GrCCPRCoverageProcessor::Shader::EmitEdgeDistanceEquation(GrGLSLShaderBuild
const char* leftPt,
const char* rightPt,
const char* outputDistanceEquation) {
// Which quadrant does the vector from left -> right fall into?
s->codeAppendf("float2 qlr = sign(%s - %s);", rightPt, leftPt);
s->codeAppend ("float2 d1 = float2(qlr.y, -qlr.x);");
s->codeAppendf("float2 n = float2(%s.y - %s.y, %s.x - %s.x);",
rightPt, leftPt, leftPt, rightPt);
s->codeAppendf("float2 kk = n * float2x2(%s + bloat * d1, %s - bloat * d1);",
leftPt, leftPt);
// Clamp for when n=0. wind=0 when n=0 so as long as we don't get Inf or NaN we are fine.
s->codeAppendf("float scale = 1 / max(kk[0] - kk[1], 1e-30);");
s->codeAppendf("%s = half3(-n, kk[1]) * scale;", outputDistanceEquation);
s->codeAppend ("float nwidth = (abs(n.x) + abs(n.y)) * (bloat * 2);");
// When nwidth=0, wind must also be 0 (and coverage * wind = 0). So it doesn't matter what we
// come up with here as long as it isn't NaN or Inf.
s->codeAppend ("n /= (0 != nwidth) ? nwidth : 1;");
s->codeAppendf("%s = float3(-n, dot(n, %s) - .5);", outputDistanceEquation, leftPt);
}
int GrCCPRCoverageProcessor::Shader::DefineSoftSampleLocations(GrGLSLPPFragmentBuilder* f,

3
src/gpu/ccpr/GrCCPRCoverageProcessor.h
View File

@ -153,7 +153,8 @@ public:
const char* skOutputColor, const char* skOutputCoverage) const;
// Defines an equation ("dot(float3(pt, 1), distance_equation)") that is -1 on the outside
// border of a conservative raster edge and 0 on the inside (see emitEdgeGeometry).
// border of a conservative raster edge and 0 on the inside. 'leftPt' and 'rightPt' must be
// ordered clockwise.
static void EmitEdgeDistanceEquation(GrGLSLShaderBuilder*, const char* leftPt,
const char* rightPt,
const char* outputDistanceEquation);

5
src/gpu/ccpr/GrCCPRCoverageProcessor_GSImpl.cpp
View File

@ -211,12 +211,13 @@ public:
Shader::EmitEdgeDistanceEquation(g, "left", "right", "float3 edge_distance_equation");
// qlr is defined in EmitEdgeDistanceEquation. TODO: address in a followup CL!
// Which quadrant does the vector from left -> right fall into?
g->codeAppend ("float2 qlr = sign(right - left);");
g->codeAppend ("float2x2 outer_pts = float2x2(left - bloat * qlr, right + bloat * qlr);");
g->codeAppend ("half2 outer_coverage = edge_distance_equation.xy * outer_pts + "
"edge_distance_equation.z;");
// d1 is defined in EmitEdgeDistanceEquation. TODO: address in a followup CL!
g->codeAppend ("float2 d1 = float2(qlr.y, -qlr.x);");
g->codeAppend ("float2 d2 = d1;");
g->codeAppend ("bool aligned = qlr.x == 0 || qlr.y == 0;");
g->codeAppend ("if (aligned) {");

26
src/gpu/ccpr/GrCCPRCubicShader.cpp
View File

@ -92,15 +92,6 @@ void GrCCPRCubicShader::emitSetupCode(GrGLSLShaderBuilder* s, const char* pts,
"0, orientation[0], 0, "
"0, 0, orientation[1]);", fKLMMatrix.c_str());
// TODO: remove in followup CL.
s->declareGlobal(fKLMDerivatives);
s->codeAppendf("%s[0] = %s[0].xy;",
fKLMDerivatives.c_str(), fKLMMatrix.c_str());
s->codeAppendf("%s[1] = %s[1].xy;",
fKLMDerivatives.c_str(), fKLMMatrix.c_str());
s->codeAppendf("%s[2] = %s[2].xy;",
fKLMDerivatives.c_str(), fKLMMatrix.c_str());
// Determine the amount of additional coverage to subtract out for the flat edge (P3 -> P0).
s->declareGlobal(fEdgeDistanceEquation);
s->codeAppendf("short edgeidx0 = %s > 0 ? 3 : 0;", wind);
@ -133,9 +124,9 @@ void GrCCPRCubicHullShader::onEmitSetupCode(GrGLSLShaderBuilder* s, const char*
void GrCCPRCubicHullShader::onEmitVaryings(GrGLSLVaryingHandler* varyingHandler, SkString* code) {
// "klm" was just defined by the base class.
varyingHandler->addVarying("grad_matrix", &fGradMatrix);
code->appendf("%s[0] = 3 * klm[0] * %s[0];", fGradMatrix.gsOut(), fKLMDerivatives.c_str());
code->appendf("%s[0] = 3 * klm[0] * %s[0].xy;", fGradMatrix.gsOut(), fKLMMatrix.c_str());
code->appendf("%s[1] = -klm[1] * %s[2].xy - klm[2] * %s[1].xy;",
fGradMatrix.gsOut(), fKLMDerivatives.c_str(), fKLMDerivatives.c_str());
fGradMatrix.gsOut(), fKLMMatrix.c_str(), fKLMMatrix.c_str());
}
void GrCCPRCubicHullShader::onEmitFragmentCode(GrGLSLPPFragmentBuilder* f,
@ -150,11 +141,6 @@ void GrCCPRCubicHullShader::onEmitFragmentCode(GrGLSLPPFragmentBuilder* f,
void GrCCPRCubicCornerShader::onEmitSetupCode(GrGLSLShaderBuilder* s, const char* pts,
const char* cornerId, GeometryVars* vars) const {
// TODO: remove in followup CL.
s->declareGlobal(fEdgeDistanceDerivatives);
s->codeAppendf("%s = %s.xy;",
fEdgeDistanceDerivatives.c_str(), fEdgeDistanceEquation.c_str());
s->codeAppendf("float2 corner = %s[%s * 3];", pts, cornerId);
vars->fCornerVars.fPoint = "corner";
}
@ -162,13 +148,13 @@ void GrCCPRCubicCornerShader::onEmitSetupCode(GrGLSLShaderBuilder* s, const char
void GrCCPRCubicCornerShader::onEmitVaryings(GrGLSLVaryingHandler* varyingHandler, SkString* code) {
varyingHandler->addFlatVarying("dklmddx", &fdKLMDdx);
code->appendf("%s = float4(%s[0].x, %s[1].x, %s[2].x, %s.x);",
fdKLMDdx.gsOut(), fKLMDerivatives.c_str(), fKLMDerivatives.c_str(),
fKLMDerivatives.c_str(), fEdgeDistanceDerivatives.c_str());
fdKLMDdx.gsOut(), fKLMMatrix.c_str(), fKLMMatrix.c_str(),
fKLMMatrix.c_str(), fEdgeDistanceEquation.c_str());
varyingHandler->addFlatVarying("dklmddy", &fdKLMDdy);
code->appendf("%s = float4(%s[0].y, %s[1].y, %s[2].y, %s.y);",
fdKLMDdy.gsOut(), fKLMDerivatives.c_str(), fKLMDerivatives.c_str(),
fKLMDerivatives.c_str(), fEdgeDistanceDerivatives.c_str());
fdKLMDdy.gsOut(), fKLMMatrix.c_str(), fKLMMatrix.c_str(),
fKLMMatrix.c_str(), fEdgeDistanceEquation.c_str());
}
void GrCCPRCubicCornerShader::onEmitFragmentCode(GrGLSLPPFragmentBuilder* f,

2
src/gpu/ccpr/GrCCPRCubicShader.h
View File

@ -52,7 +52,6 @@ protected:
const CubicType fCubicType;
GrShaderVar fKLMMatrix{"klm_matrix", kFloat3x3_GrSLType};
GrShaderVar fKLMDerivatives{"klm_derivatives", kFloat2_GrSLType, 3};
GrShaderVar fEdgeDistanceEquation{"edge_distance_equation", kFloat3_GrSLType};
GrGLSLGeoToFrag fKLMD{kFloat4_GrSLType};
};
@ -84,7 +83,6 @@ private:
void onEmitVaryings(GrGLSLVaryingHandler*, SkString* code) override;
void onEmitFragmentCode(GrGLSLPPFragmentBuilder*, const char* outputCoverage) const override;
GrShaderVar fEdgeDistanceDerivatives{"edge_distance_derivatives", kFloat2_GrSLType};
GrGLSLGeoToFrag fdKLMDdx{kFloat4_GrSLType};
GrGLSLGeoToFrag fdKLMDdy{kFloat4_GrSLType};
};

22
src/gpu/ccpr/GrCCPRQuadraticShader.cpp
View File

@ -45,11 +45,6 @@ void GrCCPRQuadraticShader::emitSetupCode(GrGLSLShaderBuilder* s, const char* pt
"%s[2], 1));",
fCanonicalMatrix.c_str(), pts, pts, pts);
// TODO: remove in followup CL.
s->declareGlobal(fCanonicalDerivatives);
s->codeAppendf("%s = float2x2(%s);",
fCanonicalDerivatives.c_str(), fCanonicalMatrix.c_str());
s->declareGlobal(fEdgeDistanceEquation);
s->codeAppendf("float2 edgept0 = %s[%s > 0 ? 2 : 0];", pts, wind);
s->codeAppendf("float2 edgept1 = %s[%s > 0 ? 0 : 2];", pts, wind);
@ -94,8 +89,8 @@ void GrCCPRQuadraticHullShader::onEmitSetupCode(GrGLSLShaderBuilder* s, const ch
void GrCCPRQuadraticHullShader::onEmitVaryings(GrGLSLVaryingHandler* varyingHandler,
SkString* code) {
varyingHandler->addVarying("grad", &fGrad);
code->appendf("%s = float2(2 * %s.x, -1) * %s;",
fGrad.gsOut(), fXYD.gsOut(), fCanonicalDerivatives.c_str());
code->appendf("%s = float2(2 * %s.x, -1) * float2x2(%s);",
fGrad.gsOut(), fXYD.gsOut(), fCanonicalMatrix.c_str());
}
void GrCCPRQuadraticHullShader::onEmitFragmentCode(GrGLSLPPFragmentBuilder* f,
@ -108,11 +103,6 @@ void GrCCPRQuadraticHullShader::onEmitFragmentCode(GrGLSLPPFragmentBuilder* f,
void GrCCPRQuadraticCornerShader::onEmitSetupCode(GrGLSLShaderBuilder* s, const char* pts,
const char* cornerId, GeometryVars* vars) const {
// TODO: remove in followup CL.
s->declareGlobal(fEdgeDistanceDerivatives);
s->codeAppendf("%s = %s.xy;",
fEdgeDistanceDerivatives.c_str(), fEdgeDistanceEquation.c_str());
s->codeAppendf("float2 corner = %s[%s * 2];", pts, cornerId);
vars->fCornerVars.fPoint = "corner";
}
@ -121,13 +111,13 @@ void GrCCPRQuadraticCornerShader::onEmitVaryings(GrGLSLVaryingHandler* varyingHa
SkString* code) {
varyingHandler->addFlatVarying("dXYDdx", &fdXYDdx);
code->appendf("%s = float3(%s[0].x, %s[0].y, %s.x);",
fdXYDdx.gsOut(), fCanonicalDerivatives.c_str(), fCanonicalDerivatives.c_str(),
fEdgeDistanceDerivatives.c_str());
fdXYDdx.gsOut(), fCanonicalMatrix.c_str(), fCanonicalMatrix.c_str(),
fEdgeDistanceEquation.c_str());
varyingHandler->addFlatVarying("dXYDdy", &fdXYDdy);
code->appendf("%s = float3(%s[1].x, %s[1].y, %s.y);",
fdXYDdy.gsOut(), fCanonicalDerivatives.c_str(), fCanonicalDerivatives.c_str(),
fEdgeDistanceDerivatives.c_str());
fdXYDdy.gsOut(), fCanonicalMatrix.c_str(), fCanonicalMatrix.c_str(),
fEdgeDistanceEquation.c_str());
}
void GrCCPRQuadraticCornerShader::onEmitFragmentCode(GrGLSLPPFragmentBuilder* f,

2
src/gpu/ccpr/GrCCPRQuadraticShader.h
View File

@ -42,7 +42,6 @@ protected:
virtual void onEmitVaryings(GrGLSLVaryingHandler*, SkString* code) = 0;
const GrShaderVar fCanonicalMatrix{"canonical_matrix", kFloat3x3_GrSLType};
const GrShaderVar fCanonicalDerivatives{"canonical_derivatives", kFloat2x2_GrSLType};
const GrShaderVar fEdgeDistanceEquation{"edge_distance_equation", kFloat3_GrSLType};
GrGLSLGeoToFrag fXYD{kFloat3_GrSLType};
};
@ -77,7 +76,6 @@ class GrCCPRQuadraticCornerShader : public GrCCPRQuadraticShader {
void onEmitVaryings(GrGLSLVaryingHandler*, SkString* code) override;
void onEmitFragmentCode(GrGLSLPPFragmentBuilder*, const char* outputCoverage) const override;
const GrShaderVar fEdgeDistanceDerivatives{"edge_distance_derivatives", kFloat2_GrSLType};
GrGLSLGeoToFrag fdXYDdx{kFloat3_GrSLType};
GrGLSLGeoToFrag fdXYDdy{kFloat3_GrSLType};
};

4
src/gpu/ccpr/GrCCPRTriangleShader.cpp
View File

@ -91,11 +91,7 @@ void GrCCPRTriangleCornerShader::emitSetupCode(GrGLSLShaderBuilder* s, const cha
s->codeAppendf( "%s[i][0] = -dot(n, corner) + .5;", fAABoxTranslates.c_str());
// The Y component runs perpendicular to the edge (i.e. distance-to-edge).
// NOTE: if we are back in device space and bloat.x == bloat.y, we will not need to find and
// divide by nwidth a second time.
s->codeAppend ( "n = (i == 0) ? float2(-n.y, n.x) : float2(n.y, -n.x);");
s->codeAppend ( "nwidth = (abs(n.x) + abs(n.y)) * (bloat * 2);");
s->codeAppend ( "n /= nwidth;");
s->codeAppendf( "%s[i][1] = n;", fAABoxMatrices.c_str());
s->codeAppendf( "%s[i][1] = -dot(n, corner) + .5;", fAABoxTranslates.c_str());