skgpu::graphite::DrawWriter Class Reference

#include <DrawWriter.h>

Classes
class	Appender
class	DynamicInstances
class	Instances
class	Vertices

Public Member Functions
	DrawWriter (DrawPassCommands::List *, DrawBufferManager *)
	DrawWriter (const DrawWriter &)=delete
	DrawWriter (DrawWriter &&)=delete
	~DrawWriter ()
DrawBufferManager *	bufferManager ()
void	flush ()
void	newDynamicState ()
void	newPipelineState (PrimitiveType type, size_t vertexStride, size_t instanceStride)
void	draw (BindBufferInfo vertices, unsigned int vertexCount)
void	drawIndexed (BindBufferInfo vertices, BindBufferInfo indices, unsigned int indexCount)
void	drawInstanced (BindBufferInfo vertices, unsigned int vertexCount, BindBufferInfo instances, unsigned int instanceCount)
void	drawIndexedInstanced (BindBufferInfo vertices, BindBufferInfo indices, unsigned int indexCount, BindBufferInfo instances, unsigned int instanceCount)

Detailed Description

DrawWriter is a helper around recording draws (to a temporary buffer or directly to a CommandBuffer), particularly when the number of draws is not known ahead of time, or the vertex and instance data is computed at record time and does not have a known size.

To use, construct the DrawWriter with the current pipeline layout or call newPipelineState() on an existing DrawWriter and then bind that matching pipeline. When other dynamic state needs to change between draw calls, notify the DrawWriter using newDynamicState() before recording the modifications. See the listing below for how to append dynamic data or draw with existing buffers

CommandBuffer::draw(vertices)

• dynamic vertex data -> DrawWriter::Vertices(writer) verts; verts.append(n) << ...;
• fixed vertex data -> writer.draw(vertices, {}, vertexCount)

CommandBuffer::drawIndexed(vertices, indices)

• dynamic vertex data -> unsupported
• fixed vertex,index data -> writer.drawIndexed(vertices, indices, indexCount)

CommandBuffer::drawInstances(vertices, instances)

• dynamic instance data + fixed vertex data -> DrawWriter::Instances instances(writer, vertices, {}, vertexCount); instances.append(n) << ...;
• fixed vertex and instance data -> writer.drawInstanced(vertices, vertexCount, instances, instanceCount)

CommandBuffer::drawIndexedInstanced(vertices, indices, instances)

• dynamic instance data + fixed vertex, index data -> DrawWriter::Instances instances(writer, vertices, indices, indexCount); instances.append(n) << ...;
• fixed vertex, index, and instance data -> writer.drawIndexedInstanced(vertices, indices, indexCount, instances, instanceCount)

NOTE: DrawWriter automatically handles failures to find or create a GPU buffer or map it to be writable. All returned VertexWriters will have a non-null pointer to write to, even if it will be discarded due to GPU failure at Recorder::snap() time.

Definition at line 59 of file DrawWriter.h.

Constructor & Destructor Documentation

DrawWriter() [1/3]

skgpu::graphite::DrawWriter::DrawWriter	(	DrawPassCommands::List *	commandList,
		DrawBufferManager *	bufferManager
	)

Definition at line 15 of file DrawWriter.cpp.

        : fCommandList(commandList)
        , fManager(bufferManager)
        , fPrimitiveType(PrimitiveType::kTriangles)
        , fVertexStride(0)
        , fInstanceStride(0)
        , fVertices()
        , fIndices()
        , fInstances()
        , fTemplateCount(0)
        , fPendingCount(0)
        , fPendingBase(0)
        , fPendingBufferBinds(true) {
    SkASSERT(commandList && bufferManager);
}

DrawWriter() [2/3]

skgpu::graphite::DrawWriter::DrawWriter ( const DrawWriter &  )

delete

DrawWriter() [3/3]

skgpu::graphite::DrawWriter::DrawWriter ( DrawWriter &&  )

delete

~DrawWriter()

skgpu::graphite::DrawWriter::~DrawWriter ( )

inline

Definition at line 70 of file DrawWriter.h.

{ SkASSERT(fPendingCount == 0); }

Member Function Documentation

bufferManager()

DrawBufferManager * skgpu::graphite::DrawWriter::bufferManager ( )

