/*

 * Copyright 2013 Google Inc.

 *

 * Use of this source code is governed by a BSD-style license that can be

 * found in the LICENSE file.

 */

#include "src/gpu/ops/GrOvalOpFactory.h"

#include "include/core/SkStrokeRec.h"

#include "src/core/SkMatrixPriv.h"

#include "src/core/SkRRectPriv.h"

#include "src/gpu/GrCaps.h"

#include "src/gpu/GrDrawOpTest.h"

#include "src/gpu/GrGeometryProcessor.h"

#include "src/gpu/GrOpFlushState.h"

#include "src/gpu/GrProcessor.h"

#include "src/gpu/GrProgramInfo.h"

#include "src/gpu/GrResourceProvider.h"

#include "src/gpu/GrShaderCaps.h"

#include "src/gpu/GrStyle.h"

#include "src/gpu/GrVertexWriter.h"

#include "src/gpu/glsl/GrGLSLFragmentShaderBuilder.h"

#include "src/gpu/glsl/GrGLSLProgramDataManager.h"

#include "src/gpu/glsl/GrGLSLUniformHandler.h"

#include "src/gpu/glsl/GrGLSLVarying.h"

#include "src/gpu/glsl/GrGLSLVertexGeoBuilder.h"

#include "src/gpu/ops/GrMeshDrawOp.h"

#include "src/gpu/ops/GrSimpleMeshDrawOpHelper.h"

#include <utility>

namespace {

static inline bool circle_stays_circle(const SkMatrix& m) { return m.isSimilarity(); }

// Produces TriStrip vertex data for an origin-centered rectangle from [-x, -y] to [x, y]

static inline GrVertexWriter::TriStrip<float> origin_centered_tri_strip(float x, float y) {

    return GrVertexWriter::TriStrip<float>{ -x, -y, x, y };

};

}  // namespace

///////////////////////////////////////////////////////////////////////////////

/**

 * The output of this effect is a modulation of the input color and coverage for a circle. It

 * operates in a space normalized by the circle radius (outer radius in the case of a stroke)

 * with origin at the circle center. Three vertex attributes are used:

 *    vec2f : position in device space of the bounding geometry vertices

 *    vec4ub: color

 *    vec4f : (p.xy, outerRad, innerRad)

 *             p is the position in the normalized space.

 *             outerRad is the outerRadius in device space.

 *             innerRad is the innerRadius in normalized space (ignored if not stroking).

 * Additional clip planes are supported for rendering circular arcs. The additional planes are

 * either intersected or unioned together. Up to three planes are supported (an initial plane,

 * a plane intersected with the initial plane, and a plane unioned with the first two). Only two

 * are useful for any given arc, but having all three in one instance allows combining different

 * types of arcs.

 * Round caps for stroking are allowed as well. The caps are specified as two circle center points

 * in the same space as p.xy.

 */

class CircleGeometryProcessor : public GrGeometryProcessor {

public:

    static GrGeometryProcessor* Make(SkArenaAlloc* arena, bool stroke, bool clipPlane,

                                     bool isectPlane, bool unionPlane, bool roundCaps,

                                     bool wideColor, const SkMatrix& localMatrix) {

        return arena->make([&](void* ptr) {

            return new (ptr) CircleGeometryProcessor(stroke, clipPlane, isectPlane, unionPlane,

                                                     roundCaps, wideColor, localMatrix);

        });

    }

    const char* name() const override { return "CircleGeometryProcessor"; }

    void addToKey(const GrShaderCaps& caps, GrProcessorKeyBuilder* b) const override {

        b->addBool(fStroke,                             "stroked"        );

        b->addBool(fInClipPlane.isInitialized(),        "clipPlane"      );

        b->addBool(fInIsectPlane.isInitialized(),       "isectPlane"     );

        b->addBool(fInUnionPlane.isInitialized(),       "unionPlane"     );

        b->addBool(fInRoundCapCenters.isInitialized(),  "roundCapCenters");

        b->addBits(ProgramImpl::kMatrixKeyBits,

                   ProgramImpl::ComputeMatrixKey(caps, fLocalMatrix),

                   "localMatrixType");

    }

    std::unique_ptr<ProgramImpl> makeProgramImpl(const GrShaderCaps&) const override {

        return std::make_unique<Impl>();

    }

private:

    CircleGeometryProcessor(bool stroke, bool clipPlane, bool isectPlane, bool unionPlane,

                            bool roundCaps, bool wideColor, const SkMatrix& localMatrix)

            : INHERITED(kCircleGeometryProcessor_ClassID)

            , fLocalMatrix(localMatrix)

            , fStroke(stroke) {

        fInPosition = {"inPosition", kFloat2_GrVertexAttribType, kFloat2_GrSLType};

        fInColor = MakeColorAttribute("inColor", wideColor);

        fInCircleEdge = {"inCircleEdge", kFloat4_GrVertexAttribType, kFloat4_GrSLType};

        if (clipPlane) {

            fInClipPlane = {"inClipPlane", kFloat3_GrVertexAttribType, kHalf3_GrSLType};

        }

        if (isectPlane) {

            fInIsectPlane = {"inIsectPlane", kFloat3_GrVertexAttribType, kHalf3_GrSLType};

        }

        if (unionPlane) {

            fInUnionPlane = {"inUnionPlane", kFloat3_GrVertexAttribType, kHalf3_GrSLType};

        }

        if (roundCaps) {

            SkASSERT(stroke);

            SkASSERT(clipPlane);

            fInRoundCapCenters =

                    {"inRoundCapCenters", kFloat4_GrVertexAttribType, kFloat4_GrSLType};

        }

        this->setVertexAttributes(&fInPosition, 7);

    }

    class Impl : public ProgramImpl {

    public:

