/*

 * Copyright 2021 Google LLC

 *

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

 * found in the LICENSE file.

 */

#ifndef skgpu_graphite_Renderer_DEFINED

#define skgpu_graphite_Renderer_DEFINED

#include "include/core/SkSpan.h"

#include "include/core/SkString.h"

#include "include/core/SkTypes.h"

#include "src/base/SkEnumBitMask.h"

#include "src/base/SkVx.h"

#include "src/gpu/graphite/Attribute.h"

#include "src/gpu/graphite/DrawTypes.h"

#include "src/gpu/graphite/ResourceTypes.h"

#include "src/gpu/graphite/Uniform.h"

#include <array>

#include <initializer_list>

#include <string>

#include <string_view>

#include <vector>

enum class SkPathFillType;

namespace skgpu { enum class MaskFormat; }

namespace skgpu::graphite {

class DrawWriter;

class DrawParams;

class PipelineDataGatherer;

class Rect;

class ResourceProvider;

class TextureDataBlock;

class Transform;

struct ResourceBindingRequirements;

enum class Coverage { kNone, kSingleChannel, kLCD };

struct Varying {

    const char* fName;

    SkSLType fType;

    // TODO: add modifier (e.g., flat and noperspective) support

};

/**

 * The actual technique for rasterizing a high-level draw recorded in a DrawList is handled by a

 * specific Renderer. Each technique has an associated singleton Renderer that decomposes the

 * technique into a series of RenderSteps that must be executed in the specified order for the draw.

 * However, the RenderStep executions for multiple draws can be re-arranged so batches of each

 * step can be performed in a larger GPU operation. This re-arranging relies on accurate

 * determination of the DisjointStencilIndex for each draw so that stencil steps are not corrupted

 * by another draw before its cover step is executed. It also relies on the CompressedPaintersOrder

 * for each draw to ensure steps are not re-arranged in a way that violates the original draw order.

 *

 * Renderer itself is non-virtual since it simply has to point to a list of RenderSteps. RenderSteps

 * on the other hand are virtual implement the technique specific functionality. It is entirely

 * possible for certain types of steps, e.g. a bounding box cover, to be re-used across different

 * Renderers even if the preceeding steps were different.

 *

 * All Renderers are accessed through the SharedContext's RendererProvider.

 */

class RenderStep {

public:

    virtual ~RenderStep() = default;

    // The DrawWriter is configured with the vertex and instance strides of the RenderStep, and its

    // primitive type. The recorded draws will be executed with a graphics pipeline compatible with

    // this RenderStep.

    virtual void writeVertices(DrawWriter*, const DrawParams&, skvx::ushort2 ssboIndices) const = 0;

    // Write out the uniform values (aligned for the layout), textures, and samplers. The uniform

    // values will be de-duplicated across all draws using the RenderStep before uploading to the

    // GPU, but it can be assumed the uniforms will be bound before the draws recorded in

    // 'writeVertices' are executed.

    virtual void writeUniformsAndTextures(const DrawParams&, PipelineDataGatherer*) const = 0;

    // Returns the body of a vertex function, which must define a float4 devPosition variable and

    // must write to an already-defined float2 stepLocalCoords variable. This will be automatically

    // set to a varying for the fragment shader if the paint requires local coords. This SkSL has

    // access to the variables declared by vertexAttributes(), instanceAttributes(), and uniforms().

    // The 'devPosition' variable's z must store the PaintDepth normalized to a float from [0, 1],

    // for each processed draw although the RenderStep can choose to upload it in any manner.

    //

    // NOTE: The above contract is mainly so that the entire SkSL program can be created by just str

    // concatenating struct definitions generated from the RenderStep and paint Combination

    // and then including the function bodies returned here.

    virtual std::string vertexSkSL() const = 0;

    // Emits code to set up textures and samplers. Should only be defined if hasTextures is true.

    virtual std::string texturesAndSamplersSkSL(const ResourceBindingRequirements&,

                                                int* nextBindingIndex) const {

        return R"()";

    }

    // Emits code to set up coverage value. Should only be defined if overridesCoverage is true.