inline

Definition at line 72 of file DrawWriter.h.

{ return fManager; }

draw()

void skgpu::graphite::DrawWriter::draw ( BindBufferInfo  vertices, unsigned int  vertexCount  )

inline

Definition at line 176 of file DrawWriter.h.

                                                                 {
        this->bindAndFlush(vertices, {}, {}, 0, vertexCount);
    }

drawIndexed()

void skgpu::graphite::DrawWriter::drawIndexed ( BindBufferInfo  vertices, BindBufferInfo  indices, unsigned int  indexCount  )

inline

Definition at line 179 of file DrawWriter.h.

                                                                                               {
        this->bindAndFlush(vertices, indices, {}, 0, indexCount);
    }

drawIndexedInstanced()

void skgpu::graphite::DrawWriter::drawIndexedInstanced ( BindBufferInfo  vertices, BindBufferInfo  indices, unsigned int  indexCount, BindBufferInfo  instances, unsigned int  instanceCount  )

inline

Definition at line 187 of file DrawWriter.h.

                                                          {
        SkASSERT(indexCount > 0);
        this->bindAndFlush(vertices, indices, instances, indexCount, instanceCount);
    }

drawInstanced()

void skgpu::graphite::DrawWriter::drawInstanced ( BindBufferInfo  vertices, unsigned int  vertexCount, BindBufferInfo  instances, unsigned int  instanceCount  )

inline

Definition at line 182 of file DrawWriter.h.

                                                                             {
        SkASSERT(vertexCount > 0);
        this->bindAndFlush(vertices, {}, instances, vertexCount, instanceCount);
    }

flush()

void skgpu::graphite::DrawWriter::flush

(

)

Definition at line 78 of file DrawWriter.cpp.

                       {
    // If nothing was appended, or the only appended data was through dynamic instances and the
    // final vertex count per instance is 0 (-1 in the sign encoded field), nothing should be drawn.
    if (fPendingCount == 0 || fTemplateCount == -1) {
        return;
    }
    if (fPendingBufferBinds) {
        fCommandList->bindDrawBuffers(fVertices, fInstances, fIndices, {});
        fPendingBufferBinds = false;
    }
 
    if (fTemplateCount) {
        // Instanced drawing
        unsigned int realVertexCount;
        if (fTemplateCount < 0) {
            realVertexCount = -fTemplateCount - 1;
            fTemplateCount = -1; // reset to re-accumulate max index account for next flush
        } else {
            realVertexCount = fTemplateCount;
        }
 
        if (fIndices) {
            fCommandList->drawIndexedInstanced(fPrimitiveType, 0, realVertexCount, 0,
                                               fPendingBase, fPendingCount);
        } else {
            fCommandList->drawInstanced(fPrimitiveType, 0, realVertexCount,
                                        fPendingBase, fPendingCount);
        }
    } else {
        SkASSERT(!fInstances);
        if (fIndices) {
            fCommandList->drawIndexed(fPrimitiveType, 0, fPendingCount, fPendingBase);
        } else {
            fCommandList->draw(fPrimitiveType, fPendingBase, fPendingCount);
        }
    }
 
    fPendingBase += fPendingCount;
    fPendingCount = 0;
}

newDynamicState()

void skgpu::graphite::DrawWriter::newDynamicState ( )

inline

Definition at line 77 of file DrawWriter.h.

{ this->flush(); }

newPipelineState()

void skgpu::graphite::DrawWriter::newPipelineState ( PrimitiveType  type, size_t  vertexStride, size_t  instanceStride  )

inline

Definition at line 82 of file DrawWriter.h.

                                                                                          {
        this->flush();
        fPrimitiveType = type;
        fVertexStride = vertexStride;
        fInstanceStride = instanceStride;
 
        // NOTE: resetting pending base is sufficient to redo bindings for vertex/instance data that
        // is later appended but doesn't invalidate bindings for fixed buffers that might not need
        // to change between pipelines.
        fPendingBase = 0;
        SkASSERT(fPendingCount == 0);
    }

---

The documentation for this class was generated from the following files:

• third_party/skia/src/gpu/graphite/DrawWriter.h
• third_party/skia/src/gpu/graphite/DrawWriter.cpp