#include <BufferManager.h>

Public Member Functions
	DrawBufferManager (ResourceProvider , const Caps , UploadBufferManager *)

	~DrawBufferManager ()

bool	hasMappingFailed () const

std::pair< VertexWriter, BindBufferInfo >	getVertexWriter (size_t requiredBytes)

std::pair< IndexWriter, BindBufferInfo >	getIndexWriter (size_t requiredBytes)

std::pair< UniformWriter, BindBufferInfo >	getUniformWriter (size_t requiredBytes)

std::pair< UniformWriter, BindBufferInfo >	getSsboWriter (size_t requiredBytes)

std::pair< void *, BindBufferInfo >	getUniformPointer (size_t requiredBytes)

std::pair< void *, BindBufferInfo >	getStoragePointer (size_t requiredBytes)

BindBufferInfo	getStorage (size_t requiredBytes, ClearBuffer cleared=ClearBuffer::kNo)

BindBufferInfo	getVertexStorage (size_t requiredBytes)

BindBufferInfo	getIndexStorage (size_t requiredBytes)

BindBufferInfo	getIndirectStorage (size_t requiredBytes, ClearBuffer cleared=ClearBuffer::kNo)

ScratchBuffer	getScratchStorage (size_t requiredBytes)

void	returnVertexBytes (size_t unusedBytes)

size_t	alignUniformBlockSize (size_t dataSize)

void	transferToRecording (Recording *)

Friends
class	ScratchBuffer

Detailed Description

DrawBufferManager controls writing to buffer data ranges within larger, cacheable Buffers and automatically handles either mapping or copying via transfer buffer depending on what the GPU hardware supports for the requested buffer type and use case. It is intended for repeatedly uploading dynamic data to the GPU.

Definition at line 99 of file BufferManager.h.

Constructor & Destructor Documentation

◆ DrawBufferManager()

skgpu::graphite::DrawBufferManager::DrawBufferManager	(	ResourceProvider *	resourceProvider,
		const Caps *	caps,
		UploadBufferManager *	uploadManager
	)

Definition at line 115 of file BufferManager.cpp.

        : fResourceProvider(resourceProvider)
        , fCaps(caps)
        , fUploadManager(uploadManager)
        , fCurrentBuffers{{
                { BufferType::kVertex,        kVertexBufferSize,  caps },
                { BufferType::kIndex,         kIndexBufferSize,   caps },
                { BufferType::kUniform,       kUniformBufferSize, caps },
                { BufferType::kStorage,       kStorageBufferSize, caps },  // mapped storage
                { BufferType::kStorage,       kStorageBufferSize, caps },  // GPU-only storage
                { BufferType::kVertexStorage, kVertexBufferSize,  caps },
                { BufferType::kIndexStorage,  kIndexBufferSize,   caps },
                { BufferType::kIndirect,      kStorageBufferSize, caps } }} {}

◆ ~DrawBufferManager()

skgpu::graphite::DrawBufferManager::~DrawBufferManager ( )

Definition at line 131 of file BufferManager.cpp.

131{}

Member Function Documentation

◆ alignUniformBlockSize()

size_t skgpu::graphite::DrawBufferManager::alignUniformBlockSize ( size_t dataSize )

inline

Definition at line 146 of file BufferManager.h.

                                                  {
        return SkAlignTo(dataSize, fCurrentBuffers[kUniformBufferIndex].fStartAlignment);
    }

◆ getIndexStorage()

BindBufferInfo skgpu::graphite::DrawBufferManager::getIndexStorage ( size_t requiredBytes )

Definition at line 233 of file BufferManager.cpp.

                                                                      {
    if (!requiredBytes) {
        return {};
    }
 
    auto& info = fCurrentBuffers[kIndexStorageBufferIndex];
    return this->prepareBindBuffer(&info, requiredBytes, "IndexStorageBuffer");
}

◆ getIndexWriter()

std::pair< IndexWriter, BindBufferInfo > skgpu::graphite::DrawBufferManager::getIndexWriter ( size_t requiredBytes )

Definition at line 161 of file BufferManager.cpp.

                                                                                           {
    if (!requiredBytes) {
        return {};
    }
 
    auto& info = fCurrentBuffers[kIndexBufferIndex];
    auto [ptr, bindInfo] = this->prepareMappedBindBuffer(&info, requiredBytes, "IndexBuffer");
    return {IndexWriter(ptr, requiredBytes), bindInfo};
}

◆ getIndirectStorage()

