blob: 5baf9852849b0a82717e891e2d9dbffcf3e53bf8 [file] [log] [blame]
/*
* 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 GrMeshDrawOp_DEFINED
#define GrMeshDrawOp_DEFINED
#include "src/gpu/GrAppliedClip.h"
#include "src/gpu/GrGeometryProcessor.h"
#include "src/gpu/GrMesh.h"
#include "src/gpu/ops/GrDrawOp.h"
#include <type_traits>
class GrAtlasManager;
class GrCaps;
class GrStrikeCache;
class GrOpFlushState;
/**
* Base class for mesh-drawing GrDrawOps.
*/
class GrMeshDrawOp : public GrDrawOp {
public:
/** Abstract interface that represents a destination for a GrMeshDrawOp. */
class Target;
protected:
GrMeshDrawOp(uint32_t classID);
/** Helper for rendering repeating meshes using a patterned index buffer. This class creates the
space for the vertices and flushes the draws to the GrMeshDrawOp::Target. */
class PatternHelper {
public:
PatternHelper(Target*, GrPrimitiveType, size_t vertexStride,
sk_sp<const GrBuffer> indexBuffer, int verticesPerRepetition,
int indicesPerRepetition, int repeatCount);
/** Called to issue draws to the GrMeshDrawOp::Target.*/
void recordDraw(Target*, sk_sp<const GrGeometryProcessor>) const;
void recordDraw(Target*, sk_sp<const GrGeometryProcessor>,
const GrPipeline::FixedDynamicState*) const;
void* vertices() const { return fVertices; }
protected:
PatternHelper() = default;
void init(Target*, GrPrimitiveType, size_t vertexStride, sk_sp<const GrBuffer> indexBuffer,
int verticesPerRepetition, int indicesPerRepetition, int repeatCount);
private:
void* fVertices = nullptr;
GrMesh* fMesh = nullptr;
};
static const int kVerticesPerQuad = 4;
static const int kIndicesPerQuad = 6;
/** A specialization of InstanceHelper for quad rendering. */
class QuadHelper : private PatternHelper {
public:
QuadHelper() = delete;
QuadHelper(Target* target, size_t vertexStride, int quadsToDraw);
using PatternHelper::recordDraw;
using PatternHelper::vertices;
private:
typedef PatternHelper INHERITED;
};
private:
void onPrepare(GrOpFlushState* state) final;
virtual void onPrepareDraws(Target*) = 0;
typedef GrDrawOp INHERITED;
};
class GrMeshDrawOp::Target {
public:
virtual ~Target() {}
/** Adds a draw of a mesh. */
virtual void recordDraw(
sk_sp<const GrGeometryProcessor>, const GrMesh[], int meshCnt,
const GrPipeline::FixedDynamicState*, const GrPipeline::DynamicStateArrays*) = 0;
/**
* Helper for drawing GrMesh(es) with zero primProc textures and no dynamic state besides the
* scissor clip.
*/
void recordDraw(sk_sp<const GrGeometryProcessor> gp, const GrMesh meshes[], int meshCnt = 1) {
static constexpr int kZeroPrimProcTextures = 0;
auto fixedDynamicState = this->makeFixedDynamicState(kZeroPrimProcTextures);
this->recordDraw(std::move(gp), meshes, meshCnt, fixedDynamicState, nullptr);
}
/**
* Makes space for vertex data. The returned pointer is the location where vertex data
* should be written. On return the buffer that will hold the data as well as an offset into
* the buffer (in 'vertexSize' units) where the data will be placed.
*/
virtual void* makeVertexSpace(size_t vertexSize, int vertexCount, sk_sp<const GrBuffer>*,
int* startVertex) = 0;
/**
* Makes space for index data. The returned pointer is the location where index data
* should be written. On return the buffer that will hold the data as well as an offset into
* the buffer (in uint16_t units) where the data will be placed.
*/
virtual uint16_t* makeIndexSpace(int indexCount, sk_sp<const GrBuffer>*, int* startIndex) = 0;
/**
* This is similar to makeVertexSpace. It allows the caller to use up to 'actualVertexCount'
* vertices in the returned pointer, which may exceed 'minVertexCount'.
* 'fallbackVertexCount' is the maximum number of vertices that should be allocated if a new
* buffer is allocated on behalf of this request.
*/
virtual void* makeVertexSpaceAtLeast(size_t vertexSize, int minVertexCount,
int fallbackVertexCount, sk_sp<const GrBuffer>*,
int* startVertex, int* actualVertexCount) = 0;
/**
* This is similar to makeIndexSpace. It allows the caller to use up to 'actualIndexCount'
* indices in the returned pointer, which may exceed 'minIndexCount'.
* 'fallbackIndexCount' is the maximum number of indices that should be allocated if a new
* buffer is allocated on behalf of this request.
*/
virtual uint16_t* makeIndexSpaceAtLeast(int minIndexCount, int fallbackIndexCount,
sk_sp<const GrBuffer>*, int* startIndex,
int* actualIndexCount) = 0;
/** Helpers for ops which over-allocate and then return excess data to the pool. */
virtual void putBackIndices(int indices) = 0;
virtual void putBackVertices(int vertices, size_t vertexStride) = 0;
GrMesh* allocMesh(GrPrimitiveType primitiveType) {
return this->allocator()->make<GrMesh>(primitiveType);
}
GrMesh* allocMeshes(int n) { return this->allocator()->makeArray<GrMesh>(n); }
GrPipeline::DynamicStateArrays* allocDynamicStateArrays(int numMeshes,
int numPrimitiveProcessorTextures,
bool allocScissors);
GrPipeline::FixedDynamicState* makeFixedDynamicState(int numPrimitiveProcessorTextures);
virtual GrRenderTargetProxy* proxy() const = 0;
virtual const GrAppliedClip* appliedClip() = 0;
virtual GrAppliedClip detachAppliedClip() = 0;
virtual const GrXferProcessor::DstProxy& dstProxy() const = 0;
virtual GrResourceProvider* resourceProvider() const = 0;
uint32_t contextUniqueID() const { return this->resourceProvider()->contextUniqueID(); }
virtual GrStrikeCache* glyphCache() const = 0;
virtual GrAtlasManager* atlasManager() const = 0;
// This should be called during onPrepare of a GrOp. The caller should add any proxies to the
// array it will use that it did not access during a call to visitProxies. This is usually the
// case for atlases.
virtual SkTArray<GrTextureProxy*, true>* sampledProxyArray() = 0;
virtual const GrCaps& caps() const = 0;
virtual GrDeferredUploadTarget* deferredUploadTarget() = 0;
private:
virtual SkArenaAlloc* allocator() = 0;
};
#endif