| /* | |
| * Copyright 2022 Rive | |
| */ | |
| #pragma once | |
| #include "rive/pls/pls.hpp" | |
| namespace rive::pls | |
| { | |
| // API-agnostic implementation of an abstract buffer ring. We use rings to ensure the GPU can render | |
| // one frame in parallel while the CPU prepares the next frame. | |
| // | |
| // Calling mapBuffer() maps the next buffer in the ring. | |
| // | |
| // Calling unmapAndSubmitBuffer() submits the currently-mapped buffer for GPU rendering, in whatever | |
| // way that is meaningful for the PLSRenderContext implementation. | |
| // | |
| // This class is meant to only be used through BufferRing<>. | |
| class BufferRingImpl | |
| { | |
| public: | |
| BufferRingImpl(size_t capacity, size_t itemSizeInBytes) : | |
| m_capacity(capacity), m_itemSizeInBytes(itemSizeInBytes) | |
| {} | |
| virtual ~BufferRingImpl() {} | |
| size_t capacity() const { return m_capacity; } | |
| size_t itemSizeInBytes() const { return m_itemSizeInBytes; } | |
| // Maps the next buffer in the ring. | |
| void* mapBuffer() | |
| { | |
| assert(!m_mapped); | |
| RIVE_DEBUG_CODE(m_mapped = true;) | |
| m_submittedBufferIdx = (m_submittedBufferIdx + 1) % kBufferRingSize; | |
| return onMapBuffer(m_submittedBufferIdx); | |
| } | |
| // Submits the currently-mapped buffer for GPU rendering, in whatever way that is meaningful for | |
| // the PLSRenderContext implementation. | |
| void unmapAndSubmitBuffer(size_t bytesWritten) | |
| { | |
| assert(m_mapped); | |
| RIVE_DEBUG_CODE(m_mapped = false;) | |
| onUnmapAndSubmitBuffer(m_submittedBufferIdx, bytesWritten); | |
| } | |
| protected: | |
| int submittedBufferIdx() const | |
| { | |
| assert(!m_mapped); | |
| return m_submittedBufferIdx; | |
| } | |
| virtual void* onMapBuffer(int bufferIdx) = 0; | |
| virtual void onUnmapAndSubmitBuffer(int bufferIdx, size_t bytesWritten) = 0; | |
| private: | |
| size_t m_capacity; | |
| size_t m_itemSizeInBytes; | |
| int m_submittedBufferIdx = 0; | |
| RIVE_DEBUG_CODE(bool m_mapped = false;) | |
| }; | |
| // Buffer ring implementation for a GPU resource that doesn't support mapping. Mapping is emulated | |
| // via shadow buffer on the CPU. | |
| class BufferRingShadowImpl : public BufferRingImpl | |
| { | |
| public: | |
| BufferRingShadowImpl(size_t capacity, size_t itemSizeInBytes) : | |
| BufferRingImpl(capacity, itemSizeInBytes) | |
| {} | |
| ~BufferRingShadowImpl() override { free(m_shadowBuffer); } | |
| void* onMapBuffer(int bufferIdx) final | |
| { | |
| if (!m_shadowBuffer) | |
| { | |
| m_shadowBuffer = malloc(capacity() * itemSizeInBytes()); | |
| } | |
| return m_shadowBuffer; | |
| } | |
| const void* shadowBuffer() const { return m_shadowBuffer; } | |
| private: | |
| void* m_shadowBuffer = nullptr; | |
| }; | |
| // BufferRingShadowImpl whose backing store is a 2D texture. | |
| class TexelBufferRing : public BufferRingShadowImpl | |
| { | |
| public: | |
| enum class Format | |
| { | |
| rgba8, | |
| rgba32f, | |
| rgba32ui, | |
| }; | |
| constexpr static size_t BytesPerPixel(Format format) | |
| { | |
| switch (format) | |
| { | |
| case Format::rgba8: | |
| return 4; | |
| case Format::rgba32f: | |
| case Format::rgba32ui: | |
| return 4 * 4; | |
| } | |
| } | |
| enum class Filter | |
| { | |
| nearest, | |
| linear, | |
| }; | |
| TexelBufferRing(Format format, size_t widthInItems, size_t height, size_t texelsPerItem) : | |
| BufferRingShadowImpl(height * widthInItems, texelsPerItem * BytesPerPixel(format)), | |
| m_format(format), | |
| m_widthInItems(widthInItems), | |
| m_height(height), | |
| m_texelsPerItem(texelsPerItem) | |
| {} | |
| size_t widthInItems() const { return m_widthInItems; } | |
| size_t widthInTexels() const { return m_widthInItems * m_texelsPerItem; } | |
| size_t height() const { return m_height; } | |
| protected: | |
| void onUnmapAndSubmitBuffer(int bufferIdx, size_t bytesWritten) final | |
| { | |
| size_t texelsWritten = bytesWritten / BytesPerPixel(m_format); | |
| assert(texelsWritten * BytesPerPixel(m_format) == bytesWritten); | |
| size_t updateWidthInTexels = std::min(texelsWritten, widthInTexels()); | |
| size_t updateHeight = (texelsWritten + widthInTexels() - 1) / widthInTexels(); | |
| submitTexels(bufferIdx, updateWidthInTexels, updateHeight); | |
| } | |
| virtual void submitTexels(int textureIdx, size_t width, size_t height) = 0; | |
| const Format m_format; | |
| const size_t m_widthInItems; | |
| const size_t m_height; | |
| const size_t m_texelsPerItem; | |
| }; | |
| // Wrapper for an abstract BufferRingImpl that supports mapping buffers, writing an array of items | |
| // of the same type, and submitting for rendering. | |
| // | |
| // Intended usage pattern: | |
| // | |
| // * Call ensureMapped() to map the next buffer in the ring. | |
| // * push() all items for rendering. | |
| // * Call submit() to unmap and submit the currently-mapped buffer for rendering, in whatever way | |
| // that is meaningful for the PLSRenderContext implementation. | |
| // | |
| template <typename T> class BufferRing | |
| { | |
| public: | |
| BufferRing() = default; | |
| BufferRing(std::unique_ptr<BufferRingImpl> impl) : m_impl(std::move(impl)) | |
| { | |
| assert(m_impl->itemSizeInBytes() == sizeof(T)); | |
| } | |
| BufferRing(BufferRing&& other) : m_impl(std::move(other.m_impl)) {} | |
| void reset(std::unique_ptr<BufferRingImpl> impl) | |
| { | |
| assert(!mapped()); | |
| m_impl = std::move(impl); | |
| } | |
| size_t totalSizeInBytes() const | |
| { | |
| return m_impl ? kBufferRingSize * m_impl->capacity() * m_impl->itemSizeInBytes() : 0; | |
| } | |
| // Maps the next buffer in the ring, if one is not already mapped. | |
| RIVE_ALWAYS_INLINE void ensureMapped() | |
| { | |
| if (!mapped()) | |
| { | |
| m_mappedMemory = m_nextMappedItem = reinterpret_cast<T*>(m_impl->mapBuffer()); | |
| m_mappingEnd = m_mappedMemory + m_impl->capacity(); | |
| } | |
| } | |
| const BufferRingImpl* impl() const { return m_impl.get(); } | |
| BufferRingImpl* impl() { return m_impl.get(); } | |
| // Is a buffer not mapped, or, has nothing been pushed yet to the currently-mapped buffer? | |
| size_t empty() const | |
| { | |
| assert(!m_mappedMemory == !m_nextMappedItem); | |
| return m_mappedMemory == m_nextMappedItem; | |
| } | |
| // How many bytes have been written to the currently-mapped buffer? | |
| // (Returns 0 if no buffer is mapped.) | |
| size_t bytesWritten() const | |
| { | |
| assert(!m_mappedMemory == !m_mappingEnd); | |
| return reinterpret_cast<uintptr_t>(m_nextMappedItem) - | |
| reinterpret_cast<uintptr_t>(m_mappedMemory); | |
| } | |
| // Is a buffer currently mapped? | |
| bool mapped() const | |
| { | |
| assert(!m_mappedMemory == !m_nextMappedItem && !m_mappedMemory == !m_mappingEnd); | |
| return m_mappedMemory != nullptr; | |
| } | |
| // Is there room to push() itemCount items to the currently-mapped buffer? | |
| bool hasRoomFor(size_t itemCount) | |
| { | |
| assert(mapped()); | |
| return m_nextMappedItem + itemCount <= m_mappingEnd; | |
| } | |
| // Append and write a new item to the currently-mapped buffer. In order to enforce the | |
| // write-only requirement of a mapped buffer, this method does not return any pointers to the | |
| // client. | |
| template <typename... Args> RIVE_ALWAYS_INLINE void emplace_back(Args&&... args) | |
| { | |
| push() = {std::forward<Args>(args)...}; | |
| } | |
| template <typename... Args> RIVE_ALWAYS_INLINE void set_back(Args&&... args) | |
| { | |
| push().set(std::forward<Args>(args)...); | |
| } | |
| // Called after all the data for a frame has been push()-ed to the mapped buffer. Unmaps and | |
| // submits the currently-mapped buffer (if any) for GPU rendering, in whatever way that is | |
| // meaningful for the PLSRenderContext implementation. | |
| void submit() | |
| { | |
| if (mapped()) | |
| { | |
| m_impl->unmapAndSubmitBuffer(bytesWritten()); | |
| m_mappingEnd = m_nextMappedItem = m_mappedMemory = nullptr; | |
| } | |
| assert(!mapped()); | |
| } | |
| private: | |
| template <typename... Args> RIVE_ALWAYS_INLINE T& push() | |
| { | |
| assert(mapped()); | |
| assert(hasRoomFor(1)); | |
| return *m_nextMappedItem++; | |
| } | |
| std::unique_ptr<BufferRingImpl> m_impl; | |
| T* m_mappedMemory = nullptr; | |
| T* m_nextMappedItem = nullptr; | |
| const T* m_mappingEnd = nullptr; | |
| }; | |
| } // namespace rive::pls |