blob: 43a96b358c0359d7fb2faa7b166281acffb721b3 [file] [log] [blame]
/*
* 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 GrVertexChunkArray_DEFINED
#define GrVertexChunkArray_DEFINED
#include "include/core/SkRefCnt.h"
#include "include/private/base/SkNoncopyable.h"
#include "include/private/base/SkTArray.h"
#include "include/private/base/SkTypeTraits.h"
#include "src/gpu/BufferWriter.h"
#include "src/gpu/ganesh/GrBuffer.h"
class GrMeshDrawTarget;
// Represents a chunk of vertex data. Use with GrVertexChunkArray and GrVertexChunkBuilder. We write
// the data out in chunks when we don't start out knowing exactly how many vertices (or instances)
// we will end up writing.
struct GrVertexChunk {
sk_sp<const GrBuffer> fBuffer;
int fCount = 0;
int fBase; // baseVertex or baseInstance, depending on the use case.
static_assert(::sk_is_trivially_relocatable<decltype(fBuffer)>::value);
using sk_is_trivially_relocatable = std::true_type;
};
// Represents an array of GrVertexChunks.
//
// We only preallocate 1 chunk because if the array needs to grow, then we're also allocating a
// brand new GPU buffer anyway.
using GrVertexChunkArray = skia_private::STArray<1, GrVertexChunk>;
// Builds a GrVertexChunkArray. The provided Target must not be used externally throughout the
// entire lifetime of this object.
class GrVertexChunkBuilder : SkNoncopyable {
public:
GrVertexChunkBuilder(GrMeshDrawTarget* target, GrVertexChunkArray* chunks,
size_t stride, int minVerticesPerChunk)
: fTarget(target)
, fChunks(chunks)
, fStride(stride)
, fMinVerticesPerChunk(minVerticesPerChunk) {
SkASSERT(fMinVerticesPerChunk > 0);
}
~GrVertexChunkBuilder();
size_t stride() const { return fStride; }
// Appends 'count' contiguous vertices. These vertices are not guaranteed to be contiguous with
// previous or future calls to appendVertices.
SK_ALWAYS_INLINE skgpu::VertexWriter appendVertices(int count) {
SkASSERT(count > 0);
if (fCurrChunkVertexCount + count > fCurrChunkVertexCapacity && !this->allocChunk(count)) {
SkDEBUGCODE(fLastAppendAmount = 0;)
return {};
}
SkASSERT(fCurrChunkVertexCount + count <= fCurrChunkVertexCapacity);
fCurrChunkVertexCount += count;
SkDEBUGCODE(fLastAppendAmount = count;)
return std::exchange(fCurrChunkVertexWriter,
fCurrChunkVertexWriter.makeOffset(fStride * count));
}
// Pops the most recent 'count' contiguous vertices. Since there is no guarantee of contiguity
// between appends, 'count' may be no larger than the most recent call to appendVertices().
void popVertices(int count) {
SkASSERT(count <= fLastAppendAmount);
SkASSERT(fLastAppendAmount <= fCurrChunkVertexCount);
SkASSERT(count >= 0);
fCurrChunkVertexCount -= count;
fCurrChunkVertexWriter = fCurrChunkVertexWriter.makeOffset(fStride * -count);
SkDEBUGCODE(fLastAppendAmount -= count;)
}
private:
bool allocChunk(int minCount);
GrMeshDrawTarget* const fTarget;
GrVertexChunkArray* const fChunks;
const size_t fStride;
int fMinVerticesPerChunk;
skgpu::VertexWriter fCurrChunkVertexWriter;
int fCurrChunkVertexCount = 0;
int fCurrChunkVertexCapacity = 0;
SkDEBUGCODE(int fLastAppendAmount = 0;)
};
#endif