        void setData(const GrGLSLProgramDataManager& pdman,

                     const GrShaderCaps& shaderCaps,

                     const GrGeometryProcessor& geomProc) override {

            SetTransform(pdman,

                         shaderCaps,

                         fLocalMatrixUniform,

                         geomProc.cast<CircleGeometryProcessor>().fLocalMatrix,

                         &fLocalMatrix);

        }

    private:

        void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override {

            const CircleGeometryProcessor& cgp = args.fGeomProc.cast<CircleGeometryProcessor>();

            GrGLSLVertexBuilder* vertBuilder = args.fVertBuilder;

            GrGLSLVaryingHandler* varyingHandler = args.fVaryingHandler;

            GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;

            GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;

            // emit attributes

            varyingHandler->emitAttributes(cgp);

            fragBuilder->codeAppend("float4 circleEdge;");

            varyingHandler->addPassThroughAttribute(cgp.fInCircleEdge.asShaderVar(), "circleEdge");

            if (cgp.fInClipPlane.isInitialized()) {

                fragBuilder->codeAppend("half3 clipPlane;");

                varyingHandler->addPassThroughAttribute(cgp.fInClipPlane.asShaderVar(),

                                                        "clipPlane");

            }

            if (cgp.fInIsectPlane.isInitialized()) {

                fragBuilder->codeAppend("half3 isectPlane;");

                varyingHandler->addPassThroughAttribute(cgp.fInIsectPlane.asShaderVar(),

                                                        "isectPlane");

            }

            if (cgp.fInUnionPlane.isInitialized()) {

                SkASSERT(cgp.fInClipPlane.isInitialized());

                fragBuilder->codeAppend("half3 unionPlane;");

                varyingHandler->addPassThroughAttribute(cgp.fInUnionPlane.asShaderVar(),

                                                        "unionPlane");

            }

            GrGLSLVarying capRadius(kFloat_GrSLType);

            if (cgp.fInRoundCapCenters.isInitialized()) {

                fragBuilder->codeAppend("float4 roundCapCenters;");

                varyingHandler->addPassThroughAttribute(cgp.fInRoundCapCenters.asShaderVar(),

                                                        "roundCapCenters");

                varyingHandler->addVarying("capRadius", &capRadius,

                                           GrGLSLVaryingHandler::Interpolation::kCanBeFlat);

                // This is the cap radius in normalized space where the outer radius is 1 and

                // circledEdge.w is the normalized inner radius.

                vertBuilder->codeAppendf("%s = (1.0 - %s.w) / 2.0;", capRadius.vsOut(),

                                         cgp.fInCircleEdge.name());

            }

            // setup pass through color

            fragBuilder->codeAppendf("half4 %s;", args.fOutputColor);

            varyingHandler->addPassThroughAttribute(cgp.fInColor.asShaderVar(), args.fOutputColor);

            // Setup position

            WriteOutputPosition(vertBuilder, gpArgs, cgp.fInPosition.name());

            WriteLocalCoord(vertBuilder,

                            uniformHandler,

                            *args.fShaderCaps,

                            gpArgs,

                            cgp.fInPosition.asShaderVar(),

                            cgp.fLocalMatrix,

                            &fLocalMatrixUniform);

            fragBuilder->codeAppend("float d = length(circleEdge.xy);");

            fragBuilder->codeAppend("half distanceToOuterEdge = half(circleEdge.z * (1.0 - d));");

            fragBuilder->codeAppend("half edgeAlpha = saturate(distanceToOuterEdge);");

            if (cgp.fStroke) {

                fragBuilder->codeAppend(

                        "half distanceToInnerEdge = half(circleEdge.z * (d - circleEdge.w));");

                fragBuilder->codeAppend("half innerAlpha = saturate(distanceToInnerEdge);");

                fragBuilder->codeAppend("edgeAlpha *= innerAlpha;");

            }

            if (cgp.fInClipPlane.isInitialized()) {

                fragBuilder->codeAppend(

                        "half clip = half(saturate(circleEdge.z * dot(circleEdge.xy, "

                        "clipPlane.xy) + clipPlane.z));");

                if (cgp.fInIsectPlane.isInitialized()) {

                    fragBuilder->codeAppend(

                            "clip *= half(saturate(circleEdge.z * dot(circleEdge.xy, "

                            "isectPlane.xy) + isectPlane.z));");

                }

                if (cgp.fInUnionPlane.isInitialized()) {

                    fragBuilder->codeAppend(

                            "clip = saturate(clip + half(saturate(circleEdge.z * dot(circleEdge.xy,"

                            " unionPlane.xy) + unionPlane.z)));");

                }

                fragBuilder->codeAppend("edgeAlpha *= clip;");

                if (cgp.fInRoundCapCenters.isInitialized()) {

                    // We compute coverage of the round caps as circles at the butt caps produced

                    // by the clip planes. The inverse of the clip planes is applied so that there

                    // is no double counting.

                    fragBuilder->codeAppendf(

                            "half dcap1 = half(circleEdge.z * (%s - length(circleEdge.xy - "

                            "                                              roundCapCenters.xy)));"

                            "half dcap2 = half(circleEdge.z * (%s - length(circleEdge.xy - "

                            "                                              roundCapCenters.zw)));"

                            "half capAlpha = (1 - clip) * (max(dcap1, 0) + max(dcap2, 0));"

                            "edgeAlpha = min(edgeAlpha + capAlpha, 1.0);",

                            capRadius.fsIn(), capRadius.fsIn());

                }

            }

            fragBuilder->codeAppendf("half4 %s = half4(edgeAlpha);", args.fOutputCoverage);

        }

Unexecuted instantiation: CircleGeometryProcessor::Impl::onEmitCode(GrGeometryProcessor::ProgramImpl::EmitArgs&, GrGeometryProcessor::ProgramImpl::GrGPArgs*)

Unexecuted instantiation: CircleGeometryProcessor::Impl::onEmitCode(GrGeometryProcessor::ProgramImpl::EmitArgs&, GrGeometryProcessor::ProgramImpl::GrGPArgs*)

