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

#ifndef GrPipeline_DEFINED
#define GrPipeline_DEFINED

#include "include/core/SkMatrix.h"
#include "include/core/SkRefCnt.h"
#include "src/gpu/GrColor.h"
#include "src/gpu/GrDstProxyView.h"
#include "src/gpu/GrFragmentProcessor.h"
#include "src/gpu/GrProcessorSet.h"
#include "src/gpu/GrScissorState.h"
#include "src/gpu/GrSurfaceProxyView.h"
#include "src/gpu/GrUserStencilSettings.h"
#include "src/gpu/GrWindowRectsState.h"
#include "src/gpu/effects/GrCoverageSetOpXP.h"
#include "src/gpu/effects/GrDisableColorXP.h"
#include "src/gpu/effects/GrPorterDuffXferProcessor.h"
#include "src/gpu/effects/GrTextureEffect.h"
#include "src/gpu/geometry/GrRect.h"

class GrAppliedClip;
class GrAppliedHardClip;
struct GrGLSLBuiltinUniformHandles;
class GrGLSLProgramDataManager;
class GrOp;
class GrSurfaceDrawContext;

/**
 * This immutable object contains information needed to build a shader program and set API
 * state for a draw. It is used along with a GrGeometryProcessor and a source of geometric
 * data to draw.
 */
class GrPipeline {
public:
    ///////////////////////////////////////////////////////////////////////////
    /// @name Creation

    // Pipeline options that the caller may enable.
    // NOTE: This enum is extended later by GrPipeline::Flags.
    enum class InputFlags : uint8_t {
        kNone = 0,
        /**
         * Perform HW anti-aliasing. This means either HW FSAA, if supported by the render target,
         * or smooth-line rendering if a line primitive is drawn and line smoothing is supported by
         * the 3D API.
         */
        kHWAntialias = (1 << 0),
        /**
         * Cause every pixel to be rasterized that is touched by the triangle anywhere (not just at
         * pixel center). Additionally, if using MSAA, the sample mask will always have 100%
         * coverage.
         * NOTE: The primitive type must be a triangle type.
         */
        kConservativeRaster = (1 << 1),
        /**
         * Draws triangles as outlines.
         */
        kWireframe = (1 << 2),
        /**
         * Modifies the vertex shader so that vertices will be positioned at pixel centers.
         */
        kSnapVerticesToPixelCenters = (1 << 3),  // This value must be last. (See kLastInputFlag.)
    };

    struct InitArgs {
        InputFlags fInputFlags = InputFlags::kNone;
        const GrCaps* fCaps = nullptr;
        GrDstProxyView fDstProxyView;
        GrSwizzle fWriteSwizzle;
    };

    /**
     * Creates a simple pipeline with default settings and no processors. The provided blend mode
     * must be "Porter Duff" (<= kLastCoeffMode). If using GrScissorTest::kEnabled, the caller must
     * specify a scissor rectangle through the DynamicState struct.
     **/
    GrPipeline(GrScissorTest scissor,
               SkBlendMode blend,
               const GrSwizzle& writeSwizzle,
               InputFlags flags = InputFlags::kNone)
            : GrPipeline(scissor,
                         GrPorterDuffXPFactory::MakeNoCoverageXP(blend),
                         writeSwizzle,
                         flags) {}

    GrPipeline(GrScissorTest,
               sk_sp<const GrXferProcessor>,
               const GrSwizzle& writeSwizzle,
               InputFlags = InputFlags::kNone);

    GrPipeline(const InitArgs& args, sk_sp<const GrXferProcessor>, const GrAppliedHardClip&);
    GrPipeline(const InitArgs&, GrProcessorSet&&, GrAppliedClip&&);

    GrPipeline(const GrPipeline&) = delete;
    GrPipeline& operator=(const GrPipeline&) = delete;

    /// @}

    ///////////////////////////////////////////////////////////////////////////
    /// @name GrFragmentProcessors

    int numFragmentProcessors() const { return fFragmentProcessors.count(); }
    int numColorFragmentProcessors() const { return fNumColorProcessors; }
    bool isColorFragmentProcessor(int idx) const { return idx < fNumColorProcessors; }
    bool isCoverageFragmentProcessor(int idx) const { return idx >= fNumColorProcessors; }

    bool usesVaryingCoords() const {
        for (const auto& fp : fFragmentProcessors) {
            if (fp->usesVaryingCoords()) {
                return true;
            }
        }
        return false;
    }

    void visitTextureEffects(const std::function<void(const GrTextureEffect&)>&) const;