BindBufferInfo skgpu::graphite::DrawBufferManager::getIndirectStorage	(	size_t	requiredBytes,
		ClearBuffer	cleared = `ClearBuffer::kNo`
	)

Definition at line 242 of file BufferManager.cpp.

                                                                                              {
    if (!requiredBytes) {
        return {};
    }
 
    auto& info = fCurrentBuffers[kIndirectStorageBufferIndex];
    return this->prepareBindBuffer(&info,
                                   requiredBytes,
                                   "IndirectStorageBuffer",
                                   /*supportCpuUpload=*/false,
                                   cleared);
}

◆ getScratchStorage()

ScratchBuffer skgpu::graphite::DrawBufferManager::getScratchStorage ( size_t requiredBytes )

Definition at line 255 of file BufferManager.cpp.

                                                                       {
    if (!requiredBytes || fMappingFailed) {
        return {};
    }
 
    // TODO: Generalize the pool to other buffer types.
    auto& info = fCurrentBuffers[kStorageBufferIndex];
    size_t bufferSize = sufficient_block_size(requiredBytes, info.fBlockSize);
    sk_sp<Buffer> buffer = this->findReusableSbo(bufferSize);
    if (!buffer) {
        buffer = fResourceProvider->findOrCreateBuffer(
                bufferSize, BufferType::kStorage, AccessPattern::kGpuOnly, "ScratchStorageBuffer");
 
        if (!buffer) {
            this->onFailedBuffer();
            return {};
        }
    }
    return {requiredBytes, info.fStartAlignment, std::move(buffer), this};
}

◆ getSsboWriter()

std::pair< UniformWriter, BindBufferInfo > skgpu::graphite::DrawBufferManager::getSsboWriter ( size_t requiredBytes )

Definition at line 181 of file BufferManager.cpp.

                                                                                            {
    if (!requiredBytes) {
        return {};
    }
 
    auto& info = fCurrentBuffers[kStorageBufferIndex];
    auto [ptr, bindInfo] = this->prepareMappedBindBuffer(&info, requiredBytes, "StorageBuffer");
    return {UniformWriter(ptr, requiredBytes), bindInfo};
}

◆ getStorage()

BindBufferInfo skgpu::graphite::DrawBufferManager::getStorage	(	size_t	requiredBytes,
		ClearBuffer	cleared = `ClearBuffer::kNo`
	)

Definition at line 211 of file BufferManager.cpp.

                                                                                      {
    if (!requiredBytes) {
        return {};
    }
 
    auto& info = fCurrentBuffers[kGpuOnlyStorageBufferIndex];
    return this->prepareBindBuffer(&info,
                                   requiredBytes,
                                   "StorageBuffer",
                                   /*supportCpuUpload=*/false,
                                   cleared);
}

◆ getStoragePointer()

std::pair< void *, BindBufferInfo > skgpu::graphite::DrawBufferManager::getStoragePointer ( size_t requiredBytes )

Definition at line 201 of file BufferManager.cpp.

                              {
    if (!requiredBytes) {
        return {};
    }
 
    auto& info = fCurrentBuffers[kStorageBufferIndex];
    return this->prepareMappedBindBuffer(&info, requiredBytes, "StorageBuffer");
}

◆ getUniformPointer()

std::pair< void *, BindBufferInfo > skgpu::graphite::DrawBufferManager::getUniformPointer ( size_t requiredBytes )

Definition at line 191 of file BufferManager.cpp.

                                  {
    if (!requiredBytes) {
        return {};
    }
 
    auto& info = fCurrentBuffers[kUniformBufferIndex];
    return this->prepareMappedBindBuffer(&info, requiredBytes, "UniformBuffer");
}

◆ getUniformWriter()

std::pair< UniformWriter, BindBufferInfo > skgpu::graphite::DrawBufferManager::getUniformWriter ( size_t requiredBytes )

Definition at line 171 of file BufferManager.cpp.

                                                                                               {
    if (!requiredBytes) {
        return {};
    }
 
    auto& info = fCurrentBuffers[kUniformBufferIndex];
    auto [ptr, bindInfo] = this->prepareMappedBindBuffer(&info, requiredBytes, "UniformBuffer");
    return {UniformWriter(ptr, requiredBytes), bindInfo};
}

◆ getVertexStorage()

BindBufferInfo skgpu::graphite::DrawBufferManager::getVertexStorage ( size_t requiredBytes )

Definition at line 224 of file BufferManager.cpp.

                                                                       {
    if (!requiredBytes) {
        return {};
    }
 
    auto& info = fCurrentBuffers[kVertexStorageBufferIndex];
    return this->prepareBindBuffer(&info, requiredBytes, "VertexStorageBuffer");
}

