src/gpu/ops/GrQuadPerEdgeAA.h

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

#ifndef GrQuadPerEdgeAA_DEFINED
#define GrQuadPerEdgeAA_DEFINED

#include "GrColor.h"
#include "GrPrimitiveProcessor.h"
#include "GrQuad.h"
#include "GrSamplerState.h"
#include "GrTypesPriv.h"
#include "glsl/GrGLSLPrimitiveProcessor.h"
#include "SkPoint.h"
#include "SkPoint3.h"

class GrGLSLColorSpaceXformHelper;

namespace GrQuadPerEdgeAA {

    enum class Domain : bool { kNo = false, kYes = true };
    enum class ColorType { kNone, kByte, kHalf, kLast = kHalf };
    static const int kColorTypeCount = static_cast<int>(ColorType::kLast) + 1;

    // Specifies the vertex configuration for an op that renders per-edge AA quads. The vertex
    // order (when enabled) is device position, color, local position, domain, aa edge equations.
    // This order matches the constructor argument order of VertexSpec and is the order that
    // GPAttributes maintains. If hasLocalCoords is false, then the local quad type can be ignored.
    struct VertexSpec {
    public:
        VertexSpec(GrQuadType deviceQuadType, ColorType colorType, GrQuadType localQuadType,
                   bool hasLocalCoords, Domain domain, GrAAType aa)
                : fDeviceQuadType(static_cast<unsigned>(deviceQuadType))
                , fLocalQuadType(static_cast<unsigned>(localQuadType))
                , fHasLocalCoords(hasLocalCoords)
                , fColorType(static_cast<unsigned>(colorType))
                , fHasDomain(static_cast<unsigned>(domain))
                , fUsesCoverageAA(aa == GrAAType::kCoverage) { }

        GrQuadType deviceQuadType() const { return static_cast<GrQuadType>(fDeviceQuadType); }
        GrQuadType localQuadType() const { return static_cast<GrQuadType>(fLocalQuadType); }
        bool hasLocalCoords() const { return fHasLocalCoords; }
        ColorType colorType() const { return static_cast<ColorType>(fColorType); }
        bool hasVertexColors() const { return ColorType::kNone != this->colorType(); }
        bool hasDomain() const { return fHasDomain; }
        bool usesCoverageAA() const { return fUsesCoverageAA; }

        // Will always be 2 or 3
        int deviceDimensionality() const;
        // Will always be 0 if hasLocalCoords is false, otherwise will be 2 or 3
        int localDimensionality() const;

    private:
        static_assert(kGrQuadTypeCount <= 4, "GrQuadType doesn't fit in 2 bits");
        static_assert(kColorTypeCount <= 4, "Color doesn't fit in 2 bits");

        unsigned fDeviceQuadType: 2;
        unsigned fLocalQuadType: 2;
        unsigned fHasLocalCoords: 1;
        unsigned fColorType : 2;
        unsigned fHasDomain: 1;
        unsigned fUsesCoverageAA: 1;
    };

    // Utility class that manages the attribute state necessary to render a particular batch of
    // quads. It is similar to a geometry processor but is meant to be included in a has-a
    // relationship by specialized GP's that provide further functionality on top of the per-edge AA
    // coverage.
    //
    // For performance reasons, this uses fixed names for the attribute variables; since it defines
    // the majority of attributes a GP will likely need, this shouldn't be too limiting.
    //
    // In terms of responsibilities, the actual geometry processor must still call emitTransforms(),
    // using the localCoords() attribute as the 4th argument; it must set the transform data helper
    // to use the identity matrix; it must manage the color space transform for the quad's paint
    // color; it should include getKey() in the geometry processor's key builder; and it should
    // add these attributes at construction time.
    class GPAttributes {
    public:
        using Attribute = GrPrimitiveProcessor::Attribute;

        GPAttributes(const VertexSpec& vertexSpec);

        const Attribute& positionsAndMaxCoverage() const { return fPositions; }
        const Attribute& colors() const { return fColors; }
        const Attribute& localCoords() const { return fLocalCoords; }
        const Attribute& domain() const { return fDomain; }
        const Attribute& edgeDistances() const { return fAAEdgeDistances; }

        bool hasVertexColors() const { return fColors.isInitialized(); }

        bool usesCoverageAA() const { return fAAEdgeDistances.isInitialized(); }

        bool hasLocalCoords() const { return fLocalCoords.isInitialized(); }

        bool hasDomain() const { return fDomain.isInitialized(); }

        bool needsPerspectiveInterpolation() const;

        const Attribute* attributes() const { return &fPositions; }
        int attributeCount() const {  return 5; }

        uint32_t getKey() const;

        // Functions to be called at appropriate times in a processor's onEmitCode() block. These
        // are separated into discrete pieces so that they can be interleaved with the rest of the
        // processor's shader code as needed. The functions take char* arguments for the names of
        // variables the emitted code must declare, so that the calling GP can ensure there's no
        // naming conflicts with their own code.

        // Returns the GrShaderVar to store in GrGPArgs
        GrShaderVar emitPosition(GrGLSLPrimitiveProcessor::EmitArgs& args,
                                 const char* posVarName) const;

        void emitColor(GrGLSLPrimitiveProcessor::EmitArgs& args, const char* colorVarName) const;

        // localCoordName will be declared as a float2, with any domain applied after any
        // perspective division is performed.
        //
        // Note: this should only be used if the local coordinates need to be passed separately
        // from the standard coord transform process that is used by FPs.
        // FIXME: This can go in two directions from here, if GrTextureOp stops needing per-quad
        // domains it can be removed and GrTextureOp rewritten to use coord transforms. Or
        // emitTransform() in the primitive builder can be updated to have a notion of domain for
        // local coords, and all domain-needing code (blurs, filters, etc.) can switch to that magic
        void emitExplicitLocalCoords(GrGLSLPrimitiveProcessor::EmitArgs& args,
                                     const char* localCoordName, const char* domainVarName) const;

        void emitCoverage(GrGLSLPrimitiveProcessor::EmitArgs& args, const char* edgeDistName) const;
    private:
        Attribute fPositions;       // named "position" in SkSL
        Attribute fColors;          // named "color" in SkSL
        Attribute fLocalCoords;     // named "localCoord" in SkSL
        Attribute fDomain;          // named "domain" in SkSL
        Attribute fAAEdgeDistances; // named "aaEdgeDist" in SkSL

        // The positions attribute is always a vec4 and can't be used to encode perspectiveness
        bool fNeedsPerspective;
    };

    // Fill vertices with the vertex data needed to represent the given quad. The device position,
    // local coords, vertex color, domain, and edge coefficients will be written and/or computed
    // based on the configuration in the vertex spec; if that attribute is disabled in the spec,
    // then its corresponding function argument is ignored.
    //
    // Returns the advanced pointer in vertices.
    // TODO4F: Switch GrColor to GrVertexColor
    void* Tessellate(void* vertices, const VertexSpec& spec, const GrPerspQuad& deviceQuad,
                     const SkPMColor4f& color, const GrPerspQuad& localQuad, const SkRect& domain,
                     GrQuadAAFlags aa);

} // namespace GrQuadPerEdgeAA

#endif // GrQuadPerEdgeAA_DEFINED