    // When implemented the returned SkSL fragment should write its coverage into a

    // 'half4 outputCoverage' variable (defined in the calling code) with the actual

    // coverage splatted out into all four channels.

    virtual const char* fragmentCoverageSkSL() const { return R"()"; }

    // Emits code to set up a primitive color value. Should only be defined if emitsPrimitiveColor

    // is true. When implemented, the returned SkSL fragment should write its color into a

    // 'half4 primitiveColor' variable (defined in the calling code).

    virtual const char* fragmentColorSkSL() const { return R"()"; }

    uint32_t uniqueID() const { return fUniqueID; }

    // Returns a name formatted as "Subclass[variant]", where "Subclass" matches the C++ class name

    // and variant is a unique term describing instance's specific configuration.

    const char* name() const { return fName.c_str(); }

    bool requiresMSAA()        const { return SkToBool(fFlags & Flags::kRequiresMSAA);        }

    bool performsShading()     const { return SkToBool(fFlags & Flags::kPerformsShading);     }

    bool hasTextures()         const { return SkToBool(fFlags & Flags::kHasTextures);         }

    bool emitsPrimitiveColor() const { return SkToBool(fFlags & Flags::kEmitsPrimitiveColor); }

    bool outsetBoundsForAA()   const { return SkToBool(fFlags & Flags::kOutsetBoundsForAA);   }

    Coverage coverage() const { return RenderStep::GetCoverage(fFlags); }

    PrimitiveType primitiveType()  const { return fPrimitiveType;  }

    size_t        vertexStride()   const { return fVertexStride;   }

    size_t        instanceStride() const { return fInstanceStride; }

    size_t numUniforms()           const { return fUniforms.size();      }

    size_t numVertexAttributes()   const { return fVertexAttrs.size();   }

    size_t numInstanceAttributes() const { return fInstanceAttrs.size(); }

    // Name of an attribute containing both render step and shading SSBO indices, if used.

    static const char* ssboIndicesAttribute() { return "ssboIndices"; }

    // Name of a varying to pass SSBO indices to fragment shader. Both render step and shading

    // indices are passed, because render step uniforms are sometimes used for coverage.

    static const char* ssboIndicesVarying() { return "ssboIndicesVar"; }

    // The uniforms of a RenderStep are bound to the kRenderStep slot, the rest of the pipeline

    // may still use uniforms bound to other slots.

    SkSpan<const Uniform> uniforms()             const { return SkSpan(fUniforms);      }

    SkSpan<const Attribute> vertexAttributes()   const { return SkSpan(fVertexAttrs);   }

    SkSpan<const Attribute> instanceAttributes() const { return SkSpan(fInstanceAttrs); }

    SkSpan<const Varying>   varyings()           const { return SkSpan(fVaryings);      }

    const DepthStencilSettings& depthStencilSettings() const { return fDepthStencilSettings; }

    SkEnumBitMask<DepthStencilFlags> depthStencilFlags() const {

        return (fDepthStencilSettings.fStencilTestEnabled

                        ? DepthStencilFlags::kStencil : DepthStencilFlags::kNone) |

               (fDepthStencilSettings.fDepthTestEnabled || fDepthStencilSettings.fDepthWriteEnabled

                        ? DepthStencilFlags::kDepth : DepthStencilFlags::kNone);

    }

    // TODO: Actual API to do things

    // 6. Some Renderers benefit from being able to share vertices between RenderSteps. Must find a

    //    way to support that. It may mean that RenderSteps get state per draw.

    //    - Does Renderer make RenderStepFactories that create steps for each DrawList::Draw?

    //    - Does DrawList->DrawPass conversion build a separate array of blind data that the

    //      stateless Renderstep can refer to for {draw,step} pairs?

    //    - Does each DrawList::Draw have extra space (e.g. 8 bytes) that steps can cache data in?

protected:

    enum class Flags : unsigned {

        kNone                  = 0b0000000,

        kRequiresMSAA          = 0b0000001,

        kPerformsShading       = 0b0000010,