        SkMatrix      fLocalMatrix = SkMatrix::InvalidMatrix();

        UniformHandle fLocalMatrixUniform;

    };

    SkMatrix fLocalMatrix;

    Attribute fInPosition;

    Attribute fInColor;

    Attribute fInCircleEdge;

    // Optional attributes.

    Attribute fInClipPlane;

    Attribute fInIsectPlane;

    Attribute fInUnionPlane;

    Attribute fInRoundCapCenters;

    bool fStroke;

    GR_DECLARE_GEOMETRY_PROCESSOR_TEST

    using INHERITED = GrGeometryProcessor;

};

GR_DEFINE_GEOMETRY_PROCESSOR_TEST(CircleGeometryProcessor);

#if GR_TEST_UTILS

GrGeometryProcessor* CircleGeometryProcessor::TestCreate(GrProcessorTestData* d) {

    bool stroke = d->fRandom->nextBool();

    bool roundCaps = stroke ? d->fRandom->nextBool() : false;

    bool wideColor = d->fRandom->nextBool();

    bool clipPlane = d->fRandom->nextBool();

    bool isectPlane = d->fRandom->nextBool();

    bool unionPlane = d->fRandom->nextBool();

    const SkMatrix& matrix = GrTest::TestMatrix(d->fRandom);

    return CircleGeometryProcessor::Make(d->allocator(), stroke, clipPlane, isectPlane,

                                         unionPlane, roundCaps, wideColor, matrix);

}

#endif

class ButtCapDashedCircleGeometryProcessor : public GrGeometryProcessor {

public:

    static GrGeometryProcessor* Make(SkArenaAlloc* arena, bool wideColor,

                                     const SkMatrix& localMatrix) {

        return arena->make([&](void* ptr) {

            return new (ptr) ButtCapDashedCircleGeometryProcessor(wideColor, localMatrix);

        });

    }

    ~ButtCapDashedCircleGeometryProcessor() override {}

    const char* name() const override { return "ButtCapDashedCircleGeometryProcessor"; }

    void addToKey(const GrShaderCaps& caps, GrProcessorKeyBuilder* b) const override {

        b->addBits(ProgramImpl::kMatrixKeyBits,

                   ProgramImpl::ComputeMatrixKey(caps, fLocalMatrix),

                   "localMatrixType");

    }

    std::unique_ptr<ProgramImpl> makeProgramImpl(const GrShaderCaps&) const override {

        return std::make_unique<Impl>();

    }

private:

    ButtCapDashedCircleGeometryProcessor(bool wideColor, const SkMatrix& localMatrix)

            : INHERITED(kButtCapStrokedCircleGeometryProcessor_ClassID)

            , fLocalMatrix(localMatrix) {

        fInPosition = {"inPosition", kFloat2_GrVertexAttribType, kFloat2_GrSLType};

        fInColor = MakeColorAttribute("inColor", wideColor);

        fInCircleEdge = {"inCircleEdge", kFloat4_GrVertexAttribType, kFloat4_GrSLType};

        fInDashParams = {"inDashParams", kFloat4_GrVertexAttribType, kFloat4_GrSLType};

        this->setVertexAttributes(&fInPosition, 4);

    }

    class Impl : public ProgramImpl {

    public:

        void setData(const GrGLSLProgramDataManager& pdman,

                     const GrShaderCaps& shaderCaps,

                     const GrGeometryProcessor& geomProc) override {

            SetTransform(pdman,

                         shaderCaps,

                         fLocalMatrixUniform,

                         geomProc.cast<ButtCapDashedCircleGeometryProcessor>().fLocalMatrix,

                         &fLocalMatrix);

        }

    private:

        void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override {

            const ButtCapDashedCircleGeometryProcessor& bcscgp =

                    args.fGeomProc.cast<ButtCapDashedCircleGeometryProcessor>();

            GrGLSLVertexBuilder* vertBuilder = args.fVertBuilder;

            GrGLSLVaryingHandler* varyingHandler = args.fVaryingHandler;

            GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;

            GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;

            // emit attributes

            varyingHandler->emitAttributes(bcscgp);

            fragBuilder->codeAppend("float4 circleEdge;");

            varyingHandler->addPassThroughAttribute(bcscgp.fInCircleEdge.asShaderVar(),

                                                    "circleEdge");

            fragBuilder->codeAppend("float4 dashParams;");

            varyingHandler->addPassThroughAttribute(

                    bcscgp.fInDashParams.asShaderVar(),

                    "dashParams",

                    GrGLSLVaryingHandler::Interpolation::kCanBeFlat);

            GrGLSLVarying wrapDashes(kHalf4_GrSLType);

            varyingHandler->addVarying("wrapDashes", &wrapDashes,

                                       GrGLSLVaryingHandler::Interpolation::kCanBeFlat);

            GrGLSLVarying lastIntervalLength(kHalf_GrSLType);

            varyingHandler->addVarying("lastIntervalLength", &lastIntervalLength,

                                       GrGLSLVaryingHandler::Interpolation::kCanBeFlat);

            vertBuilder->codeAppendf("float4 dashParams = %s;", bcscgp.fInDashParams.name());

            // Our fragment shader works in on/off intervals as specified by dashParams.xy:

            //     x = length of on interval, y = length of on + off.

            // There are two other parameters in dashParams.zw:

            //     z = start angle in radians, w = phase offset in radians in range -y/2..y/2.

            // Each interval has a "corresponding" dash which may be shifted partially or

            // fully out of its interval by the phase. So there may be up to two "visual"

            // dashes in an interval.

            // When computing coverage in an interval we look at three dashes. These are the

            // "corresponding" dashes from the current, previous, and next intervals. Any of these

            // may be phase shifted into our interval or even when phase=0 they may be within half a

            // pixel distance of a pixel center in the interval.

            // When in the first interval we need to check the dash from the last interval. And

            // similarly when in the last interval we need to check the dash from the first

            // interval. When 2pi is not perfectly divisible dashParams.y this is a boundary case.

            // We compute the dash begin/end angles in the vertex shader and apply them in the

            // fragment shader when we detect we're in the first/last interval.

            vertBuilder->codeAppend(R"(

                    // The two boundary dash intervals are stored in wrapDashes.xy and .zw and fed

                    // to the fragment shader as a varying.

                    float4 wrapDashes;

                    half lastIntervalLength = mod(6.28318530718, half(dashParams.y));

                    // We can happen to be perfectly divisible.

                    if (0 == lastIntervalLength) {

                        lastIntervalLength = half(dashParams.y);

                    }

                    // Let 'l' be the last interval before reaching 2 pi.

                    // Based on the phase determine whether (l-1)th, l-th, or (l+1)th interval's

                    // "corresponding" dash appears in the l-th interval and is closest to the 0-th

                    // interval.

                    half offset = 0;

                    if (-dashParams.w >= lastIntervalLength) {

                         offset = half(-dashParams.y);

                    } else if (dashParams.w > dashParams.y - lastIntervalLength) {

                         offset = half(dashParams.y);

                    }

                    wrapDashes.x = -lastIntervalLength + offset - dashParams.w;

                    // The end of this dash may be beyond the 2 pi and therefore clipped. Hence the

                    // min.

                    wrapDashes.y = min(wrapDashes.x + dashParams.x, 0);

                    // Based on the phase determine whether the -1st, 0th, or 1st interval's

                    // "corresponding" dash appears in the 0th interval and is closest to l.

                    offset = 0;

                    if (dashParams.w >= dashParams.x) {

                        offset = half(dashParams.y);

                    } else if (-dashParams.w > dashParams.y - dashParams.x) {

                        offset = half(-dashParams.y);

                    }

                    wrapDashes.z = lastIntervalLength + offset - dashParams.w;

                    wrapDashes.w = wrapDashes.z + dashParams.x;

                    // The start of the dash we're considering may be clipped by the start of the

                    // circle.

                    wrapDashes.z = max(wrapDashes.z, lastIntervalLength);

            )");

            vertBuilder->codeAppendf("%s = half4(wrapDashes);", wrapDashes.vsOut());

            vertBuilder->codeAppendf("%s = lastIntervalLength;", lastIntervalLength.vsOut());

            fragBuilder->codeAppendf("half4 wrapDashes = %s;", wrapDashes.fsIn());

            fragBuilder->codeAppendf("half lastIntervalLength = %s;", lastIntervalLength.fsIn());

            // setup pass through color

            fragBuilder->codeAppendf("half4 %s;", args.fOutputColor);

            varyingHandler->addPassThroughAttribute(

                    bcscgp.fInColor.asShaderVar(),

                    args.fOutputColor,

                    GrGLSLVaryingHandler::Interpolation::kCanBeFlat);

            // Setup position

            WriteOutputPosition(vertBuilder, gpArgs, bcscgp.fInPosition.name());

            WriteLocalCoord(vertBuilder,

                            uniformHandler,

                            *args.fShaderCaps,

                            gpArgs,

                            bcscgp.fInPosition.asShaderVar(),

                            bcscgp.fLocalMatrix,

                            &fLocalMatrixUniform);

            GrShaderVar fnArgs[] = {

                    GrShaderVar("angleToEdge", kFloat_GrSLType),

                    GrShaderVar("diameter", kFloat_GrSLType),

            };

            SkString fnName = fragBuilder->getMangledFunctionName("coverage_from_dash_edge");

            fragBuilder->emitFunction(kFloat_GrSLType, fnName.c_str(),

                                      {fnArgs, SK_ARRAY_COUNT(fnArgs)}, R"(

                    float linearDist;

                    angleToEdge = clamp(angleToEdge, -3.1415, 3.1415);

                    linearDist = diameter * sin(angleToEdge / 2);

                    return saturate(linearDist + 0.5);

            )");

            fragBuilder->codeAppend(R"(

                    float d = length(circleEdge.xy) * circleEdge.z;

                    // Compute coverage from outer/inner edges of the stroke.

                    half distanceToOuterEdge = half(circleEdge.z - d);

                    half edgeAlpha = saturate(distanceToOuterEdge);

                    half distanceToInnerEdge = half(d - circleEdge.z * circleEdge.w);

                    half innerAlpha = saturate(distanceToInnerEdge);

                    edgeAlpha *= innerAlpha;

                    half angleFromStart = half(atan(circleEdge.y, circleEdge.x) - dashParams.z);

                    angleFromStart = mod(angleFromStart, 6.28318530718);

                    float x = mod(angleFromStart, dashParams.y);

                    // Convert the radial distance from center to pixel into a diameter.

                    d *= 2;

                    half2 currDash = half2(half(-dashParams.w), half(dashParams.x) -

                                                                half(dashParams.w));

                    half2 nextDash = half2(half(dashParams.y) - half(dashParams.w),

                                           half(dashParams.y) + half(dashParams.x) -

                                                                half(dashParams.w));

                    half2 prevDash = half2(half(-dashParams.y) - half(dashParams.w),

                                           half(-dashParams.y) + half(dashParams.x) -

                                                                 half(dashParams.w));

                    half dashAlpha = 0;

                )");

            fragBuilder->codeAppendf(R"(

                    if (angleFromStart - x + dashParams.y >= 6.28318530718) {

                         dashAlpha += half(%s(x - wrapDashes.z, d) * %s(wrapDashes.w - x, d));

                         currDash.y = min(currDash.y, lastIntervalLength);

                         if (nextDash.x >= lastIntervalLength) {

                             // The next dash is outside the 0..2pi range, throw it away

                             nextDash.xy = half2(1000);

                         } else {

                             // Clip the end of the next dash to the end of the circle

                             nextDash.y = min(nextDash.y, lastIntervalLength);

                         }

                    }

            )", fnName.c_str(), fnName.c_str());

            fragBuilder->codeAppendf(R"(

                    if (angleFromStart - x - dashParams.y < -0.01) {

                         dashAlpha += half(%s(x - wrapDashes.x, d) * %s(wrapDashes.y - x, d));

                         currDash.x = max(currDash.x, 0);

                         if (prevDash.y <= 0) {

                             // The previous dash is outside the 0..2pi range, throw it away

                             prevDash.xy = half2(1000);

                         } else {

                             // Clip the start previous dash to the start of the circle

                             prevDash.x = max(prevDash.x, 0);

                         }

                    }

            )", fnName.c_str(), fnName.c_str());

            fragBuilder->codeAppendf(R"(

                    dashAlpha += half(%s(x - currDash.x, d) * %s(currDash.y - x, d));

                    dashAlpha += half(%s(x - nextDash.x, d) * %s(nextDash.y - x, d));

                    dashAlpha += half(%s(x - prevDash.x, d) * %s(prevDash.y - x, d));

                    dashAlpha = min(dashAlpha, 1);

                    edgeAlpha *= dashAlpha;

            )", fnName.c_str(), fnName.c_str(), fnName.c_str(), fnName.c_str(), fnName.c_str(),

                fnName.c_str());

