skgpu::graphite::DrawWriter::Appender Class Reference

#include <DrawWriter.h>

Inheritance diagram for skgpu::graphite::DrawWriter::Appender:

Public Types
enum class	Target { kVertices , kInstances }

Public Member Functions
	Appender (DrawWriter &w, Target target)
virtual	~Appender ()

Protected Member Functions
virtual void	onFlush ()
void	reserve (unsigned int count)
VertexWriter	append (unsigned int count)

Protected Attributes
DrawWriter &	fDrawer
BindBufferInfo &	fTarget
size_t	fStride
unsigned int	fReservedCount
VertexWriter	fNextWriter

Detailed Description

Definition at line 241 of file DrawWriter.h.

Member Enumeration Documentation

Target

enum class skgpu::graphite::DrawWriter::Appender::Target

strong

Enumerator
kVertices
kInstances

Definition at line 243 of file DrawWriter.h.

{ kVertices, kInstances };

Constructor & Destructor Documentation

Appender()

skgpu::graphite::DrawWriter::Appender::Appender ( DrawWriter &  w, Target  target  )

inline

Definition at line 245 of file DrawWriter.h.

            : fDrawer(w)
            , fTarget(target == Target::kVertices ? w.fVertices     : w.fInstances)
            , fStride(target == Target::kVertices ? w.fVertexStride : w.fInstanceStride)
            , fReservedCount(0)
            , fNextWriter() {
        SkASSERT(fStride > 0);
        SkASSERT(!w.fAppender);
        SkDEBUGCODE(w.fAppender = this;)
    }

~Appender()

virtual skgpu::graphite::DrawWriter::Appender::~Appender ( )

inlinevirtual

Definition at line 256 of file DrawWriter.h.

                        {
        if (fReservedCount > 0) {
            fDrawer.fManager->returnVertexBytes(fReservedCount * fStride);
        }
        SkASSERT(fDrawer.fAppender == this);
        SkDEBUGCODE(fDrawer.fAppender = nullptr;)
    }

Member Function Documentation

append()

VertexWriter skgpu::graphite::DrawWriter::Appender::append ( unsigned int  count )

inlineprotected

Definition at line 301 of file DrawWriter.h.

                                            {
        SkASSERT(count > 0);
        this->reserve(count);
 
        const size_t size = count * fStride;
        if (!fNextWriter) SK_UNLIKELY {
            // If the GPU mapped buffer failed, ensure we have a sufficiently large CPU address to
            // write to so that RenderSteps don't have to worry about error handling. The Recording
            // will fail since the map failure is tracked by BufferManager.
            return VertexWriter(fDrawer.fFailureStorage.reset(size, SkAutoMalloc::kReuse_OnShrink),
                                size);
        }
 
        SkASSERT(fReservedCount >= count);
        fReservedCount -= count;
        fDrawer.fPendingCount += count;
        return std::exchange(fNextWriter, fNextWriter.makeOffset(size));
    }

onFlush()

virtual void skgpu::graphite::DrawWriter::Appender::onFlush ( )

inlineprotectedvirtual

Reimplemented in skgpu::graphite::DrawWriter::DynamicInstances< VertexCountProxy >, and skgpu::graphite::DrawWriter::DynamicInstances< LinearToleranceProxy >.

Definition at line 272 of file DrawWriter.h.

{}

reserve()

void skgpu::graphite::DrawWriter::Appender::reserve ( unsigned int  count )

inlineprotected

Definition at line 274 of file DrawWriter.h.

                                     {
        if (fReservedCount >= count) {
            return;
        } else if (fReservedCount > 0) {
            // Have contiguous bytes that can't satisfy request, so return them in the event the
            // DBM has additional contiguous bytes after the prior reserved range.
            fDrawer.fManager->returnVertexBytes(fReservedCount * fStride);
        }
 
        fReservedCount = count;
        // NOTE: Cannot bind tuple directly to fNextWriter, compilers don't produce the right
        // move assignment.
        auto [writer, reservedChunk] = fDrawer.fManager->getVertexWriter(count * fStride);
        if (reservedChunk.fBuffer != fTarget.fBuffer ||
            reservedChunk.fOffset !=
                    (fTarget.fOffset + (fDrawer.fPendingBase + fDrawer.fPendingCount) * fStride)) {
            // Not contiguous, so flush and update binding to 'reservedChunk'
            this->onFlush();
            fDrawer.flush();
 
            fTarget = reservedChunk;
            fDrawer.fPendingBase = 0;
            fDrawer.fPendingBufferBinds = true;
        }
        fNextWriter = std::move(writer);
    }

Member Data Documentation

fDrawer

DrawWriter& skgpu::graphite::DrawWriter::Appender::fDrawer

protected

Definition at line 265 of file DrawWriter.h.

fNextWriter

VertexWriter skgpu::graphite::DrawWriter::Appender::fNextWriter

protected

Definition at line 270 of file DrawWriter.h.

fReservedCount

unsigned int skgpu::graphite::DrawWriter::Appender::fReservedCount

protected

Definition at line 269 of file DrawWriter.h.

fStride

size_t skgpu::graphite::DrawWriter::Appender::fStride

protected

Definition at line 267 of file DrawWriter.h.

fTarget

BindBufferInfo& skgpu::graphite::DrawWriter::Appender::fTarget

protected

Definition at line 266 of file DrawWriter.h.

---

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

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