        kHasTextures           = 0b0000100,

        kEmitsCoverage         = 0b0001000,

        kLCDCoverage           = 0b0010000,

        kEmitsPrimitiveColor   = 0b0100000,

        kOutsetBoundsForAA     = 0b1000000,

    };

    SK_DECL_BITMASK_OPS_FRIENDS(Flags)

    // While RenderStep does not define the full program that's run for a draw, it defines the

    // entire vertex layout of the pipeline. This is not allowed to change, so can be provided to

    // the RenderStep constructor by subclasses.

    RenderStep(std::string_view className,

               std::string_view variantName,

               SkEnumBitMask<Flags> flags,

               std::initializer_list<Uniform> uniforms,

               PrimitiveType primitiveType,

               DepthStencilSettings depthStencilSettings,

               SkSpan<const Attribute> vertexAttrs,

               SkSpan<const Attribute> instanceAttrs,

               SkSpan<const Varying> varyings = {});

private:

    friend class Renderer; // for Flags

    // Cannot copy or move

    RenderStep(const RenderStep&) = delete;

    RenderStep(RenderStep&&)      = delete;

    static Coverage GetCoverage(SkEnumBitMask<Flags>);

    uint32_t fUniqueID;

    SkEnumBitMask<Flags> fFlags;

    PrimitiveType        fPrimitiveType;

    DepthStencilSettings fDepthStencilSettings;

    // TODO: When we always use C++17 for builds, we should be able to just let subclasses declare

    // constexpr arrays and point to those, but we need explicit storage for C++14.

    // Alternatively, if we imposed a max attr count, similar to Renderer's num render steps, we

    // could just have this be std::array and keep all attributes inline with the RenderStep memory.

    // On the other hand, the attributes are only needed when creating a new pipeline so it's not

    // that performance sensitive.

    std::vector<Uniform>   fUniforms;

    std::vector<Attribute> fVertexAttrs;

    std::vector<Attribute> fInstanceAttrs;

    std::vector<Varying>   fVaryings;

    size_t fVertexStride;   // derived from vertex attribute set

    size_t fInstanceStride; // derived from instance attribute set

    std::string fName;

};

SK_MAKE_BITMASK_OPS(RenderStep::Flags)

class Renderer {

    using StepFlags = RenderStep::Flags;

public:

    // The maximum number of render steps that any Renderer is allowed to have.

    static constexpr int kMaxRenderSteps = 4;

    const RenderStep& step(int i) const {

        SkASSERT(i >= 0 && i < fStepCount);

        return *fSteps[i];

    }

Unexecuted instantiation: skgpu::graphite::Renderer::step(int) const

Unexecuted instantiation: skgpu::graphite::Renderer::step(int) const

    SkSpan<const RenderStep* const> steps() const {

        SkASSERT(fStepCount > 0); // steps() should only be called on valid Renderers.

        return {fSteps.data(), static_cast<size_t>(fStepCount) };

    }

Unexecuted instantiation: skgpu::graphite::Renderer::steps() const

Unexecuted instantiation: skgpu::graphite::Renderer::steps() const

    const char*   name()           const { return fName.c_str(); }

    DrawTypeFlags drawTypes()      const { return fDrawTypes; }

    int           numRenderSteps() const { return fStepCount;    }

    bool requiresMSAA() const {

        return SkToBool(fStepFlags & StepFlags::kRequiresMSAA);

    }

    bool emitsPrimitiveColor() const {

        return SkToBool(fStepFlags & StepFlags::kEmitsPrimitiveColor);

    }

    bool outsetBoundsForAA() const {

        return SkToBool(fStepFlags & StepFlags::kOutsetBoundsForAA);

    }

    SkEnumBitMask<DepthStencilFlags> depthStencilFlags() const { return fDepthStencilFlags; }

    Coverage coverage() const { return RenderStep::GetCoverage(fStepFlags); }

private:

    friend class RendererProvider; // for ctors

    // Max render steps is 4, so just spell the options out for now...

    Renderer(std::string_view name, DrawTypeFlags drawTypes, const RenderStep* s1)

