void GrCCTriangleShader::onEmitVaryings(GrGLSLVaryingHandler* varyingHandler,
GrGLSLVarying::Scope scope, SkString* code,
const char* /*position*/, const char* inputCoverage,
const char* wind) {
fCoverageTimesWind.reset(kHalf_GrSLType, scope);
if (!inputCoverage) {
varyingHandler->addVarying("wind", &fCoverageTimesWind,
GrGLSLVaryingHandler::Interpolation::kCanBeFlat);
code->appendf("%s = %s;", OutName(fCoverageTimesWind), wind);
} else {
varyingHandler->addVarying("coverage_times_wind", &fCoverageTimesWind);
code->appendf("%s = %s * %s;", OutName(fCoverageTimesWind), inputCoverage, wind);
}
}
void GrCCCubicShader::onEmitVaryings(
GrGLSLVaryingHandler* varyingHandler, GrGLSLVarying::Scope scope, SkString* code,
const char* position, const char* coverage, const char* cornerCoverage, const char* wind) {
code->appendf("float3 klm = float3(%s, 1) * %s;", position, fKLMMatrix.c_str());
fKLM_fEdge.reset(kFloat4_GrSLType, scope);
varyingHandler->addVarying("klm_and_edge", &fKLM_fEdge);
// Give L&M both the same sign as wind, in order to pass this value to the fragment shader.
// (Cubics are pre-chopped such that L&M do not change sign within any individual segment.)
code->appendf("%s.xyz = klm * float3(1, %s, %s);", OutName(fKLM_fEdge), wind, wind);
// Flat edge opposite the curve.
code->appendf("%s.w = %s;", OutName(fKLM_fEdge), coverage);
fGradMatrix.reset(kFloat4_GrSLType, scope);
varyingHandler->addVarying("grad_matrix", &fGradMatrix);
code->appendf("%s.xy = 2*bloat * 3 * klm[0] * %s[0].xy;",
OutName(fGradMatrix), fKLMMatrix.c_str());
code->appendf("%s.zw = -2*bloat * (klm[1] * %s[2].xy + klm[2] * %s[1].xy);",
OutName(fGradMatrix), fKLMMatrix.c_str(), fKLMMatrix.c_str());
if (cornerCoverage) {
SkASSERT(coverage);
code->appendf("half hull_coverage; {");
this->calcHullCoverage(code, OutName(fKLM_fEdge), OutName(fGradMatrix), "hull_coverage");
code->appendf("}");
fCornerCoverage.reset(kHalf2_GrSLType, scope);
varyingHandler->addVarying("corner_coverage", &fCornerCoverage);
code->appendf("%s = half2(hull_coverage, 1) * %s;",
OutName(fCornerCoverage), cornerCoverage);
}
}
void GrCCConicShader::onEmitVaryings(
GrGLSLVaryingHandler* varyingHandler, GrGLSLVarying::Scope scope, SkString* code,
const char* position, const char* coverage, const char* cornerCoverage, const char* wind) {
code->appendf("float3 klm = float3(%s - %s, 1) * %s;",
position, fControlPoint.c_str(), fKLMMatrix.c_str());
fKLM_fWind.reset(kFloat4_GrSLType, scope);
varyingHandler->addVarying("klm_and_wind", &fKLM_fWind);
code->appendf("%s.xyz = klm;", OutName(fKLM_fWind));
code->appendf("%s.w = %s;", OutName(fKLM_fWind), wind);
fGrad_fCorner.reset(cornerCoverage ? kFloat4_GrSLType : kFloat2_GrSLType, scope);
varyingHandler->addVarying(cornerCoverage ? "grad_and_corner" : "grad", &fGrad_fCorner);
code->appendf("%s.xy = 2*bloat * (float3x2(%s) * float3(2*klm[0], -klm[2], -klm[1]));",
OutName(fGrad_fCorner), fKLMMatrix.c_str());
if (cornerCoverage) {
SkASSERT(coverage);
code->appendf("half hull_coverage;");
this->calcHullCoverage(code, "klm", OutName(fGrad_fCorner), "hull_coverage");
code->appendf("%s.zw = half2(hull_coverage, 1) * %s;",
OutName(fGrad_fCorner), cornerCoverage);
}
}
void GrCCTriangleCornerShader::onEmitVaryings(GrGLSLVaryingHandler* varyingHandler,
GrGLSLVarying::Scope scope, SkString* code,
const char* position, const char* inputCoverage,
const char* wind) {
using Interpolation = GrGLSLVaryingHandler::Interpolation;
SkASSERT(!inputCoverage);
fCornerLocationInAABoxes.reset(kFloat2x2_GrSLType, scope);
varyingHandler->addVarying("corner_location_in_aa_boxes", &fCornerLocationInAABoxes);
fBisectInAABoxes.reset(kFloat2x2_GrSLType, scope);
varyingHandler->addVarying("bisect_in_aa_boxes", &fBisectInAABoxes, Interpolation::kCanBeFlat);
code->appendf("for (int i = 0; i < 2; ++i) {");
code->appendf( "%s[i] = %s * %s[i] + %s[i];",
OutName(fCornerLocationInAABoxes), position, fAABoxMatrices.c_str(),
fAABoxTranslates.c_str());
code->appendf( "%s[i] = %s[i];", OutName(fBisectInAABoxes), fGeoShaderBisects.c_str());
code->appendf("}");
fWindTimesHalf.reset(kHalf_GrSLType, scope);
varyingHandler->addVarying("wind_times_half", &fWindTimesHalf, Interpolation::kCanBeFlat);
code->appendf("%s = %s * .5;", OutName(fWindTimesHalf), wind);
}
void GrCCQuadraticShader::onEmitVaryings(
GrGLSLVaryingHandler* varyingHandler, GrGLSLVarying::Scope scope, SkString* code,
const char* position, const char* coverage, const char* cornerCoverage, const char* wind) {
fCoord_fGrad.reset(kFloat4_GrSLType, scope);
varyingHandler->addVarying("coord_and_grad", &fCoord_fGrad);
code->appendf("%s.xy = %s * (%s - %s);", // Quadratic coords.
OutName(fCoord_fGrad), fQCoordMatrix.c_str(), position, fQCoord0.c_str());
code->appendf("%s.zw = 2*bloat * float2(2 * %s.x, -1) * %s;", // Gradient.
OutName(fCoord_fGrad), OutName(fCoord_fGrad), fQCoordMatrix.c_str());
// Coverages need full precision since distance to the opposite edge can be large.
fEdge_fWind_fCorner.reset(cornerCoverage ? kFloat4_GrSLType : kFloat2_GrSLType, scope);
varyingHandler->addVarying("edge_and_wind_and_corner", &fEdge_fWind_fCorner);
code->appendf("%s.x = %s;", OutName(fEdge_fWind_fCorner), coverage);
code->appendf("%s.y = %s;", OutName(fEdge_fWind_fCorner), wind);
if (cornerCoverage) {
SkASSERT(coverage);
code->appendf("half hull_coverage;");
this->calcHullCoverage(code, OutName(fCoord_fGrad), coverage, "hull_coverage");
code->appendf("%s.zw = half2(hull_coverage, 1) * %s;",
OutName(fEdge_fWind_fCorner), cornerCoverage);
}
}