            fragBuilder->codeAppendf("half4 %s = half4(edgeAlpha);", args.fOutputCoverage);

        }

        SkMatrix      fLocalMatrix = SkMatrix::InvalidMatrix();

        UniformHandle fLocalMatrixUniform;

    };

    SkMatrix fLocalMatrix;

    Attribute fInPosition;

    Attribute fInColor;

    Attribute fInCircleEdge;

    Attribute fInDashParams;

    GR_DECLARE_GEOMETRY_PROCESSOR_TEST

    using INHERITED = GrGeometryProcessor;

};

#if GR_TEST_UTILS

GrGeometryProcessor* ButtCapDashedCircleGeometryProcessor::TestCreate(GrProcessorTestData* d) {

    bool wideColor = d->fRandom->nextBool();

    const SkMatrix& matrix = GrTest::TestMatrix(d->fRandom);

    return ButtCapDashedCircleGeometryProcessor::Make(d->allocator(), wideColor, matrix);

}

#endif

///////////////////////////////////////////////////////////////////////////////

/**

 * The output of this effect is a modulation of the input color and coverage for an axis-aligned

 * ellipse, specified as a 2D offset from center, and the reciprocals of the outer and inner radii,

 * in both x and y directions.

 *

 * We are using an implicit function of x^2/a^2 + y^2/b^2 - 1 = 0.

 */

class EllipseGeometryProcessor : public GrGeometryProcessor {

public:

    static GrGeometryProcessor* Make(SkArenaAlloc* arena, bool stroke, bool wideColor,

                                     bool useScale, const SkMatrix& localMatrix) {

        return arena->make([&](void* ptr) {

            return new (ptr) EllipseGeometryProcessor(stroke, wideColor, useScale, localMatrix);

        });

    }

    ~EllipseGeometryProcessor() override {}

    const char* name() const override { return "EllipseGeometryProcessor"; }

    void addToKey(const GrShaderCaps& caps, GrProcessorKeyBuilder* b) const override {

        b->addBool(fStroke, "stroked");

        b->addBits(ProgramImpl::kMatrixKeyBits,

                   ProgramImpl::ComputeMatrixKey(caps, fLocalMatrix),

                   "localMatrixType");

    }

    std::unique_ptr<ProgramImpl> makeProgramImpl(const GrShaderCaps&) const override {

        return std::make_unique<Impl>();

    }

private:

    EllipseGeometryProcessor(bool stroke, bool wideColor, bool useScale,

                             const SkMatrix& localMatrix)

            : INHERITED(kEllipseGeometryProcessor_ClassID)

            , fLocalMatrix(localMatrix)

            , fStroke(stroke)

            , fUseScale(useScale) {

        fInPosition = {"inPosition", kFloat2_GrVertexAttribType, kFloat2_GrSLType};

        fInColor = MakeColorAttribute("inColor", wideColor);

        if (useScale) {

            fInEllipseOffset = {"inEllipseOffset", kFloat3_GrVertexAttribType, kFloat3_GrSLType};

        } else {

            fInEllipseOffset = {"inEllipseOffset", kFloat2_GrVertexAttribType, kFloat2_GrSLType};

        }

        fInEllipseRadii = {"inEllipseRadii", kFloat4_GrVertexAttribType, kFloat4_GrSLType};

        this->setVertexAttributes(&fInPosition, 4);

    }

    class Impl : public ProgramImpl {

    public:

        void setData(const GrGLSLProgramDataManager& pdman,

                     const GrShaderCaps& shaderCaps,

                     const GrGeometryProcessor& geomProc) override {

            const EllipseGeometryProcessor& egp = geomProc.cast<EllipseGeometryProcessor>();

            SetTransform(pdman, shaderCaps, fLocalMatrixUniform, egp.fLocalMatrix, &fLocalMatrix);

        }

    private:

        void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override {

            const EllipseGeometryProcessor& egp = args.fGeomProc.cast<EllipseGeometryProcessor>();

            GrGLSLVertexBuilder* vertBuilder = args.fVertBuilder;

            GrGLSLVaryingHandler* varyingHandler = args.fVaryingHandler;

            GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;

            // emit attributes

            varyingHandler->emitAttributes(egp);

            GrSLType offsetType = egp.fUseScale ? kFloat3_GrSLType : kFloat2_GrSLType;

            GrGLSLVarying ellipseOffsets(offsetType);

            varyingHandler->addVarying("EllipseOffsets", &ellipseOffsets);

            vertBuilder->codeAppendf("%s = %s;", ellipseOffsets.vsOut(),

                                     egp.fInEllipseOffset.name());

            GrGLSLVarying ellipseRadii(kFloat4_GrSLType);

            varyingHandler->addVarying("EllipseRadii", &ellipseRadii);

            vertBuilder->codeAppendf("%s = %s;", ellipseRadii.vsOut(), egp.fInEllipseRadii.name());

            GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;

            // setup pass through color

            fragBuilder->codeAppendf("half4 %s;", args.fOutputColor);

            varyingHandler->addPassThroughAttribute(egp.fInColor.asShaderVar(), args.fOutputColor);

            // Setup position

            WriteOutputPosition(vertBuilder, gpArgs, egp.fInPosition.name());

            WriteLocalCoord(vertBuilder,

                            uniformHandler,

                            *args.fShaderCaps,

                            gpArgs,

                            egp.fInPosition.asShaderVar(),

                            egp.fLocalMatrix,

                            &fLocalMatrixUniform);

            // For stroked ellipses, we use the full ellipse equation (x^2/a^2 + y^2/b^2 = 1)

            // to compute both the edges because we need two separate test equations for

            // the single offset.

            // For filled ellipses we can use a unit circle equation (x^2 + y^2 = 1), and warp

            // the distance by the gradient, non-uniformly scaled by the inverse of the

            // ellipse size.

            // On medium precision devices, we scale the denominator of the distance equation

            // before taking the inverse square root to minimize the chance that we're dividing

            // by zero, then we scale the result back.

            // for outer curve

            fragBuilder->codeAppendf("float2 offset = %s.xy;", ellipseOffsets.fsIn());

            if (egp.fStroke) {

                fragBuilder->codeAppendf("offset *= %s.xy;", ellipseRadii.fsIn());

            }

            fragBuilder->codeAppend("float test = dot(offset, offset) - 1.0;");

            if (egp.fUseScale) {

                fragBuilder->codeAppendf("float2 grad = 2.0*offset*(%s.z*%s.xy);",

                                         ellipseOffsets.fsIn(), ellipseRadii.fsIn());

            } else {

                fragBuilder->codeAppendf("float2 grad = 2.0*offset*%s.xy;", ellipseRadii.fsIn());

            }

            fragBuilder->codeAppend("float grad_dot = dot(grad, grad);");

            // avoid calling inversesqrt on zero.

            if (args.fShaderCaps->floatIs32Bits()) {

                fragBuilder->codeAppend("grad_dot = max(grad_dot, 1.1755e-38);");

            } else {

                fragBuilder->codeAppend("grad_dot = max(grad_dot, 6.1036e-5);");

            }

            if (egp.fUseScale) {

                fragBuilder->codeAppendf("float invlen = %s.z*inversesqrt(grad_dot);",

                                         ellipseOffsets.fsIn());

            } else {

                fragBuilder->codeAppend("float invlen = inversesqrt(grad_dot);");

            }

            fragBuilder->codeAppend("float edgeAlpha = saturate(0.5-test*invlen);");

            // for inner curve

            if (egp.fStroke) {

                fragBuilder->codeAppendf("offset = %s.xy*%s.zw;", ellipseOffsets.fsIn(),

                                         ellipseRadii.fsIn());

                fragBuilder->codeAppend("test = dot(offset, offset) - 1.0;");

                if (egp.fUseScale) {

                    fragBuilder->codeAppendf("grad = 2.0*offset*(%s.z*%s.zw);",

                                             ellipseOffsets.fsIn(), ellipseRadii.fsIn());

                } else {

                    fragBuilder->codeAppendf("grad = 2.0*offset*%s.zw;", ellipseRadii.fsIn());

                }

                fragBuilder->codeAppend("grad_dot = dot(grad, grad);");

                if (!args.fShaderCaps->floatIs32Bits()) {

                    fragBuilder->codeAppend("grad_dot = max(grad_dot, 6.1036e-5);");

                }

                if (egp.fUseScale) {

                    fragBuilder->codeAppendf("invlen = %s.z*inversesqrt(grad_dot);",

                                             ellipseOffsets.fsIn());

                } else {

                    fragBuilder->codeAppend("invlen = inversesqrt(grad_dot);");

                }

                fragBuilder->codeAppend("edgeAlpha *= saturate(0.5+test*invlen);");

            }

            fragBuilder->codeAppendf("half4 %s = half4(half(edgeAlpha));", args.fOutputCoverage);

        }

        using INHERITED = ProgramImpl;

        SkMatrix      fLocalMatrix = SkMatrix::InvalidMatrix();

        UniformHandle fLocalMatrixUniform;

    };

    Attribute fInPosition;

    Attribute fInColor;

    Attribute fInEllipseOffset;

    Attribute fInEllipseRadii;

    SkMatrix fLocalMatrix;

    bool fStroke;

    bool fUseScale;

    GR_DECLARE_GEOMETRY_PROCESSOR_TEST

    using INHERITED = GrGeometryProcessor;

};

GR_DEFINE_GEOMETRY_PROCESSOR_TEST(EllipseGeometryProcessor);

#if GR_TEST_UTILS

GrGeometryProcessor* EllipseGeometryProcessor::TestCreate(GrProcessorTestData* d) {

    bool stroke = d->fRandom->nextBool();

    bool wideColor = d->fRandom->nextBool();

    bool useScale = d->fRandom->nextBool();

    SkMatrix matrix = GrTest::TestMatrix(d->fRandom);

    return EllipseGeometryProcessor::Make(d->allocator(), stroke, wideColor, useScale, matrix);

}

#endif

///////////////////////////////////////////////////////////////////////////////

/**

 * The output of this effect is a modulation of the input color and coverage for an ellipse,

 * specified as a 2D offset from center for both the outer and inner paths (if stroked). The

 * implict equation used is for a unit circle (x^2 + y^2 - 1 = 0) and the edge corrected by

 * using differentials.

 *

 * The result is device-independent and can be used with any affine matrix.

 */

enum class DIEllipseStyle { kStroke = 0, kHairline, kFill };

class DIEllipseGeometryProcessor : public GrGeometryProcessor {

public:

