skgpu::graphite::DrawWriter::Instances Class Reference

#include <DrawWriter.h>

Inheritance diagram for skgpu::graphite::DrawWriter::Instances:

Public Member Functions
	Instances (DrawWriter &w, BindBufferInfo vertices, BindBufferInfo indices, unsigned int vertexCount)
void	reserve (unsigned int count)
VertexWriter	append (unsigned int count)

Detailed Description

Definition at line 331 of file DrawWriter.h.

Constructor & Destructor Documentation

Instances()

skgpu::graphite::DrawWriter::Instances::Instances ( DrawWriter &  w, BindBufferInfo  vertices, BindBufferInfo  indices, unsigned int  vertexCount  )

inline

Definition at line 333 of file DrawWriter.h.

            : Appender(w, Target::kInstances) {
        SkASSERT(vertexCount > 0);
        w.setTemplate(vertices, indices, w.fInstances, SkTo<int>(vertexCount));
    }

Member Function Documentation

append()

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

inline

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));
    }

reserve()

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

inline

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);
    }

---

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

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