/*

 * Copyright 2015 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/ganesh/ops/DrawAtlasOp.h"

#include "include/core/SkMatrix.h"

#include "include/core/SkRSXform.h"

#include "include/core/SkRect.h"

#include "include/core/SkScalar.h"

#include "include/core/SkString.h"

#include "include/private/SkColorData.h"

#include "include/private/base/SkAssert.h"

#include "include/private/base/SkDebug.h"

#include "include/private/base/SkMath.h"

#include "include/private/base/SkPoint_impl.h"

#include "include/private/base/SkTArray.h"

#include "include/private/base/SkTo.h"

#include "include/private/gpu/ganesh/GrTypesPriv.h"

#include "src/base/SkRandom.h"

#include "src/base/SkSafeMath.h"

#include "src/core/SkMatrixPriv.h"

#include "src/core/SkRectPriv.h"

#include "src/gpu/ganesh/GrAppliedClip.h"

#include "src/gpu/ganesh/GrCaps.h"

#include "src/gpu/ganesh/GrColor.h"

#include "src/gpu/ganesh/GrDefaultGeoProcFactory.h"

#include "src/gpu/ganesh/GrDrawOpTest.h"

#include "src/gpu/ganesh/GrGeometryProcessor.h"

#include "src/gpu/ganesh/GrOpFlushState.h"

#include "src/gpu/ganesh/GrPaint.h"

#include "src/gpu/ganesh/GrProcessorAnalysis.h"

#include "src/gpu/ganesh/GrProcessorSet.h"

#include "src/gpu/ganesh/GrProgramInfo.h"

#include "src/gpu/ganesh/GrTestUtils.h"

#include "src/gpu/ganesh/SkGr.h"

#include "src/gpu/ganesh/ops/GrDrawOp.h"

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

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

#include <cstdint>

#include <cstring>

#include <utility>

class GrDstProxyView;

class GrMeshDrawTarget;

class GrSurfaceProxyView;

class SkArenaAlloc;

enum class GrXferBarrierFlags;

struct GrSimpleMesh;

namespace skgpu::ganesh {

class SurfaceDrawContext;

}

using namespace skia_private;

namespace {

class DrawAtlasOpImpl final : public GrMeshDrawOp {

private:

    using Helper = GrSimpleMeshDrawOpHelper;

public:

    DEFINE_OP_CLASS_ID

    DrawAtlasOpImpl(GrProcessorSet*, const SkPMColor4f& color,

                    const SkMatrix& viewMatrix, GrAAType, int spriteCount, const SkRSXform* xforms,

                    const SkRect* rects, const SkColor* colors);

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

    void visitProxies(const GrVisitProxyFunc& func) const override {

        if (fProgramInfo) {

            fProgramInfo->visitFPProxies(func);

        } else {

            fHelper.visitProxies(func);

        }

    }

    FixedFunctionFlags fixedFunctionFlags() const override;

    GrProcessorSet::Analysis finalize(const GrCaps&, const GrAppliedClip*, GrClampType) override;

private:

    GrProgramInfo* programInfo() override { return fProgramInfo; }

    void onCreateProgramInfo(const GrCaps*,

                             SkArenaAlloc*,

                             const GrSurfaceProxyView& writeView,

                             bool usesMSAASurface,

                             GrAppliedClip&&,

                             const GrDstProxyView&,

                             GrXferBarrierFlags renderPassXferBarriers,

                             GrLoadOp colorLoadOp) override;

    void onPrepareDraws(GrMeshDrawTarget*) override;

    void onExecute(GrOpFlushState*, const SkRect& chainBounds) override;

#if defined(GPU_TEST_UTILS)

    SkString onDumpInfo() const override;

#endif

    const SkPMColor4f& color() const { return fColor; }

    const SkMatrix& viewMatrix() const { return fViewMatrix; }

    bool hasColors() const { return fHasColors; }

    int quadCount() const { return fQuadCount; }

    CombineResult onCombineIfPossible(GrOp* t, SkArenaAlloc*, const GrCaps&) override;

    struct Geometry {

        SkPMColor4f fColor;

        TArray<uint8_t, true> fVerts;

    };

    STArray<1, Geometry, true> fGeoData;

    Helper fHelper;

    SkMatrix fViewMatrix;

    SkPMColor4f fColor;

    int fQuadCount;

    bool fHasColors;

    GrSimpleMesh* fMesh = nullptr;

    GrProgramInfo* fProgramInfo = nullptr;

};

GrGeometryProcessor* make_gp(SkArenaAlloc* arena,

                             bool hasColors,

                             const SkPMColor4f& color,

                             const SkMatrix& viewMatrix) {

    using namespace GrDefaultGeoProcFactory;

    Color gpColor(color);

    if (hasColors) {

        gpColor.fType = Color::kPremulGrColorAttribute_Type;

    }

    return GrDefaultGeoProcFactory::Make(arena, gpColor, Coverage::kSolid_Type,

                                         LocalCoords::kHasExplicit_Type, viewMatrix);

}

DrawAtlasOpImpl::DrawAtlasOpImpl(GrProcessorSet* processorSet, const SkPMColor4f& color,

                                 const SkMatrix& viewMatrix, GrAAType aaType, int spriteCount,

                                 const SkRSXform* xforms, const SkRect* rects,

                                 const SkColor* colors)

        : GrMeshDrawOp(ClassID()), fHelper(processorSet, aaType), fColor(color) {

    SkASSERT(xforms);

    SkASSERT(rects);

    SkASSERT(spriteCount >= 0);

    fViewMatrix = viewMatrix;

    Geometry& installedGeo = fGeoData.push_back();

    installedGeo.fColor = color;

    // Figure out stride and offsets

    // Order within the vertex is: position [color] texCoord

    size_t texOffset = sizeof(SkPoint);

    size_t vertexStride = 2 * sizeof(SkPoint);

    fHasColors = SkToBool(colors);

    if (colors) {

        texOffset += sizeof(GrColor);

        vertexStride += sizeof(GrColor);

    }

    // Bail out if we'd overflow from a really large draw

    if (spriteCount > SK_MaxS32 / static_cast<int>(4 * vertexStride)) {

        return;

    }

    // Compute buffer size and alloc buffer

    fQuadCount = spriteCount;

    int allocSize = static_cast<int>(4 * vertexStride * spriteCount);

    installedGeo.fVerts.reset(allocSize);

    uint8_t* currVertex = installedGeo.fVerts.begin();

    SkRect bounds = SkRectPriv::MakeLargestInverted();

    // TODO4F: Preserve float colors

    int paintAlpha = GrColorUnpackA(installedGeo.fColor.toBytes_RGBA());

    for (int spriteIndex = 0; spriteIndex < spriteCount; ++spriteIndex) {

        // Transform rect

        SkPoint strip[4];

        const SkRect& currRect = rects[spriteIndex];

        xforms[spriteIndex].toTriStrip(currRect.width(), currRect.height(), strip);

        // Copy colors if necessary

        if (colors) {

            // convert to GrColor

            SkColor spriteColor = colors[spriteIndex];

            if (paintAlpha != 255) {

                spriteColor = SkColorSetA(spriteColor,

                                          SkMulDiv255Round(SkColorGetA(spriteColor), paintAlpha));

            }

            GrColor grColor = SkColorToPremulGrColor(spriteColor);

            *(reinterpret_cast<GrColor*>(currVertex + sizeof(SkPoint))) = grColor;

            *(reinterpret_cast<GrColor*>(currVertex + vertexStride + sizeof(SkPoint))) = grColor;

            *(reinterpret_cast<GrColor*>(currVertex + 2 * vertexStride + sizeof(SkPoint))) =

                    grColor;

            *(reinterpret_cast<GrColor*>(currVertex + 3 * vertexStride + sizeof(SkPoint))) =

                    grColor;

        }

        // Copy position and uv to verts

        *(reinterpret_cast<SkPoint*>(currVertex)) = strip[0];

        *(reinterpret_cast<SkPoint*>(currVertex + texOffset)) =

                SkPoint::Make(currRect.fLeft, currRect.fTop);

        SkRectPriv::GrowToInclude(&bounds, strip[0]);

        currVertex += vertexStride;

        *(reinterpret_cast<SkPoint*>(currVertex)) = strip[1];

        *(reinterpret_cast<SkPoint*>(currVertex + texOffset)) =

                SkPoint::Make(currRect.fLeft, currRect.fBottom);

        SkRectPriv::GrowToInclude(&bounds, strip[1]);

        currVertex += vertexStride;

        *(reinterpret_cast<SkPoint*>(currVertex)) = strip[2];

        *(reinterpret_cast<SkPoint*>(currVertex + texOffset)) =

                SkPoint::Make(currRect.fRight, currRect.fTop);

        SkRectPriv::GrowToInclude(&bounds, strip[2]);

        currVertex += vertexStride;

        *(reinterpret_cast<SkPoint*>(currVertex)) = strip[3];

        *(reinterpret_cast<SkPoint*>(currVertex + texOffset)) =

                SkPoint::Make(currRect.fRight, currRect.fBottom);

        SkRectPriv::GrowToInclude(&bounds, strip[3]);

        currVertex += vertexStride;

    }

    this->setTransformedBounds(bounds, viewMatrix, HasAABloat::kNo, IsHairline::kNo);

}

Unexecuted instantiation: DrawAtlasOp.cpp:(anonymous namespace)::DrawAtlasOpImpl::DrawAtlasOpImpl(GrProcessorSet*, SkRGBA4f<(SkAlphaType)2> const&, SkMatrix const&, GrAAType, int, SkRSXform const*, SkRect const*, unsigned int const*)

Unexecuted instantiation: DrawAtlasOp.cpp:(anonymous namespace)::DrawAtlasOpImpl::DrawAtlasOpImpl(GrProcessorSet*, SkRGBA4f<(SkAlphaType)2> const&, SkMatrix const&, GrAAType, int, SkRSXform const*, SkRect const*, unsigned int const*)

#if defined(GPU_TEST_UTILS)

SkString DrawAtlasOpImpl::onDumpInfo() const {

    SkString string;

    for (const auto& geo : fGeoData) {

        string.appendf("Color: 0x%08x, Quads: %d\n", geo.fColor.toBytes_RGBA(),

                       geo.fVerts.size() / 4);

    }

    string += fHelper.dumpInfo();

    return string;

}

#endif

void DrawAtlasOpImpl::onCreateProgramInfo(const GrCaps* caps,

                                          SkArenaAlloc* arena,

                                          const GrSurfaceProxyView& writeView,

                                          bool usesMSAASurface,

                                          GrAppliedClip&& appliedClip,

                                          const GrDstProxyView& dstProxyView,

                                          GrXferBarrierFlags renderPassXferBarriers,

                                          GrLoadOp colorLoadOp) {

    // Setup geometry processor

    GrGeometryProcessor* gp = make_gp(arena,

                                      this->hasColors(),

                                      this->color(),

                                      this->viewMatrix());

    fProgramInfo = fHelper.createProgramInfo(caps, arena, writeView, usesMSAASurface,

                                             std::move(appliedClip), dstProxyView, gp,

                                             GrPrimitiveType::kTriangles, renderPassXferBarriers,

                                             colorLoadOp);

}

void DrawAtlasOpImpl::onPrepareDraws(GrMeshDrawTarget* target) {

    if (!fProgramInfo) {

        this->createProgramInfo(target);

    }

    int instanceCount = fGeoData.size();

    size_t vertexStride = fProgramInfo->geomProc().vertexStride();

    int numQuads = this->quadCount();

    QuadHelper helper(target, vertexStride, numQuads);

    void* verts = helper.vertices();

    if (!verts) {

        SkDebugf("Could not allocate vertices\n");

        return;

    }

    uint8_t* vertPtr = reinterpret_cast<uint8_t*>(verts);

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

        const Geometry& args = fGeoData[i];

        size_t allocSize = args.fVerts.size();

        memcpy(vertPtr, args.fVerts.begin(), allocSize);

        vertPtr += allocSize;

    }

    fMesh = helper.mesh();

}

void DrawAtlasOpImpl::onExecute(GrOpFlushState* flushState, const SkRect& chainBounds) {

    if (!fProgramInfo || !fMesh) {

        return;

    }

    flushState->bindPipelineAndScissorClip(*fProgramInfo, chainBounds);

    flushState->bindTextures(fProgramInfo->geomProc(), nullptr, fProgramInfo->pipeline());

    flushState->drawMesh(*fMesh);

}

GrOp::CombineResult DrawAtlasOpImpl::onCombineIfPossible(GrOp* t,

                                                         SkArenaAlloc*,

                                                         const GrCaps& caps) {

    auto that = t->cast<DrawAtlasOpImpl>();

    if (!fHelper.isCompatible(that->fHelper, caps, this->bounds(), that->bounds())) {

        return CombineResult::kCannotCombine;

    }

    // We currently use a uniform viewmatrix for this op.

    if (!SkMatrixPriv::CheapEqual(this->viewMatrix(), that->viewMatrix())) {

        return CombineResult::kCannotCombine;

    }

    if (this->hasColors() != that->hasColors()) {

        return CombineResult::kCannotCombine;

    }

    if (!this->hasColors() && this->color() != that->color()) {

        return CombineResult::kCannotCombine;

    }

    SkSafeMath safeMath;

    int newQuadCount = safeMath.addInt(fQuadCount, that->quadCount());

    if (!safeMath) {

        return CombineResult::kCannotCombine;

    }

    fGeoData.push_back_n(that->fGeoData.size(), that->fGeoData.begin());

    fQuadCount = newQuadCount;

    return CombineResult::kMerged;

}

GrDrawOp::FixedFunctionFlags DrawAtlasOpImpl::fixedFunctionFlags() const {

    return fHelper.fixedFunctionFlags();

}

GrProcessorSet::Analysis DrawAtlasOpImpl::finalize(const GrCaps& caps,

                                                   const GrAppliedClip* clip,

                                                   GrClampType clampType) {

    GrProcessorAnalysisColor gpColor;

    if (this->hasColors()) {

        gpColor.setToUnknown();

    } else {

        gpColor.setToConstant(fColor);

    }

    auto result = fHelper.finalizeProcessors(caps, clip, clampType,

                                             GrProcessorAnalysisCoverage::kNone, &gpColor);

    if (gpColor.isConstant(&fColor)) {

        fHasColors = false;

    }

    return result;

}

} // anonymous namespace

namespace skgpu::ganesh::DrawAtlasOp {

GrOp::Owner Make(GrRecordingContext* context,

                 GrPaint&& paint,

                 const SkMatrix& viewMatrix,

                 GrAAType aaType,

                 int spriteCount,

                 const SkRSXform* xforms,

                 const SkRect* rects,

                 const SkColor* colors) {

    return GrSimpleMeshDrawOpHelper::FactoryHelper<DrawAtlasOpImpl>(context, std::move(paint),

                                                                    viewMatrix, aaType,

                                                                    spriteCount, xforms,

                                                                    rects, colors);

}

}  // namespace skgpu::ganesh::DrawAtlasOp

#if defined(GPU_TEST_UTILS)

static SkRSXform random_xform(SkRandom* random) {

    static const SkScalar kMinExtent = -100.f;

    static const SkScalar kMaxExtent = 100.f;

    static const SkScalar kMinScale = 0.1f;

    static const SkScalar kMaxScale = 100.f;

    static const SkScalar kMinRotate = -SK_ScalarPI;

    static const SkScalar kMaxRotate = SK_ScalarPI;

    SkRSXform xform = SkRSXform::MakeFromRadians(random->nextRangeScalar(kMinScale, kMaxScale),

                                                 random->nextRangeScalar(kMinRotate, kMaxRotate),

                                                 random->nextRangeScalar(kMinExtent, kMaxExtent),

                                                 random->nextRangeScalar(kMinExtent, kMaxExtent),

                                                 random->nextRangeScalar(kMinExtent, kMaxExtent),

                                                 random->nextRangeScalar(kMinExtent, kMaxExtent));

    return xform;

}

static SkRect random_texRect(SkRandom* random) {

    static const SkScalar kMinCoord = 0.0f;

    static const SkScalar kMaxCoord = 1024.f;

    SkRect texRect = SkRect::MakeLTRB(random->nextRangeScalar(kMinCoord, kMaxCoord),

                                      random->nextRangeScalar(kMinCoord, kMaxCoord),

                                      random->nextRangeScalar(kMinCoord, kMaxCoord),

                                      random->nextRangeScalar(kMinCoord, kMaxCoord));

    texRect.sort();

    return texRect;

}

static void randomize_params(uint32_t count, SkRandom* random, TArray<SkRSXform>* xforms,

                             TArray<SkRect>* texRects, TArray<GrColor>* colors,

                             bool hasColors) {

    for (uint32_t v = 0; v < count; v++) {

        xforms->push_back(random_xform(random));

        texRects->push_back(random_texRect(random));

        if (hasColors) {

            colors->push_back(GrTest::RandomColor(random));

        }

    }

}

GR_DRAW_OP_TEST_DEFINE(DrawAtlasOp) {

    uint32_t spriteCount = random->nextRangeU(1, 100);

    TArray<SkRSXform> xforms(spriteCount);

    TArray<SkRect> texRects(spriteCount);

    TArray<GrColor> colors;

    bool hasColors = random->nextBool();

    randomize_params(spriteCount, random, &xforms, &texRects, &colors, hasColors);

    SkMatrix viewMatrix = GrTest::TestMatrix(random);

    GrAAType aaType = GrAAType::kNone;

    if (numSamples > 1 && random->nextBool()) {

        aaType = GrAAType::kMSAA;

    }

    return skgpu::ganesh::DrawAtlasOp::Make(context,

                                            std::move(paint),

                                            viewMatrix,

                                            aaType,

                                            spriteCount,

                                            xforms.begin(),

                                            texRects.begin(),

                                            hasColors ? colors.begin() : nullptr);

}

#endif