    static GrGeometryProcessor* Make(SkArenaAlloc* arena, bool wideColor, bool useScale,

                                     const SkMatrix& viewMatrix, DIEllipseStyle style) {

        return arena->make([&](void* ptr) {

            return new (ptr) DIEllipseGeometryProcessor(wideColor, useScale, viewMatrix, style);

        });

    }

    ~DIEllipseGeometryProcessor() override {}

    const char* name() const override { return "DIEllipseGeometryProcessor"; }

    void addToKey(const GrShaderCaps& caps, GrProcessorKeyBuilder* b) const override {

        b->addBits(2, static_cast<uint32_t>(fStyle), "style");

        b->addBits(ProgramImpl::kMatrixKeyBits,

                   ProgramImpl::ComputeMatrixKey(caps, fViewMatrix),

                   "viewMatrixType");

    }

    std::unique_ptr<ProgramImpl> makeProgramImpl(const GrShaderCaps&) const override {

        return std::make_unique<Impl>();

    }

private:

    DIEllipseGeometryProcessor(bool wideColor, bool useScale, const SkMatrix& viewMatrix,

                               DIEllipseStyle style)

            : INHERITED(kDIEllipseGeometryProcessor_ClassID)

            , fViewMatrix(viewMatrix)

            , fUseScale(useScale)

            , fStyle(style) {

        fInPosition = {"inPosition", kFloat2_GrVertexAttribType, kFloat2_GrSLType};

        fInColor = MakeColorAttribute("inColor", wideColor);

        if (useScale) {

            fInEllipseOffsets0 = {"inEllipseOffsets0", kFloat3_GrVertexAttribType,

                                  kFloat3_GrSLType};

        } else {

            fInEllipseOffsets0 = {"inEllipseOffsets0", kFloat2_GrVertexAttribType,

                                  kFloat2_GrSLType};

        }

        fInEllipseOffsets1 = {"inEllipseOffsets1", kFloat2_GrVertexAttribType, kFloat2_GrSLType};

        this->setVertexAttributes(&fInPosition, 4);

    }

    class Impl : public ProgramImpl {

    public:

        void setData(const GrGLSLProgramDataManager& pdman,

                     const GrShaderCaps& shaderCaps,

                     const GrGeometryProcessor& geomProc) override {

            const auto& diegp = geomProc.cast<DIEllipseGeometryProcessor>();

            SetTransform(pdman, shaderCaps, fViewMatrixUniform, diegp.fViewMatrix, &fViewMatrix);

        }

    private:

        void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override {

            const auto& diegp = args.fGeomProc.cast<DIEllipseGeometryProcessor>();

            GrGLSLVertexBuilder* vertBuilder = args.fVertBuilder;

            GrGLSLVaryingHandler* varyingHandler = args.fVaryingHandler;

            GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;

            // emit attributes

            varyingHandler->emitAttributes(diegp);

            GrSLType offsetType = (diegp.fUseScale) ? kFloat3_GrSLType : kFloat2_GrSLType;

            GrGLSLVarying offsets0(offsetType);

            varyingHandler->addVarying("EllipseOffsets0", &offsets0);

            vertBuilder->codeAppendf("%s = %s;", offsets0.vsOut(), diegp.fInEllipseOffsets0.name());

            GrGLSLVarying offsets1(kFloat2_GrSLType);

            varyingHandler->addVarying("EllipseOffsets1", &offsets1);

            vertBuilder->codeAppendf("%s = %s;", offsets1.vsOut(), diegp.fInEllipseOffsets1.name());

            GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;

            fragBuilder->codeAppendf("half4 %s;", args.fOutputColor);

            varyingHandler->addPassThroughAttribute(diegp.fInColor.asShaderVar(),

                                                    args.fOutputColor);

            // Setup position

            WriteOutputPosition(vertBuilder,

                                uniformHandler,

                                *args.fShaderCaps,

                                gpArgs,

                                diegp.fInPosition.name(),

                                diegp.fViewMatrix,

                                &fViewMatrixUniform);

            gpArgs->fLocalCoordVar = diegp.fInPosition.asShaderVar();

            // for outer curve

            fragBuilder->codeAppendf("float2 scaledOffset = %s.xy;", offsets0.fsIn());

            fragBuilder->codeAppend("float test = dot(scaledOffset, scaledOffset) - 1.0;");

            fragBuilder->codeAppendf("float2 duvdx = dFdx(%s.xy);", offsets0.fsIn());

            fragBuilder->codeAppendf("float2 duvdy = dFdy(%s.xy);", offsets0.fsIn());

            fragBuilder->codeAppendf(

                    "float2 grad = float2(%s.x*duvdx.x + %s.y*duvdx.y,"

                    "                     %s.x*duvdy.x + %s.y*duvdy.y);",

                    offsets0.fsIn(), offsets0.fsIn(), offsets0.fsIn(), offsets0.fsIn());

            if (diegp.fUseScale) {

                fragBuilder->codeAppendf("grad *= %s.z;", offsets0.fsIn());

            }

            fragBuilder->codeAppend("float grad_dot = 4.0*dot(grad, grad);");

            // avoid calling inversesqrt on zero.

            if (args.fShaderCaps->floatIs32Bits()) {

                fragBuilder->codeAppend("grad_dot = max(grad_dot, 1.1755e-38);");

            } else {

                fragBuilder->codeAppend("grad_dot = max(grad_dot, 6.1036e-5);");

            }

            fragBuilder->codeAppend("float invlen = inversesqrt(grad_dot);");

            if (diegp.fUseScale) {

                fragBuilder->codeAppendf("invlen *= %s.z;", offsets0.fsIn());

            }

            if (DIEllipseStyle::kHairline == diegp.fStyle) {

                // can probably do this with one step

                fragBuilder->codeAppend("float edgeAlpha = saturate(1.0-test*invlen);");

                fragBuilder->codeAppend("edgeAlpha *= saturate(1.0+test*invlen);");

            } else {

                fragBuilder->codeAppend("float edgeAlpha = saturate(0.5-test*invlen);");

            }

            // for inner curve

            if (DIEllipseStyle::kStroke == diegp.fStyle) {

                fragBuilder->codeAppendf("scaledOffset = %s.xy;", offsets1.fsIn());

                fragBuilder->codeAppend("test = dot(scaledOffset, scaledOffset) - 1.0;");

                fragBuilder->codeAppendf("duvdx = float2(dFdx(%s));", offsets1.fsIn());

                fragBuilder->codeAppendf("duvdy = float2(dFdy(%s));", offsets1.fsIn());

                fragBuilder->codeAppendf(

                        "grad = float2(%s.x*duvdx.x + %s.y*duvdx.y,"

                        "              %s.x*duvdy.x + %s.y*duvdy.y);",

                        offsets1.fsIn(), offsets1.fsIn(), offsets1.fsIn(), offsets1.fsIn());

                if (diegp.fUseScale) {

                    fragBuilder->codeAppendf("grad *= %s.z;", offsets0.fsIn());

                }

                fragBuilder->codeAppend("grad_dot = 4.0*dot(grad, grad);");

                if (!args.fShaderCaps->floatIs32Bits()) {

                    fragBuilder->codeAppend("grad_dot = max(grad_dot, 6.1036e-5);");

                }

                fragBuilder->codeAppend("invlen = inversesqrt(grad_dot);");

                if (diegp.fUseScale) {

                    fragBuilder->codeAppendf("invlen *= %s.z;", offsets0.fsIn());

                }

                fragBuilder->codeAppend("edgeAlpha *= saturate(0.5+test*invlen);");

            }

            fragBuilder->codeAppendf("half4 %s = half4(half(edgeAlpha));", args.fOutputCoverage);

        }

