void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override { const DefaultGeoProc& gp = args.fGP.cast<DefaultGeoProc>(); GrGLSLVertexBuilder* vertBuilder = args.fVertBuilder; GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder; GrGLSLVaryingHandler* varyingHandler = args.fVaryingHandler; GrGLSLUniformHandler* uniformHandler = args.fUniformHandler; // emit attributes varyingHandler->emitAttributes(gp); // Setup pass through color if (gp.hasVertexColor()) { GrGLSLVarying varying(kHalf4_GrSLType); varyingHandler->addVarying("color", &varying); // There are several optional steps to process the color. Start with the attribute: vertBuilder->codeAppendf("half4 color = %s;", gp.inColor()->fName); // Linearize if (gp.linearizeColor()) { SkString srgbFuncName; static const GrShaderVar gSrgbArgs[] = { GrShaderVar("x", kHalf_GrSLType), }; vertBuilder->emitFunction(kHalf_GrSLType, "srgb_to_linear", SK_ARRAY_COUNT(gSrgbArgs), gSrgbArgs, "return (x <= 0.04045) ? (x / 12.92) " ": pow((x + 0.055) / 1.055, 2.4);", &srgbFuncName); vertBuilder->codeAppendf("color = half4(%s(%s.r), %s(%s.g), %s(%s.b), %s.a);", srgbFuncName.c_str(), gp.inColor()->fName, srgbFuncName.c_str(), gp.inColor()->fName, srgbFuncName.c_str(), gp.inColor()->fName, gp.inColor()->fName); } // For SkColor, do a red/blue swap and premul if (gp.fFlags & kColorAttributeIsSkColor_GPFlag) { vertBuilder->codeAppend("color = half4(color.a * color.bgr, color.a);"); } // Do color-correction to destination gamut if (gp.linearizeColor()) { fColorSpaceHelper.emitCode(uniformHandler, gp.fColorSpaceXform.get(), kVertex_GrShaderFlag); if (fColorSpaceHelper.isValid()) { SkString xformedColor; vertBuilder->appendColorGamutXform(&xformedColor, "color", &fColorSpaceHelper); vertBuilder->codeAppendf("color = %s;", xformedColor.c_str()); } } vertBuilder->codeAppendf("%s = color;\n", varying.vsOut()); fragBuilder->codeAppendf("%s = %s;", args.fOutputColor, varying.fsIn()); } else { this->setupUniformColor(fragBuilder, uniformHandler, args.fOutputColor, &fColorUniform); } // Setup position this->writeOutputPosition(vertBuilder, uniformHandler, gpArgs, gp.inPosition()->fName, gp.viewMatrix(), &fViewMatrixUniform); if (gp.hasExplicitLocalCoords()) { // emit transforms with explicit local coords this->emitTransforms(vertBuilder, varyingHandler, uniformHandler, gp.inLocalCoords()->asShaderVar(), gp.localMatrix(), args.fFPCoordTransformHandler); } else { // emit transforms with position this->emitTransforms(vertBuilder, varyingHandler, uniformHandler, gp.inPosition()->asShaderVar(), gp.localMatrix(), args.fFPCoordTransformHandler); } // Setup coverage as pass through if (gp.hasVertexCoverage()) { fragBuilder->codeAppendf("half alpha = 1.0;"); varyingHandler->addPassThroughAttribute(gp.inCoverage(), "alpha"); fragBuilder->codeAppendf("%s = half4(alpha);", args.fOutputCoverage); } else if (gp.coverage() == 0xff) { fragBuilder->codeAppendf("%s = half4(1);", args.fOutputCoverage); } else { const char* fragCoverage; fCoverageUniform = uniformHandler->addUniform(kFragment_GrShaderFlag, kHalf_GrSLType, "Coverage", &fragCoverage); fragBuilder->codeAppendf("%s = half4(%s);", args.fOutputCoverage, fragCoverage); } }
void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override { const auto& proc = args.fGP.cast<Processor>(); bool useHWDerivatives = (proc.fFlags & Flags::kUseHWDerivatives); bool hasPerspective = (proc.fFlags & Flags::kHasPerspective); bool hasLocalCoords = (proc.fFlags & Flags::kHasLocalCoords); SkASSERT(useHWDerivatives == hasPerspective); SkASSERT(proc.vertexStride() == sizeof(MSAAVertex)); // Emit the vertex shader. GrGLSLVertexBuilder* v = args.fVertBuilder; GrGLSLVaryingHandler* varyings = args.fVaryingHandler; varyings->emitAttributes(proc); varyings->addPassThroughAttribute(*proc.fColorAttrib, args.fOutputColor, GrGLSLVaryingHandler::Interpolation::kCanBeFlat); // Unpack vertex attribs. v->codeAppendf("float2 corner = corner_and_radius_outsets.xy;"); v->codeAppendf("float2 radius_outset = corner_and_radius_outsets.zw;"); // Identify our radii. v->codeAppend("float2 radii;"); v->codeAppend("radii.x = dot(radii_selector, radii_x);"); v->codeAppend("radii.y = dot(radii_selector, radii_y);"); v->codeAppendf("bool is_arc_section = (radii.x > 0);"); v->codeAppendf("radii = abs(radii);"); // Find our vertex position, adjusted for radii. Our rect is drawn in normalized // [-1,-1,+1,+1] space. v->codeAppend("float2 vertexpos = corner + radius_outset * radii;"); // Emit transforms. GrShaderVar localCoord("", kFloat2_GrSLType); if (hasLocalCoords) { v->codeAppend("float2 localcoord = (local_rect.xy * (1 - vertexpos) + " "local_rect.zw * (1 + vertexpos)) * .5;"); localCoord.set(kFloat2_GrSLType, "localcoord"); } this->emitTransforms(v, varyings, args.fUniformHandler, localCoord, args.fFPCoordTransformHandler); // Transform to device space. if (!hasPerspective) { v->codeAppend("float2x2 skewmatrix = float2x2(skew.xy, skew.zw);"); v->codeAppend("float2 devcoord = vertexpos * skewmatrix + translate;"); gpArgs->fPositionVar.set(kFloat2_GrSLType, "devcoord"); } else { v->codeAppend("float3x3 persp_matrix = float3x3(persp_x, persp_y, persp_z);"); v->codeAppend("float3 devcoord = float3(vertexpos, 1) * persp_matrix;"); gpArgs->fPositionVar.set(kFloat3_GrSLType, "devcoord"); } // Determine normalized arc coordinates for the implicit function. GrGLSLVarying arcCoord((useHWDerivatives) ? kFloat2_GrSLType : kFloat4_GrSLType); varyings->addVarying("arccoord", &arcCoord); v->codeAppendf("if (is_arc_section) {"); v->codeAppendf( "%s.xy = 1 - abs(radius_outset);", arcCoord.vsOut()); if (!useHWDerivatives) { // The gradient is order-1: Interpolate it across arccoord.zw. // This doesn't work with perspective. SkASSERT(!hasPerspective); v->codeAppendf("float2x2 derivatives = inverse(skewmatrix);"); v->codeAppendf("%s.zw = derivatives * (%s.xy/radii * corner * 2);", arcCoord.vsOut(), arcCoord.vsOut()); } v->codeAppendf("} else {"); if (useHWDerivatives) { v->codeAppendf("%s = float2(0);", arcCoord.vsOut()); } else { v->codeAppendf("%s = float4(0);", arcCoord.vsOut()); } v->codeAppendf("}"); // Emit the fragment shader. GrGLSLFPFragmentBuilder* f = args.fFragBuilder; f->codeAppendf("%s = half4(1);", args.fOutputCoverage); // If x,y == 0, then we are drawing a triangle that does not track an arc. f->codeAppendf("if (float2(0) != %s.xy) {", arcCoord.fsIn()); f->codeAppendf( "float fn = dot(%s.xy, %s.xy) - 1;", arcCoord.fsIn(), arcCoord.fsIn()); if (GrAAType::kMSAA == proc.fAAType) { using ScopeFlags = GrGLSLFPFragmentBuilder::ScopeFlags; if (!useHWDerivatives) { f->codeAppendf("float2 grad = %s.zw;", arcCoord.fsIn()); f->applyFnToMultisampleMask("fn", "grad", ScopeFlags::kInsidePerPrimitiveBranch); } else { f->applyFnToMultisampleMask("fn", nullptr, ScopeFlags::kInsidePerPrimitiveBranch); } } else { f->codeAppendf("if (fn > 0) {"); f->codeAppendf( "%s = half4(0);", args.fOutputCoverage); f->codeAppendf("}"); } f->codeAppendf("}"); }
void GLSLPathProcessor::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) { using InstanceAttribs = GrCCPRPathProcessor::InstanceAttribs; const GrCCPRPathProcessor& proc = args.fGP.cast<GrCCPRPathProcessor>(); GrGLSLUniformHandler* uniHandler = args.fUniformHandler; GrGLSLVaryingHandler* varyingHandler = args.fVaryingHandler; const char* atlasAdjust; fAtlasAdjustUniform = uniHandler->addUniform( kVertex_GrShaderFlag, kVec2f_GrSLType, kHigh_GrSLPrecision, "atlas_adjust", &atlasAdjust); varyingHandler->emitAttributes(proc); GrGLSLVertToFrag texcoord(kVec2f_GrSLType); GrGLSLVertToFrag color(kVec4f_GrSLType); varyingHandler->addVarying("texcoord", &texcoord, kHigh_GrSLPrecision); varyingHandler->addFlatPassThroughAttribute(&proc.getInstanceAttrib(InstanceAttribs::kColor), args.fOutputColor, kLow_GrSLPrecision); // Vertex shader. GrGLSLVertexBuilder* v = args.fVertBuilder; // Find the intersections of (bloated) devBounds and devBounds45 in order to come up with an // octagon that circumscribes the (bloated) path. A vertex is the intersection of two lines: // one edge from the path's bounding box and one edge from its 45-degree bounding box. v->codeAppendf("highp mat2 N = mat2(%s);", proc.getEdgeNormsAttrib().fName); // N[0] is the normal for the edge we are intersecting from the regular bounding box, pointing // out of the octagon. v->codeAppendf("highp vec2 refpt = (min(N[0].x, N[0].y) < 0) ? %s.xy : %s.zw;", proc.getInstanceAttrib(InstanceAttribs::kDevBounds).fName, proc.getInstanceAttrib(InstanceAttribs::kDevBounds).fName); v->codeAppendf("refpt += N[0] * %f;", kAABloatRadius); // bloat for AA. // N[1] is the normal for the edge we are intersecting from the 45-degree bounding box, pointing // out of the octagon. v->codeAppendf("highp vec2 refpt45 = (N[1].x < 0) ? %s.xy : %s.zw;", proc.getInstanceAttrib(InstanceAttribs::kDevBounds45).fName, proc.getInstanceAttrib(InstanceAttribs::kDevBounds45).fName); v->codeAppendf("refpt45 *= mat2(.5,.5,-.5,.5);"); // transform back to device space. v->codeAppendf("refpt45 += N[1] * %f;", kAABloatRadius); // bloat for AA. v->codeAppend ("highp vec2 K = vec2(dot(N[0], refpt), dot(N[1], refpt45));"); v->codeAppendf("highp vec2 octocoord = K * inverse(N);"); gpArgs->fPositionVar.set(kVec2f_GrSLType, "octocoord"); // Convert to atlas coordinates in order to do our texture lookup. v->codeAppendf("highp vec2 atlascoord = octocoord + vec2(%s);", proc.getInstanceAttrib(InstanceAttribs::kAtlasOffset).fName); if (kTopLeft_GrSurfaceOrigin == proc.atlas()->origin()) { v->codeAppendf("%s = atlascoord * %s;", texcoord.vsOut(), atlasAdjust); } else { SkASSERT(kBottomLeft_GrSurfaceOrigin == proc.atlas()->origin()); v->codeAppendf("%s = vec2(atlascoord.x * %s.x, 1 - atlascoord.y * %s.y);", texcoord.vsOut(), atlasAdjust, atlasAdjust); } // Convert to (local) path cordinates. v->codeAppendf("highp vec2 pathcoord = inverse(mat2(%s)) * (octocoord - %s);", proc.getInstanceAttrib(InstanceAttribs::kViewMatrix).fName, proc.getInstanceAttrib(InstanceAttribs::kViewTranslate).fName); this->emitTransforms(v, varyingHandler, uniHandler, gpArgs->fPositionVar, "pathcoord", args.fFPCoordTransformHandler); // Fragment shader. GrGLSLPPFragmentBuilder* f = args.fFragBuilder; f->codeAppend ("mediump float coverage_count = "); f->appendTextureLookup(args.fTexSamplers[0], texcoord.fsIn(), kVec2f_GrSLType); f->codeAppend (".a;"); if (SkPath::kWinding_FillType == proc.fillType()) { f->codeAppendf("%s = vec4(min(abs(coverage_count), 1));", args.fOutputCoverage); } else { SkASSERT(SkPath::kEvenOdd_FillType == proc.fillType()); f->codeAppend ("mediump float t = mod(abs(coverage_count), 2);"); f->codeAppendf("%s = vec4(1 - abs(t - 1));", args.fOutputCoverage); } }
void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override { const auto& proc = args.fGP.cast<Processor>(); bool useHWDerivatives = (proc.fFlags & Flags::kUseHWDerivatives); SkASSERT(proc.vertexStride() == sizeof(CoverageVertex)); GrGLSLVaryingHandler* varyings = args.fVaryingHandler; varyings->emitAttributes(proc); varyings->addPassThroughAttribute(*proc.fColorAttrib, args.fOutputColor, GrGLSLVaryingHandler::Interpolation::kCanBeFlat); // Emit the vertex shader. GrGLSLVertexBuilder* v = args.fVertBuilder; // Unpack vertex attribs. v->codeAppend("float2 corner = corner_and_radius_outsets.xy;"); v->codeAppend("float2 radius_outset = corner_and_radius_outsets.zw;"); v->codeAppend("float2 aa_bloat_direction = aa_bloat_and_coverage.xy;"); v->codeAppend("float coverage = aa_bloat_and_coverage.z;"); v->codeAppend("float is_linear_coverage = aa_bloat_and_coverage.w;"); // Find the amount to bloat each edge for AA (in source space). v->codeAppend("float2 pixellength = inversesqrt(" "float2(dot(skew.xz, skew.xz), dot(skew.yw, skew.yw)));"); v->codeAppend("float4 normalized_axis_dirs = skew * pixellength.xyxy;"); v->codeAppend("float2 axiswidths = (abs(normalized_axis_dirs.xy) + " "abs(normalized_axis_dirs.zw));"); v->codeAppend("float2 aa_bloatradius = axiswidths * pixellength * .5;"); // Identify our radii. v->codeAppend("float4 radii_and_neighbors = radii_selector" "* float4x4(radii_x, radii_y, radii_x.yxwz, radii_y.wzyx);"); v->codeAppend("float2 radii = radii_and_neighbors.xy;"); v->codeAppend("float2 neighbor_radii = radii_and_neighbors.zw;"); v->codeAppend("if (any(greaterThan(aa_bloatradius, float2(1)))) {"); // The rrect is more narrow than an AA coverage ramp. We can't draw as-is // or else opposite AA borders will overlap. Instead, fudge the size up to // the width of a coverage ramp, and then reduce total coverage to make // the rect appear more thin. v->codeAppend( "corner = max(abs(corner), aa_bloatradius) * sign(corner);"); v->codeAppend( "coverage /= max(aa_bloatradius.x, 1) * max(aa_bloatradius.y, 1);"); // Set radii to zero to ensure we take the "linear coverage" codepath. // (The "coverage" variable only has effect in the linear codepath.) v->codeAppend( "radii = float2(0);"); v->codeAppend("}"); v->codeAppend("if (any(lessThan(radii, aa_bloatradius * 1.25))) {"); // The radii are very small. Demote this arc to a sharp 90 degree corner. v->codeAppend( "radii = aa_bloatradius;"); // Snap octagon vertices to the corner of the bounding box. v->codeAppend( "radius_outset = floor(abs(radius_outset)) * radius_outset;"); v->codeAppend( "is_linear_coverage = 1;"); v->codeAppend("} else {"); // Don't let radii get smaller than a pixel. v->codeAppend( "radii = clamp(radii, pixellength, 2 - pixellength);"); v->codeAppend( "neighbor_radii = clamp(neighbor_radii, pixellength, 2 - pixellength);"); // Don't let neighboring radii get closer together than 1/16 pixel. v->codeAppend( "float2 spacing = 2 - radii - neighbor_radii;"); v->codeAppend( "float2 extra_pad = max(pixellength * .0625 - spacing, float2(0));"); v->codeAppend( "radii -= extra_pad * .5;"); v->codeAppend("}"); // Find our vertex position, adjusted for radii and bloated for AA. Our rect is drawn in // normalized [-1,-1,+1,+1] space. v->codeAppend("float2 aa_outset = aa_bloat_direction.xy * aa_bloatradius;"); v->codeAppend("float2 vertexpos = corner + radius_outset * radii + aa_outset;"); // Emit transforms. GrShaderVar localCoord("", kFloat2_GrSLType); if (proc.fFlags & Flags::kHasLocalCoords) { v->codeAppend("float2 localcoord = (local_rect.xy * (1 - vertexpos) + " "local_rect.zw * (1 + vertexpos)) * .5;"); localCoord.set(kFloat2_GrSLType, "localcoord"); } this->emitTransforms(v, varyings, args.fUniformHandler, localCoord, args.fFPCoordTransformHandler); // Transform to device space. SkASSERT(!(proc.fFlags & Flags::kHasPerspective)); v->codeAppend("float2x2 skewmatrix = float2x2(skew.xy, skew.zw);"); v->codeAppend("float2 devcoord = vertexpos * skewmatrix + translate;"); gpArgs->fPositionVar.set(kFloat2_GrSLType, "devcoord"); // Setup interpolants for coverage. GrGLSLVarying arcCoord(useHWDerivatives ? kFloat2_GrSLType : kFloat4_GrSLType); varyings->addVarying("arccoord", &arcCoord); v->codeAppend("if (0 != is_linear_coverage) {"); // We are a non-corner piece: Set x=0 to indicate built-in coverage, and // interpolate linear coverage across y. v->codeAppendf( "%s.xy = float2(0, coverage);", arcCoord.vsOut()); v->codeAppend("} else {"); // Find the normalized arc coordinates for our corner ellipse. // (i.e., the coordinate system where x^2 + y^2 == 1). v->codeAppend( "float2 arccoord = 1 - abs(radius_outset) + aa_outset/radii * corner;"); // We are a corner piece: Interpolate the arc coordinates for coverage. // Emit x+1 to ensure no pixel in the arc has a x value of 0 (since x=0 // instructs the fragment shader to use linear coverage). v->codeAppendf( "%s.xy = float2(arccoord.x+1, arccoord.y);", arcCoord.vsOut()); if (!useHWDerivatives) { // The gradient is order-1: Interpolate it across arccoord.zw. v->codeAppendf("float2x2 derivatives = inverse(skewmatrix);"); v->codeAppendf("%s.zw = derivatives * (arccoord/radii * 2);", arcCoord.vsOut()); } v->codeAppend("}"); // Emit the fragment shader. GrGLSLFPFragmentBuilder* f = args.fFragBuilder; f->codeAppendf("float x_plus_1=%s.x, y=%s.y;", arcCoord.fsIn(), arcCoord.fsIn()); f->codeAppendf("half coverage;"); f->codeAppendf("if (0 == x_plus_1) {"); f->codeAppendf( "coverage = half(y);"); // We are a non-arc pixel (linear coverage). f->codeAppendf("} else {"); f->codeAppendf( "float fn = x_plus_1 * (x_plus_1 - 2);"); // fn = (x+1)*(x-1) = x^2-1 f->codeAppendf( "fn = fma(y,y, fn);"); // fn = x^2 + y^2 - 1 if (useHWDerivatives) { f->codeAppendf("float fnwidth = fwidth(fn);"); } else { // The gradient is interpolated across arccoord.zw. f->codeAppendf("float gx=%s.z, gy=%s.w;", arcCoord.fsIn(), arcCoord.fsIn()); f->codeAppendf("float fnwidth = abs(gx) + abs(gy);"); } f->codeAppendf( "half d = half(fn/fnwidth);"); f->codeAppendf( "coverage = clamp(.5 - d, 0, 1);"); f->codeAppendf("}"); f->codeAppendf("%s = half4(coverage);", args.fOutputCoverage); }