◆ getVertexWriter()

std::pair< VertexWriter, BindBufferInfo > skgpu::graphite::DrawBufferManager::getVertexWriter ( size_t requiredBytes )

Definition at line 141 of file BufferManager.cpp.

                                                                                             {
    if (!requiredBytes) {
        return {};
    }
 
    auto& info = fCurrentBuffers[kVertexBufferIndex];
    auto [ptr, bindInfo] = this->prepareMappedBindBuffer(&info, requiredBytes, "VertexBuffer");
    return {VertexWriter(ptr, requiredBytes), bindInfo};
}

◆ hasMappingFailed()

bool skgpu::graphite::DrawBufferManager::hasMappingFailed ( ) const

inline

Definition at line 106 of file BufferManager.h.

106{ return fMappingFailed; }

◆ returnVertexBytes()

void skgpu::graphite::DrawBufferManager::returnVertexBytes ( size_t unusedBytes )

Definition at line 151 of file BufferManager.cpp.

                                                            {
    if (fMappingFailed) {
        // The caller can be unaware that the written data went to no-where and will still call
        // this function.
        return;
    }
    SkASSERT(fCurrentBuffers[kVertexBufferIndex].fOffset >= unusedBytes);
    fCurrentBuffers[kVertexBufferIndex].fOffset -= unusedBytes;
}

◆ transferToRecording()

void skgpu::graphite::DrawBufferManager::transferToRecording ( Recording * recording )

Definition at line 299 of file BufferManager.cpp.

                                                                {
    // We could allow this to be called when the mapping has failed, since the transfer will be a no
    // op, but in practice, the caller will want to check the error state as soon as possible to
    // limit any unnecessary resource preparation from other tasks.
    SkASSERT(!fMappingFailed);
 
    if (!fClearList.empty()) {
        recording->priv().addTask(ClearBuffersTask::Make(std::move(fClearList)));
    }
 
    // Transfer the buffers in the reuse pool to the recording.
    // TODO: Allow reuse across different Recordings?
    for (auto& buffer : fReusableScratchStorageBuffers) {
        recording->priv().addResourceRef(std::move(buffer));
    }
    fReusableScratchStorageBuffers.clear();
 
    for (auto& [buffer, transferBuffer] : fUsedBuffers) {
        if (transferBuffer) {
            SkASSERT(buffer);
            SkASSERT(!fCaps->drawBufferCanBeMapped());
            // Since the transfer buffer is managed by the UploadManager, we don't manually unmap
            // it here or need to pass a ref into CopyBufferToBufferTask.
            size_t copySize = buffer->size();
            recording->priv().addTask(
                    CopyBufferToBufferTask::Make(transferBuffer.fBuffer,
                                                 transferBuffer.fOffset,
                                                 std::move(buffer),
                                                 /*dstOffset=*/0,
                                                 copySize));
        } else {
            if (buffer->isMapped()) {
                buffer->unmap();
            }
            recording->priv().addResourceRef(std::move(buffer));
        }
    }
    fUsedBuffers.clear();
 
    // The current draw buffers have not been added to fUsedBuffers,
    // so we need to handle them as well.
    for (auto& info : fCurrentBuffers) {
        if (!info.fBuffer) {
            continue;
        }
        if (info.fTransferBuffer) {
            // A transfer buffer should always be mapped at this stage
            SkASSERT(info.fBuffer);
            SkASSERT(!fCaps->drawBufferCanBeMapped());
            // Since the transfer buffer is managed by the UploadManager, we don't manually unmap
            // it here or need to pass a ref into CopyBufferToBufferTask.
            recording->priv().addTask(
                    CopyBufferToBufferTask::Make(info.fTransferBuffer.fBuffer,
                                                 info.fTransferBuffer.fOffset,
                                                 info.fBuffer,
                                                 /*dstOffset=*/0,
                                                 info.fBuffer->size()));
        } else {
            if (info.fBuffer->isMapped()) {
                info.fBuffer->unmap();
            }
            recording->priv().addResourceRef(std::move(info.fBuffer));
        }
        info.fTransferBuffer = {};
        info.fOffset = 0;
    }
}

Friends And Related Symbol Documentation

◆ ScratchBuffer

friend class ScratchBuffer

friend

Definition at line 155 of file BufferManager.h.

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

third_party/skia/src/gpu/graphite/BufferManager.h
third_party/skia/src/gpu/graphite/BufferManager.cpp

Public Member Functions

Friends