    const GrXferProcessor& getXferProcessor() const {
        if (fXferProcessor) {
            return *fXferProcessor;
        } else {
            // A null xp member means the common src-over case. GrXferProcessor's ref'ing
            // mechanism is not thread safe so we do not hold a ref on this global.
            return GrPorterDuffXPFactory::SimpleSrcOverXP();
        }
    }

    // Helper functions to quickly know if this GrPipeline will access the dst as a texture or an
    // input attachment.
    bool usesDstTexture() const { return this->dstProxyView() && !this->usesDstInputAttachment(); }
    bool usesDstInputAttachment() const {
        return this->dstSampleFlags()& GrDstSampleFlags::kAsInputAttachment;
    }

    /**
     * This returns the GrSurfaceProxyView for the texture used to access the dst color. If the
     * GrXferProcessor does not use the dst color then the proxy on the GrSurfaceProxyView will be
     * nullptr.
     */
    const GrSurfaceProxyView& dstProxyView() const { return fDstProxy.proxyView(); }

    SkIPoint dstTextureOffset() const { return fDstProxy.offset(); }

    GrDstSampleFlags dstSampleFlags() const { return fDstProxy.dstSampleFlags(); }

    /** If this GrXferProcessor uses a texture to access the dst color, returns that texture. */
    GrTexture* peekDstTexture() const {
        if (!this->usesDstTexture()) {
            return nullptr;
        }

        if (GrTextureProxy* dstProxy = this->dstProxyView().asTextureProxy()) {
            return dstProxy->peekTexture();
        }

        return nullptr;
    }

    const GrFragmentProcessor& getFragmentProcessor(int idx) const {
        return *fFragmentProcessors[idx];
    }

    /// @}

    bool isScissorTestEnabled() const {
        return SkToBool(fFlags & Flags::kScissorTestEnabled);
    }

    const GrWindowRectsState& getWindowRectsState() const { return fWindowRectsState; }

    bool isHWAntialiasState() const { return fFlags & InputFlags::kHWAntialias; }
    bool usesConservativeRaster() const { return fFlags & InputFlags::kConservativeRaster; }
    bool isWireframe() const { return fFlags & InputFlags::kWireframe; }
    bool snapVerticesToPixelCenters() const {
        return fFlags & InputFlags::kSnapVerticesToPixelCenters;
    }
    bool hasStencilClip() const {
        return SkToBool(fFlags & Flags::kHasStencilClip);
    }
#ifdef SK_DEBUG
    bool allProxiesInstantiated() const {
        for (int i = 0; i < fFragmentProcessors.count(); ++i) {
            if (!fFragmentProcessors[i]->isInstantiated()) {
                return false;
            }
        }
        if (this->dstProxyView().proxy()) {
            return this->dstProxyView().proxy()->isInstantiated();
        }

        return true;
    }
#endif

    GrXferBarrierType xferBarrierType(const GrCaps&) const;

    // Used by Vulkan and Metal to cache their respective pipeline objects
    void genKey(GrProcessorKeyBuilder*, const GrCaps&) const;

    const GrSwizzle& writeSwizzle() const { return fWriteSwizzle; }

    void visitProxies(const GrOp::VisitProxyFunc&) const;

    void setDstTextureUniforms(const GrGLSLProgramDataManager& pdm,
                               GrGLSLBuiltinUniformHandles* fBuiltinUniformHandles) const;

private:
    static constexpr uint8_t kLastInputFlag = (uint8_t)InputFlags::kSnapVerticesToPixelCenters;

    /** This is a continuation of the public "InputFlags" enum. */
    enum class Flags : uint8_t {
        kHasStencilClip = (kLastInputFlag << 1),
        kScissorTestEnabled = (kLastInputFlag << 2),
    };

    GR_DECL_BITFIELD_CLASS_OPS_FRIENDS(Flags);

    friend bool operator&(Flags, InputFlags);

    // A pipeline can contain up to three processors: color, paint coverage, and clip coverage.
    using FragmentProcessorArray = SkAutoSTArray<3, std::unique_ptr<const GrFragmentProcessor>>;

    GrDstProxyView fDstProxy;
    GrWindowRectsState fWindowRectsState;
    Flags fFlags;
    sk_sp<const GrXferProcessor> fXferProcessor;
    FragmentProcessorArray fFragmentProcessors;

    // This value is also the index in fFragmentProcessors where coverage processors begin.
    int fNumColorProcessors = 0;

    GrSwizzle fWriteSwizzle;
};

GR_MAKE_BITFIELD_CLASS_OPS(GrPipeline::InputFlags);
GR_MAKE_BITFIELD_CLASS_OPS(GrPipeline::Flags);

inline bool operator&(GrPipeline::Flags flags, GrPipeline::InputFlags inputFlag) {
    return (flags & (GrPipeline::Flags)inputFlag);
}

#endif