            : Renderer(name, drawTypes, std::array<const RenderStep*, 1>{s1}) {}

    Renderer(std::string_view name, DrawTypeFlags drawTypes,

             const RenderStep* s1, const RenderStep* s2)

            : Renderer(name, drawTypes, std::array<const RenderStep*, 2>{s1, s2}) {}

    Renderer(std::string_view name, DrawTypeFlags drawTypes,

             const RenderStep* s1, const RenderStep* s2, const RenderStep* s3)

            : Renderer(name, drawTypes, std::array<const RenderStep*, 3>{s1, s2, s3}) {}

    Renderer(std::string_view name, DrawTypeFlags drawTypes,

             const RenderStep* s1, const RenderStep* s2, const RenderStep* s3, const RenderStep* s4)

            : Renderer(name, drawTypes, std::array<const RenderStep*, 4>{s1, s2, s3, s4}) {}

    template<size_t N>

    Renderer(std::string_view name, DrawTypeFlags drawTypes, std::array<const RenderStep*, N> steps)

            : fName(name)

            , fDrawTypes(drawTypes)

            , fStepCount(SkTo<int>(N)) {

        static_assert(N <= kMaxRenderSteps);

        for (int i = 0 ; i < fStepCount; ++i) {

            fSteps[i] = steps[i];

            fStepFlags |= fSteps[i]->fFlags;

            fDepthStencilFlags |= fSteps[i]->depthStencilFlags();

        }

        // At least one step needs to actually shade.

        SkASSERT(fStepFlags & RenderStep::Flags::kPerformsShading);

    }

Unexecuted instantiation: skgpu::graphite::Renderer::Renderer<1ul>(std::__1::basic_string_view<char, std::__1::char_traits<char> >, skgpu::graphite::DrawTypeFlags, std::__1::array<skgpu::graphite::RenderStep const*, 1ul>)

Unexecuted instantiation: skgpu::graphite::Renderer::Renderer<3ul>(std::__1::basic_string_view<char, std::__1::char_traits<char> >, skgpu::graphite::DrawTypeFlags, std::__1::array<skgpu::graphite::RenderStep const*, 3ul>)

Unexecuted instantiation: skgpu::graphite::Renderer::Renderer<2ul>(std::__1::basic_string_view<char, std::__1::char_traits<char> >, skgpu::graphite::DrawTypeFlags, std::__1::array<skgpu::graphite::RenderStep const*, 2ul>)

Unexecuted instantiation: skgpu::graphite::Renderer::Renderer<1ul>(std::__1::basic_string_view<char, std::__1::char_traits<char> >, skgpu::graphite::DrawTypeFlags, std::__1::array<skgpu::graphite::RenderStep const*, 1ul>)

Unexecuted instantiation: skgpu::graphite::Renderer::Renderer<3ul>(std::__1::basic_string_view<char, std::__1::char_traits<char> >, skgpu::graphite::DrawTypeFlags, std::__1::array<skgpu::graphite::RenderStep const*, 3ul>)

Unexecuted instantiation: skgpu::graphite::Renderer::Renderer<2ul>(std::__1::basic_string_view<char, std::__1::char_traits<char> >, skgpu::graphite::DrawTypeFlags, std::__1::array<skgpu::graphite::RenderStep const*, 2ul>)

    // For RendererProvider to manage initialization; it will never expose a Renderer that is only

    // default-initialized and not replaced because it's algorithm is disabled by caps/options.

    Renderer() : fSteps(), fName(""), fStepCount(0) {}

    Renderer& operator=(Renderer&&) = default;

    std::array<const RenderStep*, kMaxRenderSteps> fSteps;

    std::string fName;

    DrawTypeFlags fDrawTypes = DrawTypeFlags::kNone;

    int fStepCount;

    SkEnumBitMask<StepFlags> fStepFlags = StepFlags::kNone;

    SkEnumBitMask<DepthStencilFlags> fDepthStencilFlags = DepthStencilFlags::kNone;

};

} // namespace skgpu::graphite

#endif // skgpu_graphite_Renderer_DEFINED