/*
 * Copyright 2018 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

#include "GrQuadPerEdgeAA.h"
#include "GrQuad.h"
#include "GrVertexWriter.h"
#include "glsl/GrGLSLColorSpaceXformHelper.h"
#include "glsl/GrGLSLPrimitiveProcessor.h"
#include "glsl/GrGLSLFragmentShaderBuilder.h"
#include "glsl/GrGLSLVarying.h"
#include "glsl/GrGLSLVertexGeoBuilder.h"
#include "SkNx.h"

#define AI SK_ALWAYS_INLINE

namespace {

static AI Sk4f fma(const Sk4f& f, const Sk4f& m, const Sk4f& a) {
    return SkNx_fma<4, float>(f, m, a);
}

// These rotate the points/edge values either clockwise or counterclockwise assuming tri strip
// order.
static AI Sk4f nextCW(const Sk4f& v) {
    return SkNx_shuffle<2, 0, 3, 1>(v);
}

static AI Sk4f nextCCW(const Sk4f& v) {
    return SkNx_shuffle<1, 3, 0, 2>(v);
}

// Fills Sk4f with 1f if edge bit is set, 0f otherwise. Edges are ordered LBTR to match CCW ordering
// of vertices in the quad.
static AI Sk4f compute_edge_mask(GrQuadAAFlags aaFlags) {
    return Sk4f((GrQuadAAFlags::kLeft & aaFlags) ? 1.f : 0.f,
                (GrQuadAAFlags::kBottom & aaFlags) ? 1.f : 0.f,
                (GrQuadAAFlags::kTop & aaFlags) ? 1.f : 0.f,
                (GrQuadAAFlags::kRight & aaFlags) ? 1.f : 0.f);
}

static AI void outset_masked_vertices(const Sk4f& xdiff, const Sk4f& ydiff, const Sk4f& invLengths,
                                      const Sk4f& mask, Sk4f* x, Sk4f* y, Sk4f* u, Sk4f* v, Sk4f* r,
                                      int uvrCount) {
    auto halfMask = 0.5f * mask;
    auto maskCW = nextCW(halfMask);
    *x += maskCW * -xdiff + halfMask * nextCW(xdiff);
    *y += maskCW * -ydiff + halfMask * nextCW(ydiff);
    if (uvrCount > 0) {
        // We want to extend the texture coords by the same proportion as the positions.
        maskCW *= invLengths;
        halfMask *= nextCW(invLengths);
        Sk4f udiff = nextCCW(*u) - *u;
        Sk4f vdiff = nextCCW(*v) - *v;
        *u += maskCW * -udiff + halfMask * nextCW(udiff);
        *v += maskCW * -vdiff + halfMask * nextCW(vdiff);
        if (uvrCount == 3) {
            Sk4f rdiff = nextCCW(*r) - *r;
            *r += maskCW * -rdiff + halfMask * nextCW(rdiff);
        }
    }
}

static AI void outset_vertices(const Sk4f& xdiff, const Sk4f& ydiff, const Sk4f& invLengths,
                               Sk4f* x, Sk4f* y, Sk4f* u, Sk4f* v, Sk4f* r, int uvrCount) {
    *x += 0.5f * (-xdiff + nextCW(xdiff));
    *y += 0.5f * (-ydiff + nextCW(ydiff));
    if (uvrCount > 0) {
        Sk4f t = 0.5f * invLengths;
        Sk4f udiff = nextCCW(*u) - *u;
        Sk4f vdiff = nextCCW(*v) - *v;
        *u += t * -udiff + nextCW(t) * nextCW(udiff);
        *v += t * -vdiff + nextCW(t) * nextCW(vdiff);
        if (uvrCount == 3) {
            Sk4f rdiff = nextCCW(*r) - *r;
            *r += t * -rdiff + nextCW(t) * nextCW(rdiff);
        }
    }
}

static AI void compute_edge_distances(const Sk4f& a, const Sk4f& b, const Sk4f& c, const Sk4f& x,
                                      const Sk4f& y, const Sk4f& w, Sk4f edgeDistances[]) {
    for (int i = 0; i < 4; ++i) {
        edgeDistances[i] = a * x[i] + b * y[i] + c * w[i];
    }
}

// This computes the four edge equations for a quad, then outsets them and optionally computes a new
// quad as the intersection points of the outset edges. 'x' and 'y' contain the original points as
// input and the outset points as output. In order to be used as a component of perspective edge
// distance calculation, this exports edge equations in 'a', 'b', and 'c'. Use
// compute_edge_distances to turn these equations into the distances needed by the shader. The
// values in x, y, u, v, and r are possibly updated if outsetting is needed. r is the local
// position's w component if it exists.
static void compute_quad_edges_and_outset_vertices(GrQuadAAFlags aaFlags, Sk4f* x, Sk4f* y,
        Sk4f* a, Sk4f* b, Sk4f* c, Sk4f* u, Sk4f* v, Sk4f* r, int uvrChannelCount, bool outset) {
    SkASSERT(uvrChannelCount == 0 || uvrChannelCount == 2 || uvrChannelCount == 3);

    // Compute edge vectors for the quad.
    auto xnext = nextCCW(*x);
    auto ynext = nextCCW(*y);
    // xdiff and ydiff will comprise the normalized vectors pointing along each quad edge.
    auto xdiff = xnext - *x;
    auto ydiff = ynext - *y;
    auto invLengths = fma(xdiff, xdiff, ydiff * ydiff).rsqrt();
    xdiff *= invLengths;
    ydiff *= invLengths;

    // Use above vectors to compute edge equations (importantly before we outset positions).
    *c = fma(xnext, *y,  -ynext * *x) * invLengths;
    // Make sure the edge equations have their normals facing into the quad in device space.
    auto test = fma(ydiff, nextCW(*x), fma(-xdiff, nextCW(*y), *c));
    if ((test < Sk4f(0)).anyTrue()) {
        *a = -ydiff;
        *b = xdiff;
        *c = -*c;
    } else {
        *a = ydiff;
        *b = -xdiff;
    }
    // Outset the edge equations so aa coverage evaluates to zero half a pixel away from the
    // original quad edge.
    *c += 0.5f;

    if (aaFlags != GrQuadAAFlags::kAll) {
        // This order is the same order the edges appear in xdiff/ydiff and therefore as the
        // edges in a/b/c.
        Sk4f mask = compute_edge_mask(aaFlags);

        // Outset edge equations for masked out edges another pixel so that they always evaluate
        // >= 1.
        *c += (1.f - mask);
        if (outset) {
            outset_masked_vertices(xdiff, ydiff, invLengths, mask, x, y, u, v, r, uvrChannelCount);
        }
    } else if (outset) {
        outset_vertices(xdiff, ydiff, invLengths, x, y, u, v, r, uvrChannelCount);
    }
}

// A specialization of the above function that can compute edge distances very quickly when it knows
// that the edges intersect at right angles, i.e. any transform other than skew and perspective
// (GrQuadType::kRectilinear). Unlike the above function, this always outsets the corners since it
// cannot be reused in the perspective case.
static void compute_rectilinear_dists_and_outset_vertices(GrQuadAAFlags aaFlags, Sk4f* x,
        Sk4f* y,  Sk4f edgeDistances[4], Sk4f* u, Sk4f* v, Sk4f* r, int uvrChannelCount) {
    SkASSERT(uvrChannelCount == 0 || uvrChannelCount == 2 || uvrChannelCount == 3);
    auto xnext = nextCCW(*x);
    auto ynext = nextCCW(*y);
    // xdiff and ydiff will comprise the normalized vectors pointing along each quad edge.
    auto xdiff = xnext - *x;
    auto ydiff = ynext - *y;
    // Need length and 1/length in this variant
    auto lengths = fma(xdiff, xdiff, ydiff * ydiff).sqrt();
    auto invLengths = lengths.invert();
    xdiff *= invLengths;
    ydiff *= invLengths;

    // Since the quad is rectilinear, the edge distances are predictable and independent of the
    // actual orientation of the quad. The lengths vector stores |p1-p0|, |p3-p1|, |p0-p2|, |p2-p3|,
    // matching the CCW order. For instance, edge distances for p0 are 0 for e0 and e2 since they
    // intersect at p0. Distance to e1 is the same as p0 to p1. Distance to e3 is p0 to p2 since
    // e3 goes through p2 and since the quad is rectilinear, we know that's the shortest distance.
    edgeDistances[0] = Sk4f(0.f, lengths[0], 0.f, lengths[2]);
    edgeDistances[1] = Sk4f(0.f, 0.f, lengths[0], lengths[1]);
    edgeDistances[2] = Sk4f(lengths[2], lengths[3], 0.f, 0.f);
    edgeDistances[3] = Sk4f(lengths[1], 0.f, lengths[3], 0.f);

    if (aaFlags != GrQuadAAFlags::kAll) {
        // This order is the same order the edges appear in xdiff/ydiff and therefore as the
        // edges in a/b/c.
        Sk4f mask = compute_edge_mask(aaFlags);

        // Update opposite corner distances by 1 (when enabled by the mask). The distance
        // calculations used in compute_quad_edges_... calculates the edge equations from original
        // positions and then shifts the coefficient by 0.5, and the final distance is calculated
        // from the outset positions, which adds a further 0.5. Thus, in this optimization we add a
        // net 1.f
        edgeDistances[0] += Sk4f(0.f, 1.f, 0.f, 1.f) * mask;
        edgeDistances[1] += Sk4f(0.f, 0.f, 1.f, 1.f) * mask;
        edgeDistances[2] += Sk4f(1.f, 1.f, 0.f, 0.f) * mask;
        edgeDistances[3] += Sk4f(1.f, 0.f, 1.f, 0.f) * mask;

        // Outset edge equations for masked out edges another pixel so that they always evaluate
        // So add 1-mask to each point's edge distances vector so that coverage >= 1 on non-aa
        for (int i = 0; i < 4; ++i) {
            edgeDistances[i] += (1.f - mask);
        }
        outset_masked_vertices(xdiff, ydiff, invLengths, mask, x, y, u, v, r, uvrChannelCount);
    } else {
        // Update opposite corner distances by 0.5 pixel and 0.5 edge shift, skipping the need for
        // mask since that's 1s
        edgeDistances[0] += Sk4f(0.f, 1.f, 0.f, 1.f);
        edgeDistances[1] += Sk4f(0.f, 0.f, 1.f, 1.f);
        edgeDistances[2] += Sk4f(1.f, 1.f, 0.f, 0.f);
        edgeDistances[3] += Sk4f(1.f, 0.f, 1.f, 0.f);

        outset_vertices(xdiff, ydiff, invLengths, x, y, u, v, r, uvrChannelCount);
    }
}

// Generalizes compute_quad_edge_distances_and_outset_vertices to extrapolate local coords such that
// after perspective division of the device coordinate, the original local coordinate value is at
// the original un-outset device position. r is the local coordinate's w component.
static void compute_quad_dists_and_outset_persp_vertices(GrQuadAAFlags aaFlags, Sk4f* x,
        Sk4f* y, Sk4f* w, Sk4f edgeDistances[4], Sk4f* u, Sk4f* v, Sk4f* r, int uvrChannelCount) {
    SkASSERT(uvrChannelCount == 0 || uvrChannelCount == 2 || uvrChannelCount == 3);

    auto iw = (*w).invert();
    auto x2d = (*x) * iw;
    auto y2d = (*y) * iw;
    Sk4f a, b, c;
    // Don't compute outset corners in the normalized space, which means u, v, and r don't need
    // to be provided here (outset separately below). Since this is computing distances for a
    // projected quad, there is a very good chance it's not rectilinear so use the general 2D path.
    compute_quad_edges_and_outset_vertices(aaFlags, &x2d, &y2d, &a, &b, &c, nullptr, nullptr,
                                           nullptr, /* uvr ct */ 0, /* outsetCorners */ false);

    static const float kOutset = 0.5f;
    if ((GrQuadAAFlags::kLeft | GrQuadAAFlags::kRight) & aaFlags) {
        // For each entry in x the equivalent entry in opX is the left/right opposite and so on.
        Sk4f opX = SkNx_shuffle<2, 3, 0, 1>(*x);
        Sk4f opW = SkNx_shuffle<2, 3, 0, 1>(*w);
        Sk4f opY = SkNx_shuffle<2, 3, 0, 1>(*y);
        // vx/vy holds the device space left-to-right vectors along top and bottom of the quad.
        Sk2f vx = SkNx_shuffle<2, 3>(x2d) - SkNx_shuffle<0, 1>(x2d);
        Sk2f vy = SkNx_shuffle<2, 3>(y2d) - SkNx_shuffle<0, 1>(y2d);
        Sk2f len = SkNx_fma(vx, vx, vy * vy).sqrt();
        // For each device space corner, devP, label its left/right opposite device space point
        // opDevPt. The new device space point is opDevPt + s (devPt - opDevPt) where s is
        // (length(devPt - opDevPt) + 0.5) / length(devPt - opDevPt);
        Sk4f s = SkNx_shuffle<0, 1, 0, 1>((len + kOutset) / len);
        // Compute t in homogeneous space from s using similar triangles so that we can produce
        // homogeneous outset vertices for perspective-correct interpolation.
        Sk4f sOpW = s * opW;
        Sk4f t = sOpW / (sOpW + (1.f - s) * (*w));
        // mask is used to make the t values be 1 when the left/right side is not antialiased.
        Sk4f mask(GrQuadAAFlags::kLeft & aaFlags  ? 1.f : 0.f,
                  GrQuadAAFlags::kLeft & aaFlags  ? 1.f : 0.f,
                  GrQuadAAFlags::kRight & aaFlags ? 1.f : 0.f,
                  GrQuadAAFlags::kRight & aaFlags ? 1.f : 0.f);
        t = t * mask + (1.f - mask);
        *x = opX + t * (*x - opX);
        *y = opY + t * (*y - opY);
        *w = opW + t * (*w - opW);

        if (uvrChannelCount > 0) {
            Sk4f opU = SkNx_shuffle<2, 3, 0, 1>(*u);
            Sk4f opV = SkNx_shuffle<2, 3, 0, 1>(*v);
            *u = opU + t * (*u - opU);
            *v = opV + t * (*v - opV);
            if (uvrChannelCount == 3) {
                Sk4f opR = SkNx_shuffle<2, 3, 0, 1>(*r);
                *r = opR + t * (*r - opR);
            }
        }

        if ((GrQuadAAFlags::kTop | GrQuadAAFlags::kBottom) & aaFlags) {
            // Update the 2D points for the top/bottom calculation.
            iw = (*w).invert();
            x2d = (*x) * iw;
            y2d = (*y) * iw;
        }
    }

    if ((GrQuadAAFlags::kTop | GrQuadAAFlags::kBottom) & aaFlags) {
        // This operates the same as above but for top/bottom rather than left/right.
        Sk4f opX = SkNx_shuffle<1, 0, 3, 2>(*x);
        Sk4f opW = SkNx_shuffle<1, 0, 3, 2>(*w);
        Sk4f opY = SkNx_shuffle<1, 0, 3, 2>(*y);

        Sk2f vx = SkNx_shuffle<1, 3>(x2d) - SkNx_shuffle<0, 2>(x2d);
        Sk2f vy = SkNx_shuffle<1, 3>(y2d) - SkNx_shuffle<0, 2>(y2d);
        Sk2f len = SkNx_fma(vx, vx, vy * vy).sqrt();

        Sk4f s = SkNx_shuffle<0, 0, 1, 1>((len + kOutset) / len);

        Sk4f sOpW = s * opW;
        Sk4f t = sOpW / (sOpW + (1.f - s) * (*w));

        Sk4f mask(GrQuadAAFlags::kTop    & aaFlags ? 1.f : 0.f,
                  GrQuadAAFlags::kBottom & aaFlags ? 1.f : 0.f,
                  GrQuadAAFlags::kTop    & aaFlags ? 1.f : 0.f,
                  GrQuadAAFlags::kBottom & aaFlags ? 1.f : 0.f);
        t = t * mask + (1.f - mask);
        *x = opX + t * (*x - opX);
        *y = opY + t * (*y - opY);
        *w = opW + t * (*w - opW);

        if (uvrChannelCount > 0) {
            Sk4f opU = SkNx_shuffle<1, 0, 3, 2>(*u);
            Sk4f opV = SkNx_shuffle<1, 0, 3, 2>(*v);
            *u = opU + t * (*u - opU);
            *v = opV + t * (*v - opV);
            if (uvrChannelCount == 3) {
                Sk4f opR = SkNx_shuffle<1, 0, 3, 2>(*r);
                *r = opR + t * (*r - opR);
            }
        }
    }

    // Use the original edge equations with the outset homogeneous coordinates to get the edge
    // distance (technically multiplied by w, so that the fragment shader can do perspective
    // interpolation when it multiplies by 1/w later).
    compute_edge_distances(a, b, c, *x, *y, *w, edgeDistances);
}

} // anonymous namespace