        SkMatrix fViewMatrix = SkMatrix::InvalidMatrix();

        UniformHandle fViewMatrixUniform;

    };

    Attribute fInPosition;

    Attribute fInColor;

    Attribute fInEllipseOffsets0;

    Attribute fInEllipseOffsets1;

    SkMatrix fViewMatrix;

    bool fUseScale;

    DIEllipseStyle fStyle;

    GR_DECLARE_GEOMETRY_PROCESSOR_TEST

    using INHERITED = GrGeometryProcessor;

};

GR_DEFINE_GEOMETRY_PROCESSOR_TEST(DIEllipseGeometryProcessor);

#if GR_TEST_UTILS

GrGeometryProcessor* DIEllipseGeometryProcessor::TestCreate(GrProcessorTestData* d) {

    bool wideColor = d->fRandom->nextBool();

    bool useScale = d->fRandom->nextBool();

    SkMatrix matrix = GrTest::TestMatrix(d->fRandom);

    auto style = (DIEllipseStyle)(d->fRandom->nextRangeU(0, 2));

    return DIEllipseGeometryProcessor::Make(d->allocator(), wideColor, useScale, matrix, style);

}

#endif

///////////////////////////////////////////////////////////////////////////////

// We have two possible cases for geometry for a circle:

// In the case of a normal fill, we draw geometry for the circle as an octagon.

static const uint16_t gFillCircleIndices[] = {

        // enter the octagon

        // clang-format off

        0, 1, 8, 1, 2, 8,

        2, 3, 8, 3, 4, 8,

        4, 5, 8, 5, 6, 8,

        6, 7, 8, 7, 0, 8

        // clang-format on

};

// For stroked circles, we use two nested octagons.

static const uint16_t gStrokeCircleIndices[] = {

        // enter the octagon

        // clang-format off

        0, 1,  9, 0, 9,   8,

        1, 2, 10, 1, 10,  9,

        2, 3, 11, 2, 11, 10,

        3, 4, 12, 3, 12, 11,

        4, 5, 13, 4, 13, 12,

        5, 6, 14, 5, 14, 13,

        6, 7, 15, 6, 15, 14,

        7, 0,  8, 7,  8, 15,

        // clang-format on

};

// Normalized geometry for octagons that circumscribe and lie on a circle:

static constexpr SkScalar kOctOffset = 0.41421356237f;  // sqrt(2) - 1

static constexpr SkPoint kOctagonOuter[] = {

    SkPoint::Make(-kOctOffset, -1),

    SkPoint::Make( kOctOffset, -1),

    SkPoint::Make( 1, -kOctOffset),

    SkPoint::Make( 1,  kOctOffset),

    SkPoint::Make( kOctOffset, 1),

    SkPoint::Make(-kOctOffset, 1),

    SkPoint::Make(-1,  kOctOffset),

    SkPoint::Make(-1, -kOctOffset),

};

// cosine and sine of pi/8

static constexpr SkScalar kCosPi8 = 0.923579533f;

static constexpr SkScalar kSinPi8 = 0.382683432f;

static constexpr SkPoint kOctagonInner[] = {

    SkPoint::Make(-kSinPi8, -kCosPi8),

    SkPoint::Make( kSinPi8, -kCosPi8),

    SkPoint::Make( kCosPi8, -kSinPi8),

    SkPoint::Make( kCosPi8,  kSinPi8),

    SkPoint::Make( kSinPi8,  kCosPi8),

    SkPoint::Make(-kSinPi8,  kCosPi8),

    SkPoint::Make(-kCosPi8,  kSinPi8),

    SkPoint::Make(-kCosPi8, -kSinPi8),

};

static const int kIndicesPerFillCircle = SK_ARRAY_COUNT(gFillCircleIndices);

static const int kIndicesPerStrokeCircle = SK_ARRAY_COUNT(gStrokeCircleIndices);

static const int kVertsPerStrokeCircle = 16;

static const int kVertsPerFillCircle = 9;

static int circle_type_to_vert_count(bool stroked) {

    return stroked ? kVertsPerStrokeCircle : kVertsPerFillCircle;

}