namespace GrQuadPerEdgeAA {

////////////////// Tessellate Implementation

void* Tessellate(void* vertices, const VertexSpec& spec, const GrPerspQuad& deviceQuad,
                 const SkPMColor4f& color4f, const GrPerspQuad& localQuad, const SkRect& domain,
                 GrQuadAAFlags aaFlags) {
    bool deviceHasPerspective = spec.deviceQuadType() == GrQuadType::kPerspective;
    bool localHasPerspective = spec.localQuadType() == GrQuadType::kPerspective;
    GrVertexColor color(color4f, GrQuadPerEdgeAA::ColorType::kHalf == spec.colorType());

    // Load position data into Sk4fs (always x, y, and load w to avoid branching down the road)
    Sk4f x = deviceQuad.x4f();
    Sk4f y = deviceQuad.y4f();
    Sk4f w = deviceQuad.w4f(); // Guaranteed to be 1f if it's not perspective

    // Load local position data into Sk4fs (either none, just u,v or all three)
    Sk4f u, v, r;
    if (spec.hasLocalCoords()) {
        u = localQuad.x4f();
        v = localQuad.y4f();

        if (localHasPerspective) {
            r = localQuad.w4f();
        }
    }

    // Index into array refers to vertex. Index into particular Sk4f refers to edge.
    Sk4f edgeDistances[4];
    if (spec.usesCoverageAA()) {
        // Must calculate edges and possibly outside the positions
        if (aaFlags == GrQuadAAFlags::kNone) {
            // A non-AA quad that got batched into an AA group, so it should have full coverage
            // everywhere, so set the edge distances to w for each vertex (so that after perspective
            // division, it is equal to 1).
            for (int i = 0; i < 4; ++i) {
                edgeDistances[i] = w[i];
            }
        } else if (deviceHasPerspective) {
            // For simplicity, pointers to u, v, and r are always provided, but the local dim param
            // ensures that only loaded Sk4fs are modified in the compute functions.
            compute_quad_dists_and_outset_persp_vertices(aaFlags, &x, &y, &w, edgeDistances,
                                                         &u, &v, &r, spec.localDimensionality());
        } else if (spec.deviceQuadType() <= GrQuadType::kRectilinear) {
            compute_rectilinear_dists_and_outset_vertices(aaFlags, &x, &y, edgeDistances,
                                                          &u, &v, &r, spec.localDimensionality());
        } else {
            Sk4f a, b, c;
            compute_quad_edges_and_outset_vertices(aaFlags, &x, &y, &a, &b, &c, &u, &v, &r,
                                                   spec.localDimensionality(), /*outset*/ true);
            compute_edge_distances(a, b, c, x, y, w, edgeDistances); // w holds 1.f as desired
        }
    }

    // Now rearrange the Sk4fs into the interleaved vertex layout:
    //  i.e. x1x2x3x4 y1y2y3y4 -> x1y1 x2y2 x3y3 x4y
    GrVertexWriter vb{vertices};
    for (int i = 0; i < 4; ++i) {
        // save position and hold on to the homogeneous point for later
        if (deviceHasPerspective) {
            vb.write<SkPoint3>({x[i], y[i], w[i]});
        } else {
            vb.write<SkPoint>({x[i], y[i]});
        }

        // save color
        if (spec.hasVertexColors()) {
            vb.write(color);
        }

        // save local position
        if (spec.hasLocalCoords()) {
            if (localHasPerspective) {
                vb.write<SkPoint3>({u[i], v[i], r[i]});
            } else {
                vb.write<SkPoint>({u[i], v[i]});
            }
        }

        // save the domain
        if (spec.hasDomain()) {
            vb.write(domain);
        }

        // save the edges
        if (spec.usesCoverageAA()) {
            vb.write(edgeDistances[i]);
        }
    }

    return vb.fPtr;
}

////////////////// VertexSpec Implementation

int VertexSpec::deviceDimensionality() const {
    return this->deviceQuadType() == GrQuadType::kPerspective ? 3 : 2;
}

int VertexSpec::localDimensionality() const {
    return fHasLocalCoords ? (this->localQuadType() == GrQuadType::kPerspective ? 3 : 2) : 0;
}

////////////////// GPAttributes Implementation

GPAttributes::GPAttributes(const VertexSpec& spec) {
    if (spec.deviceDimensionality() == 3) {
        fPositions = {"position", kFloat3_GrVertexAttribType, kFloat3_GrSLType};
    } else {
        fPositions = {"position", kFloat2_GrVertexAttribType, kFloat2_GrSLType};
    }

    int localDim = spec.localDimensionality();
    if (localDim == 3) {
        fLocalCoords = {"localCoord", kFloat3_GrVertexAttribType, kFloat3_GrSLType};
    } else if (localDim == 2) {
        fLocalCoords = {"localCoord", kFloat2_GrVertexAttribType, kFloat2_GrSLType};
    } // else localDim == 0 and attribute remains uninitialized

    if (ColorType::kByte == spec.colorType()) {
        fColors = {"color", kUByte4_norm_GrVertexAttribType, kHalf4_GrSLType};
    } else if (ColorType::kHalf == spec.colorType()) {
        fColors = {"color", kHalf4_GrVertexAttribType, kHalf4_GrSLType};
    }

    if (spec.hasDomain()) {
        fDomain = {"domain", kFloat4_GrVertexAttribType, kFloat4_GrSLType};
    }

    if (spec.usesCoverageAA()) {
        fAAEdgeDistances = {"aaEdgeDist", kFloat4_GrVertexAttribType, kFloat4_GrSLType};
    }
}

bool GPAttributes::needsPerspectiveInterpolation() const {
    // This only needs to check the position; local position having perspective does not change
    // how the varyings are interpolated
    return fPositions.cpuType() == kFloat3_GrVertexAttribType;
}

uint32_t GPAttributes::getKey() const {
    // aa, domain are single bit flags
    uint32_t x = this->usesCoverageAA() ? 0 : 1;
    x |= this->hasDomain() ? 0 : 2;
    // regular position has two options as well
    x |= kFloat3_GrVertexAttribType == fPositions.cpuType() ? 0 : 4;
    // local coords require 2 bits (3 choices), 00 for none, 01 for 2d, 10 for 3d
    if (this->hasLocalCoords()) {
        x |= kFloat3_GrVertexAttribType == fLocalCoords.cpuType() ? 8 : 16;
    }
    // similar for colors, 00 for none, 01 for bytes, 10 for half-floats
    if (this->hasVertexColors()) {
        x |= kUByte4_norm_GrVertexAttribType == fColors.cpuType() ? 32 : 64;
    }
    return x;
}

void GPAttributes::emitColor(GrGLSLPrimitiveProcessor::EmitArgs& args,
                             const char* colorVarName) const {
    using Interpolation = GrGLSLVaryingHandler::Interpolation;
    if (fColors.isInitialized()) {
        args.fVaryingHandler->addPassThroughAttribute(fColors, args.fOutputColor,
                                                      Interpolation::kCanBeFlat);
    }
}

void GPAttributes::emitExplicitLocalCoords(
        GrGLSLPrimitiveProcessor::EmitArgs& args, const char* localCoordName,
        const char* domainName) const {
    using Interpolation = GrGLSLVaryingHandler::Interpolation;
    if (!this->hasLocalCoords()) {
        return;
    }

    args.fFragBuilder->codeAppendf("float2 %s;", localCoordName);
    bool localHasPerspective = fLocalCoords.cpuType() == kFloat3_GrVertexAttribType;
    if (localHasPerspective) {
        // Can't do a pass through since we need to perform perspective division
        GrGLSLVarying v(fLocalCoords.gpuType());
        args.fVaryingHandler->addVarying(fLocalCoords.name(), &v);
        args.fVertBuilder->codeAppendf("%s = %s;", v.vsOut(), fLocalCoords.name());
        args.fFragBuilder->codeAppendf("%s = %s.xy / %s.z;", localCoordName, v.fsIn(), v.fsIn());
    } else {
        args.fVaryingHandler->addPassThroughAttribute(fLocalCoords, localCoordName);
    }

    // Clamp the now 2D localCoordName variable by the domain if it is provided
    if (this->hasDomain()) {
        args.fFragBuilder->codeAppendf("float4 %s;", domainName);
        args.fVaryingHandler->addPassThroughAttribute(fDomain, domainName,
                                                      Interpolation::kCanBeFlat);
        args.fFragBuilder->codeAppendf("%s = clamp(%s, %s.xy, %s.zw);",
                                       localCoordName, localCoordName, domainName, domainName);
    }
}

void GPAttributes::emitCoverage(GrGLSLPrimitiveProcessor::EmitArgs& args,
                                const char* edgeDistName) const {
    if (this->usesCoverageAA()) {
        args.fFragBuilder->codeAppendf("float4 %s;", edgeDistName);
        args.fVaryingHandler->addPassThroughAttribute(fAAEdgeDistances, edgeDistName);

        args.fFragBuilder->codeAppendf(
                "float min%s = min(min(%s.x, %s.y), min(%s.z, %s.w));",
                edgeDistName, edgeDistName, edgeDistName, edgeDistName, edgeDistName);
        if (fPositions.cpuType() == kFloat3_GrVertexAttribType) {
            // The distance from edge equation e to homogeneous point p=sk_Position is e.x*p.x/p.w +
            // e.y*p.y/p.w + e.z. However, we want screen space interpolation of this distance. We
            // can do this by multiplying the vertex attribute 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.fFragBuilder->codeAppendf("min%s *= sk_FragCoord.w;", edgeDistName);
        }
        args.fFragBuilder->codeAppendf("%s = float4(saturate(min%s));",
                                       args.fOutputCoverage, edgeDistName);
    } else {
        // Set coverage to 1
        args.fFragBuilder->codeAppendf("%s = float4(1);", args.fOutputCoverage);
    }
}

} // namespace GrQuadPerEdgeAA