Virtual PLSRenderContextImpl
diff --git a/include/rive/pls/buffer_ring.hpp b/include/rive/pls/buffer_ring.hpp
index e099a2e..602cd90 100644
--- a/include/rive/pls/buffer_ring.hpp
+++ b/include/rive/pls/buffer_ring.hpp
@@ -27,6 +27,7 @@
size_t capacity() const { return m_capacity; }
size_t itemSizeInBytes() const { return m_itemSizeInBytes; }
+ size_t totalSizeInBytes() const { return m_capacity * m_itemSizeInBytes * kBufferRingSize; }
// Maps the next buffer in the ring.
void* mapBuffer()
@@ -168,117 +169,4 @@
private:
std::unique_ptr<char[]> m_cpuBuffers[kBufferRingSize];
};
-
-// 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) { reset(std::move(impl)); }
- BufferRing(BufferRing&& other) : m_impl(std::move(other.m_impl)) {}
-
- void reset(std::unique_ptr<BufferRingImpl> impl)
- {
- assert(!mapped());
- assert(impl->itemSizeInBytes() == sizeof(T));
- m_impl = std::move(impl);
- }
-
- size_t totalSizeInBytes() const
- {
- return m_impl ? kBufferRingSize * m_impl->capacity() * m_impl->itemSizeInBytes() : 0;
- }
-
- size_t capacity() const { return m_impl->capacity(); }
-
- // 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
diff --git a/include/rive/pls/d3d/pls_render_context_d3d.hpp b/include/rive/pls/d3d/pls_render_context_d3d_impl.hpp
similarity index 91%
rename from include/rive/pls/d3d/pls_render_context_d3d.hpp
rename to include/rive/pls/d3d/pls_render_context_d3d_impl.hpp
index b0c7b1c..ba0f0bf 100644
--- a/include/rive/pls/d3d/pls_render_context_d3d.hpp
+++ b/include/rive/pls/d3d/pls_render_context_d3d_impl.hpp
@@ -5,7 +5,7 @@
#pragma once
#include "rive/pls/d3d/d3d11.hpp"
-#include "rive/pls/pls_render_context.hpp"
+#include "rive/pls/pls_render_context_buffer_ring_impl.hpp"
#include <map>
namespace rive::pls
@@ -22,7 +22,7 @@
ID3D11Texture2D* targetTexture() const { return m_targetTexture.Get(); }
private:
- friend class PLSRenderContextD3D;
+ friend class PLSRenderContextD3DImpl;
PLSRenderTargetD3D(ID3D11Device*, size_t width, size_t height);
@@ -38,10 +38,10 @@
};
// D3D backend implementation of PLSRenderContext.
-class PLSRenderContextD3D : public PLSRenderContext
+class PLSRenderContextD3DImpl : public PLSRenderContextBufferRingImpl
{
public:
- PLSRenderContextD3D(ComPtr<ID3D11Device>, ComPtr<ID3D11DeviceContext>, bool isIntel);
+ PLSRenderContextD3DImpl(ComPtr<ID3D11Device>, ComPtr<ID3D11DeviceContext>, bool isIntel);
rcp<PLSRenderTargetD3D> makeRenderTarget(size_t width, size_t height);
@@ -64,7 +64,7 @@
void allocateGradientTexture(size_t height) override;
void allocateTessellationTexture(size_t height) override;
- void onFlush(const FlushDescriptor&) override;
+ void flush(const PLSRenderContext::FlushDescriptor&) override;
void setPipelineLayoutAndShaders(DrawType, const ShaderFeatures&);
diff --git a/include/rive/pls/gl/pls_render_context_gl.hpp b/include/rive/pls/gl/pls_render_context_gl_impl.hpp
similarity index 86%
rename from include/rive/pls/gl/pls_render_context_gl.hpp
rename to include/rive/pls/gl/pls_render_context_gl_impl.hpp
index 4a37f2b..7fb8294 100644
--- a/include/rive/pls/gl/pls_render_context_gl.hpp
+++ b/include/rive/pls/gl/pls_render_context_gl_impl.hpp
@@ -9,7 +9,7 @@
#include "rive/pls/gl/gles3.hpp"
#include "rive/pls/gl/pls_render_target_gl.hpp"
#include "rive/pls/buffer_ring.hpp"
-#include "rive/pls/pls_render_context.hpp"
+#include "rive/pls/pls_render_context_buffer_ring_impl.hpp"
#include <map>
namespace rive::pls
@@ -19,17 +19,17 @@
class PLSRenderTargetGL;
// OpenGL backend implementation of PLSRenderContext.
-class PLSRenderContextGL : public PLSRenderContext
+class PLSRenderContextGLImpl : public PLSRenderContextBufferRingImpl
{
public:
- static std::unique_ptr<PLSRenderContextGL> Make();
- ~PLSRenderContextGL() override;
+ static std::unique_ptr<PLSRenderContextGLImpl> Make();
+ ~PLSRenderContextGLImpl() override;
// Creates a PLSRenderTarget that draws directly into the given GL framebuffer.
// Returns null if the framebuffer doesn't support pixel local storage.
rcp<PLSRenderTargetGL> wrapGLRenderTarget(GLuint framebufferID, size_t width, size_t height)
{
- return m_plsImpl->wrapGLRenderTarget(framebufferID, width, height, m_platformFeatures);
+ return m_plsImpl->wrapGLRenderTarget(framebufferID, width, height, platformFeatures());
}
// Creates a PLSRenderTarget that draws to a new, offscreen GL framebuffer. This method is
@@ -37,7 +37,7 @@
// results.
rcp<PLSRenderTargetGL> makeOffscreenRenderTarget(size_t width, size_t height)
{
- return m_plsImpl->makeOffscreenRenderTarget(width, height, m_platformFeatures);
+ return m_plsImpl->makeOffscreenRenderTarget(width, height, platformFeatures());
}
private:
@@ -55,11 +55,9 @@
size_t height,
const PlatformFeatures&) = 0;
- virtual void activatePixelLocalStorage(PLSRenderContextGL*,
- const PLSRenderTargetGL*,
- LoadAction,
- bool needsClipBuffer) = 0;
- virtual void deactivatePixelLocalStorage(PLSRenderContextGL*) = 0;
+ virtual void activatePixelLocalStorage(PLSRenderContextGLImpl*,
+ const PLSRenderContext::FlushDescriptor&) = 0;
+ virtual void deactivatePixelLocalStorage(PLSRenderContextGLImpl*) = 0;
virtual const char* shaderDefineName() const = 0;
@@ -105,7 +103,7 @@
public:
DrawProgram(const DrawProgram&) = delete;
DrawProgram& operator=(const DrawProgram&) = delete;
- DrawProgram(PLSRenderContextGL*, DrawType, const ShaderFeatures&);
+ DrawProgram(PLSRenderContextGLImpl*, DrawType, const ShaderFeatures&);
~DrawProgram();
GLuint id() const { return m_id; }
@@ -118,12 +116,7 @@
class DrawShader;
- PLSRenderContextGL(const PlatformFeatures&, GLExtensions, std::unique_ptr<PLSImpl>);
-
- const PLSRenderTargetGL* renderTarget() const
- {
- return static_cast<const PLSRenderTargetGL*>(frameDescriptor().renderTarget.get());
- }
+ PLSRenderContextGLImpl(const PlatformFeatures&, GLExtensions, std::unique_ptr<PLSImpl>);
std::unique_ptr<BufferRingImpl> makeVertexBufferRing(size_t capacity,
size_t itemSizeInBytes) override;
@@ -143,7 +136,7 @@
void allocateGradientTexture(size_t height) override;
void allocateTessellationTexture(size_t height) override;
- void onFlush(const FlushDescriptor&) override;
+ void flush(const PLSRenderContext::FlushDescriptor&) override;
// GL state wrapping.
void bindProgram(GLuint);
diff --git a/include/rive/pls/gl/pls_render_target_gl.hpp b/include/rive/pls/gl/pls_render_target_gl.hpp
index 17346b6..dc6664d 100644
--- a/include/rive/pls/gl/pls_render_target_gl.hpp
+++ b/include/rive/pls/gl/pls_render_target_gl.hpp
@@ -24,7 +24,7 @@
GLuint sideFramebufferID() const { return m_sideFramebufferID; }
private:
- friend class PLSRenderContextGL;
+ friend class PLSRenderContextGLImpl;
// Creates a render target that draws to an existing GL framebuffer. The caller must also call
// allocateCoverageBackingTextures() and attach those textures to the framebuffer if needed.
diff --git a/include/rive/pls/pls.hpp b/include/rive/pls/pls.hpp
index 30c6ee1..863f88e 100644
--- a/include/rive/pls/pls.hpp
+++ b/include/rive/pls/pls.hpp
@@ -12,6 +12,11 @@
#include "rive/shapes/paint/color.hpp"
#include "rive/shapes/paint/stroke_join.hpp"
+namespace rive
+{
+class GrInnerFanTriangulator;
+}
+
// This header defines constants and data structures for Rive's pixel local storage path rendering
// algorithm.
//
@@ -62,6 +67,7 @@
// In order to support WebGL2, we implement the path data buffer as a texture.
constexpr static size_t kPathTextureWidthInItems = 128;
constexpr static size_t kPathTexelsPerItem = 3;
+constexpr static size_t kPathTextureWidthInTexels = kPathTextureWidthInItems * kPathTexelsPerItem;
// Each contour has its own unique ID, which it uses to index a data record containing per-contour
// information. This value is currently 16 bit.
@@ -72,6 +78,8 @@
// In order to support WebGL2, we implement the contour data buffer as a texture.
constexpr static size_t kContourTextureWidthInItems = 256;
constexpr static size_t kContourTexelsPerItem = 1;
+constexpr static size_t kContourTextureWidthInTexels =
+ kContourTextureWidthInItems * kContourTexelsPerItem;
// Tessellation is performed by rendering vertices into a data texture. These values define the
// dimensions of the tessellation data texture.
@@ -389,6 +397,56 @@
};
static_assert(sizeof(TriangleVertex) == sizeof(float) * 3);
+template <typename T> class WriteOnlyMappedMemory
+{
+public:
+ WriteOnlyMappedMemory() { reset(); }
+ WriteOnlyMappedMemory(void* ptr, size_t count) { reset(ptr, count); }
+
+ void reset() { reset(nullptr, 0); }
+
+ void reset(void* ptr, size_t count)
+ {
+ m_mappedMemory = reinterpret_cast<T*>(ptr);
+ m_nextMappedItem = m_mappedMemory;
+ m_mappingEnd = m_mappedMemory + count;
+ }
+
+ operator bool() const { return m_mappedMemory; }
+
+ // How many bytes have been written to the buffer?
+ size_t bytesWritten() const
+ {
+ return reinterpret_cast<uintptr_t>(m_nextMappedItem) -
+ reinterpret_cast<uintptr_t>(m_mappedMemory);
+ }
+
+ // Is there room to push() itemCount items to the buffer?
+ bool hasRoomFor(size_t itemCount) { return m_nextMappedItem + itemCount <= m_mappingEnd; }
+
+ // Append and write a new item to the buffer. In order to enforce the write-only requirement of
+ // a mapped buffer, these methods do 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)...);
+ }
+
+private:
+ template <typename... Args> RIVE_ALWAYS_INLINE T& push()
+ {
+ assert(hasRoomFor(1));
+ return *m_nextMappedItem++;
+ }
+
+ T* m_mappedMemory;
+ T* m_nextMappedItem;
+ const T* m_mappingEnd;
+};
+
// Once all curves in a contour have been tessellated, we render the tessellated vertices in
// "patches" (aka specific instanced geometry).
//
@@ -482,6 +540,135 @@
void GeneratePatchBufferData(PatchVertex[kPatchVertexBufferCount],
uint16_t indices[kPatchIndexBufferCount]);
+enum class DrawType : uint8_t
+{
+ midpointFanPatches, // Standard paths and/or strokes.
+ outerCurvePatches, // Just the outer curves of a path; the interior will be triangulated.
+ interiorTriangulation
+};
+
+constexpr static uint32_t PatchSegmentSpan(DrawType drawType)
+{
+ switch (drawType)
+ {
+ case DrawType::midpointFanPatches:
+ return kMidpointFanPatchSegmentSpan;
+ case DrawType::outerCurvePatches:
+ return kOuterCurvePatchSegmentSpan;
+ default:
+ RIVE_UNREACHABLE();
+ }
+}
+
+constexpr static uint32_t PatchIndexCount(DrawType drawType)
+{
+ switch (drawType)
+ {
+ case DrawType::midpointFanPatches:
+ return kMidpointFanPatchIndexCount;
+ case DrawType::outerCurvePatches:
+ return kOuterCurvePatchIndexCount;
+ default:
+ RIVE_UNREACHABLE();
+ }
+}
+
+constexpr static uintptr_t PatchBaseIndex(DrawType drawType)
+{
+ switch (drawType)
+ {
+ case DrawType::midpointFanPatches:
+ return kMidpointFanPatchBaseIndex;
+ case DrawType::outerCurvePatches:
+ return kOuterCurvePatchBaseIndex;
+ default:
+ RIVE_UNREACHABLE();
+ }
+}
+
+// Specifies what to do with the render target at the beginning of a flush.
+enum class LoadAction : bool
+{
+ clear,
+ preserveRenderTarget
+};
+
+// Indicates how much blendMode support will be needed in the "uber" draw shader.
+enum class BlendTier : uint8_t
+{
+ srcOver, // Every draw uses srcOver.
+ advanced, // Draws use srcOver *and* advanced blend modes, excluding HSL modes.
+ advancedHSL, // Draws use srcOver *and* advanced blend modes *and* advanced HSL modes.
+};
+
+// Used by ShaderFeatures to generate keys and source code.
+enum class SourceType : bool
+{
+ vertexOnly,
+ wholeProgram
+};
+
+// Indicates which "uber shader" features to enable in the draw shader.
+struct ShaderFeatures
+{
+ enum PreprocessorDefines : uint32_t
+ {
+ ENABLE_ADVANCED_BLEND = 1 << 0,
+ ENABLE_PATH_CLIPPING = 1 << 1,
+ ENABLE_EVEN_ODD = 1 << 2,
+ ENABLE_HSL_BLEND_MODES = 1 << 3,
+ };
+
+ // Returns a bitmask of which preprocessor macros must be defined in order to support the
+ // current feature set.
+ uint32_t getPreprocessorDefines(SourceType) const;
+
+ struct
+ {
+ BlendTier blendTier = BlendTier::srcOver;
+ bool enablePathClipping = false;
+ } programFeatures;
+
+ struct
+ {
+ bool enableEvenOdd = false;
+ } fragmentFeatures;
+};
+
+inline static uint32_t ShaderUniqueKey(SourceType sourceType,
+ DrawType drawType,
+ const ShaderFeatures& shaderFeatures)
+{
+ return (shaderFeatures.getPreprocessorDefines(sourceType) << 1) |
+ (drawType == DrawType::interiorTriangulation);
+}
+
+// Linked list of draws to be issued by the subclass during onFlush().
+struct Draw
+{
+ Draw(DrawType drawType_, uint32_t baseVertexOrInstance_) :
+ drawType(drawType_), baseVertexOrInstance(baseVertexOrInstance_)
+ {}
+ const DrawType drawType;
+ uint32_t baseVertexOrInstance;
+ uint32_t vertexOrInstanceCount = 0; // Calculated during PLSRenderContext::flush().
+ ShaderFeatures shaderFeatures;
+ GrInnerFanTriangulator* triangulator = nullptr; // Used by "interiorTriangulation" draws.
+};
+
+// Simple gradients only have 2 texels, so we write them to mapped texture memory from the CPU
+// instead of rendering them.
+struct TwoTexelRamp
+{
+ void set(const ColorInt colors[2])
+ {
+ UnpackColorToRGBA8(colors[0], colorData);
+ UnpackColorToRGBA8(colors[1], colorData + 4);
+ }
+ uint8_t colorData[8];
+};
+static_assert(sizeof(TwoTexelRamp) == 8 * sizeof(uint8_t));
+
// Returns the smallest number that can be added to 'value', such that 'value % alignment' == 0.
template <uint32_t Alignment> RIVE_ALWAYS_INLINE uint32_t PaddingToAlignUp(uint32_t value)
{
diff --git a/include/rive/pls/pls_render_context.hpp b/include/rive/pls/pls_render_context.hpp
index 065b4cd..7c0e174 100644
--- a/include/rive/pls/pls_render_context.hpp
+++ b/include/rive/pls/pls_render_context.hpp
@@ -16,7 +16,6 @@
namespace rive
{
-class GrInnerFanTriangulator;
class RawPath;
} // namespace rive
@@ -26,6 +25,7 @@
class PLSGradient;
class PLSPaint;
class PLSPath;
+class PLSRenderContextImpl;
// Used as a key for complex gradients.
class GradientContentKey
@@ -86,14 +86,11 @@
class PLSRenderContext
{
public:
- virtual ~PLSRenderContext();
+ PLSRenderContext(std::unique_ptr<PLSRenderContextImpl>);
+ ~PLSRenderContext();
- // Specifies what to do with the render target at the beginning of a flush.
- enum class LoadAction : bool
- {
- clear,
- preserveRenderTarget
- };
+ PLSRenderContextImpl* impl() const { return m_impl.get(); }
+ const PlatformFeatures& platformFeatures() const { return m_platformFeatures; }
// Options for controlling how and where a frame is rendered.
struct FrameDescriptor
@@ -293,11 +290,11 @@
template <typename T> class PerFlushLinkedList
{
public:
- void reset() { m_tail = m_head = nullptr; }
-
- bool empty() const;
+ size_t count() const;
+ bool empty() const { return count() == 0; }
T& tail() const;
template <typename... Args> void emplace_back(PLSRenderContext* context, Args... args);
+ void reset();
struct Node
{
@@ -306,111 +303,35 @@
Node* next = nullptr;
};
- class Iter
+ template <typename U> class Iter
{
public:
Iter(Node* current) : m_current(current) {}
bool operator!=(const Iter& other) const { return m_current != other.m_current; }
void operator++() { m_current = m_current->next; }
- T& operator*() { return m_current->data; }
+ U& operator*() { return m_current->data; }
private:
Node* m_current;
};
- Iter begin() { return {m_head}; }
- Iter end() { return {nullptr}; }
+ Iter<T> begin() { return {m_head}; }
+ Iter<T> end() { return {nullptr}; }
+ Iter<const T> begin() const { return {m_head}; }
+ Iter<const T> end() const { return {nullptr}; }
private:
Node* m_head = nullptr;
Node* m_tail = nullptr;
+ size_t m_count = 0;
};
-protected:
- PLSRenderContext(const PlatformFeatures&);
-
- virtual std::unique_ptr<BufferRingImpl> makeVertexBufferRing(size_t capacity,
- size_t itemSizeInBytes) = 0;
-
- virtual std::unique_ptr<TexelBufferRing> makeTexelBufferRing(TexelBufferRing::Format,
- size_t widthInItems,
- size_t height,
- size_t texelsPerItem,
- int textureIdx,
- TexelBufferRing::Filter) = 0;
-
- virtual std::unique_ptr<BufferRingImpl> makePixelUnpackBufferRing(size_t capacity,
- size_t itemSizeInBytes) = 0;
-
- virtual std::unique_ptr<BufferRingImpl> makeUniformBufferRing(size_t sizeInBytes) = 0;
-
- virtual void allocateGradientTexture(size_t height) = 0;
- virtual void allocateTessellationTexture(size_t height) = 0;
-
- const TexelBufferRing* pathBufferRing()
- {
- return static_cast<const TexelBufferRing*>(m_pathBuffer.impl());
- }
- const TexelBufferRing* contourBufferRing()
- {
- return static_cast<const TexelBufferRing*>(m_contourBuffer.impl());
- }
- const BufferRingImpl* simpleColorRampsBufferRing() const
- {
- return m_simpleColorRampsBuffer.impl();
- }
- const BufferRingImpl* gradSpanBufferRing() const { return m_gradSpanBuffer.impl(); }
- const BufferRingImpl* tessSpanBufferRing() { return m_tessSpanBuffer.impl(); }
- const BufferRingImpl* triangleBufferRing() { return m_triangleBuffer.impl(); }
- const BufferRingImpl* uniformBufferRing() const { return m_uniformBuffer.impl(); }
-
- virtual void onBeginFrame() {}
-
- // Indicates how much blendMode support will be needed in the "uber" draw shader.
- enum class BlendTier : uint8_t
- {
- srcOver, // Every draw uses srcOver.
- advanced, // Draws use srcOver *and* advanced blend modes, excluding HSL modes.
- advancedHSL, // Draws use srcOver *and* advanced blend modes *and* advanced HSL modes.
- };
-
- // Used by ShaderFeatures to generate keys and source code.
- enum class SourceType : bool
- {
- vertexOnly,
- wholeProgram
- };
-
- // Indicates which "uber shader" features to enable in the draw shader.
- struct ShaderFeatures
- {
- enum PreprocessorDefines : uint32_t
- {
- ENABLE_ADVANCED_BLEND = 1 << 0,
- ENABLE_PATH_CLIPPING = 1 << 1,
- ENABLE_EVEN_ODD = 1 << 2,
- ENABLE_HSL_BLEND_MODES = 1 << 3,
- };
-
- // Returns a bitmask of which preprocessor macros must be defined in order to support the
- // current feature set.
- uint32_t getPreprocessorDefines(SourceType) const;
-
- struct
- {
- BlendTier blendTier = BlendTier::srcOver;
- bool enablePathClipping = false;
- } programFeatures;
-
- struct
- {
- bool enableEvenOdd = false;
- } fragmentFeatures;
- };
-
+ // protected:
+public:
struct FlushDescriptor
{
- FlushType flushType;
+ const PLSRenderTarget* renderTarget;
LoadAction loadAction;
+ ColorInt clearColor = 0;
size_t complexGradSpanCount;
size_t tessVertexSpanCount;
uint16_t simpleGradTexelsWidth;
@@ -419,89 +340,23 @@
uint32_t complexGradRowsHeight;
uint32_t tessDataHeight;
bool needsClipBuffer;
+ bool hasTriangleVertices;
+ bool wireframe;
+ const PerFlushLinkedList<Draw>* drawList;
};
- virtual void onFlush(const FlushDescriptor&) = 0;
-
+private:
const PlatformFeatures m_platformFeatures;
const size_t m_maxPathID;
-
- enum class DrawType : uint8_t
- {
- midpointFanPatches, // Standard paths and/or strokes.
- outerCurvePatches, // Just the outer curves of a path; the interior will be triangulated.
- interiorTriangulation
- };
-
- constexpr static uint32_t PatchSegmentSpan(DrawType drawType)
- {
- switch (drawType)
- {
- case DrawType::midpointFanPatches:
- return kMidpointFanPatchSegmentSpan;
- case DrawType::outerCurvePatches:
- return kOuterCurvePatchSegmentSpan;
- default:
- RIVE_UNREACHABLE();
- }
- }
-
- constexpr static uint32_t PatchIndexCount(DrawType drawType)
- {
- switch (drawType)
- {
- case DrawType::midpointFanPatches:
- return kMidpointFanPatchIndexCount;
- case DrawType::outerCurvePatches:
- return kOuterCurvePatchIndexCount;
- default:
- RIVE_UNREACHABLE();
- }
- }
-
- constexpr static uintptr_t PatchBaseIndex(DrawType drawType)
- {
- switch (drawType)
- {
- case DrawType::midpointFanPatches:
- return kMidpointFanPatchBaseIndex;
- case DrawType::outerCurvePatches:
- return kOuterCurvePatchBaseIndex;
- default:
- RIVE_UNREACHABLE();
- }
- }
-
- static uint32_t ShaderUniqueKey(SourceType sourceType,
- DrawType drawType,
- const ShaderFeatures& shaderFeatures)
- {
- return (shaderFeatures.getPreprocessorDefines(sourceType) << 1) |
- (drawType == DrawType::interiorTriangulation);
- }
-
- // Linked list of draws to be issued by the subclass during onFlush().
- struct Draw
- {
- Draw(DrawType drawType_, uint32_t baseVertexOrInstance_) :
- drawType(drawType_), baseVertexOrInstance(baseVertexOrInstance_)
- {}
- const DrawType drawType;
- uint32_t baseVertexOrInstance;
- uint32_t vertexOrInstanceCount = 0; // Calculated during PLSRenderContext::flush().
- ShaderFeatures shaderFeatures;
- GrInnerFanTriangulator* triangulator = nullptr; // Used by "interiorTriangulation" draws.
- };
+ const std::unique_ptr<PLSRenderContextImpl> m_impl;
PerFlushLinkedList<Draw> m_drawList;
- size_t m_drawListCount = 0;
// GrTriangulator provides an upper bound on the number of vertices it will emit. Triangulations
// are not writen out until the last minute, during flush(), and this variable provides an upper
// bound on the number of vertices that will be written.
size_t m_maxTriangleVertexCount = 0;
-private:
static BlendTier BlendTierForBlendMode(PLSBlendMode);
// Allocates a horizontal span of texels in the gradient texture and schedules either a texture
@@ -551,7 +406,7 @@
// Resources allocated at flush time (after we already know exactly how big they need to
// be).
- size_t triangleVertexBufferSize;
+ size_t triangleVertexBufferCount;
size_t gradientTextureHeight;
size_t tessellationTextureHeight;
@@ -564,8 +419,8 @@
maxComplexGradientSpans =
std::max(maxComplexGradientSpans, other.maxComplexGradientSpans);
maxTessellationSpans = std::max(maxTessellationSpans, other.maxTessellationSpans);
- triangleVertexBufferSize =
- std::max(triangleVertexBufferSize, other.triangleVertexBufferSize);
+ triangleVertexBufferCount =
+ std::max(triangleVertexBufferCount, other.triangleVertexBufferCount);
gradientTextureHeight = std::max(gradientTextureHeight, other.gradientTextureHeight);
tessellationTextureHeight =
std::max(tessellationTextureHeight, other.tessellationTextureHeight);
@@ -589,9 +444,9 @@
if (maxTessellationSpans > threshold.maxTessellationSpans)
scaled.maxTessellationSpans =
static_cast<double>(maxTessellationSpans) * scaleFactor;
- if (triangleVertexBufferSize > threshold.triangleVertexBufferSize)
- scaled.triangleVertexBufferSize =
- static_cast<double>(triangleVertexBufferSize) * scaleFactor;
+ if (triangleVertexBufferCount > threshold.triangleVertexBufferCount)
+ scaled.triangleVertexBufferCount =
+ static_cast<double>(triangleVertexBufferCount) * scaleFactor;
if (gradientTextureHeight > threshold.gradientTextureHeight)
scaled.gradientTextureHeight =
static_cast<double>(gradientTextureHeight) * scaleFactor;
@@ -614,7 +469,7 @@
GPUResourceLimits resetFlushTimeLimits() const
{
GPUResourceLimits noFlushTimeLimits = *this;
- noFlushTimeLimits.triangleVertexBufferSize = 0;
+ noFlushTimeLimits.triangleVertexBufferCount = 0;
noFlushTimeLimits.gradientTextureHeight = 0;
noFlushTimeLimits.tessellationTextureHeight = 0;
return noFlushTimeLimits;
@@ -641,29 +496,18 @@
// whether the buffer needs to be updated at the beginning of a flush.
FlushUniforms m_cachedUniformData{0, 0, 0, 0, 0, m_platformFeatures};
- // Simple gradients only have 2 texels, so we write them to mapped texture memory from the CPU
- // instead of rendering them.
- struct TwoTexelRamp
- {
- void set(const ColorInt colors[2])
- {
- UnpackColorToRGBA8(colors[0], colorData);
- UnpackColorToRGBA8(colors[1], colorData + 4);
- }
- uint8_t colorData[8];
- };
-
- BufferRing<PathData> m_pathBuffer;
- BufferRing<ContourData> m_contourBuffer;
- BufferRing<TwoTexelRamp> m_simpleColorRampsBuffer; // Simple gradients get written by the CPU.
- BufferRing<GradientSpan> m_gradSpanBuffer; // Complex gradients get rendered by the GPU.
- BufferRing<TessVertexSpan> m_tessSpanBuffer;
- BufferRing<TriangleVertex> m_triangleBuffer;
- BufferRing<FlushUniforms> m_uniformBuffer;
+ WriteOnlyMappedMemory<PathData> m_pathData;
+ WriteOnlyMappedMemory<ContourData> m_contourData;
+ // Simple gradients get written by the CPU.
+ WriteOnlyMappedMemory<TwoTexelRamp> m_simpleColorRampsData;
+ // Complex gradients get rendered by the GPU.
+ WriteOnlyMappedMemory<GradientSpan> m_gradSpanData;
+ WriteOnlyMappedMemory<TessVertexSpan> m_tessSpanData;
+ WriteOnlyMappedMemory<TriangleVertex> m_triangleVertexData;
// How many rows of the gradient texture are dedicated to simple (two-texel) ramps?
// This is also the y-coordinate at which the complex color ramps begin.
- size_t m_reservedGradTextureRowsForSimpleRamps = 0;
+ size_t m_reservedSimpleGradientRowCount = 0;
// Per-frame state.
FrameDescriptor m_frameDescriptor;
@@ -702,10 +546,11 @@
TrivialBlockAllocator m_trivialPerFlushAllocator{kPerFlushAllocatorInitialBlockSize};
};
-template <typename T> bool PLSRenderContext::PerFlushLinkedList<T>::empty() const
+template <typename T> size_t PLSRenderContext::PerFlushLinkedList<T>::count() const
{
assert(!!m_head == !!m_tail);
- return m_tail == nullptr;
+ assert(!!m_tail == !!m_count);
+ return m_count;
}
template <typename T> T& PLSRenderContext::PerFlushLinkedList<T>::tail() const
@@ -729,6 +574,13 @@
m_tail->next = node;
}
m_tail = node;
+ ++m_count;
}
+template <typename T> void PLSRenderContext::PerFlushLinkedList<T>::reset()
+{
+ m_tail = nullptr;
+ m_head = nullptr;
+ m_count = 0;
+}
} // namespace rive::pls
diff --git a/include/rive/pls/pls_render_context_buffer_ring_impl.hpp b/include/rive/pls/pls_render_context_buffer_ring_impl.hpp
new file mode 100644
index 0000000..d92c162
--- /dev/null
+++ b/include/rive/pls/pls_render_context_buffer_ring_impl.hpp
@@ -0,0 +1,85 @@
+/*
+ * Copyright 2023 Rive
+ */
+
+#pragma once
+
+#include "rive/pls/pls_render_context_impl.hpp"
+#include "rive/pls/buffer_ring.hpp"
+
+namespace rive::pls
+{
+class PLSRenderContextBufferRingImpl : public PLSRenderContextImpl
+{
+public:
+ PLSRenderContextBufferRingImpl(const PlatformFeatures& platformFeatures)
+ {
+ m_platformFeatures = platformFeatures;
+ }
+
+ void resizePathTexture(size_t width, size_t height) override;
+ void resizeContourTexture(size_t width, size_t height) override;
+ void resizeSimpleColorRampsBuffer(size_t sizeInBytes) override;
+ void resizeGradSpanBuffer(size_t sizeInBytes) override;
+ void resizeTessVertexSpanBuffer(size_t sizeInBytes) override;
+ void resizeTriangleVertexBuffer(size_t sizeInBytes) override;
+
+ void resizeGradientTexture(size_t height) override { allocateGradientTexture(height); }
+ void resizeTessellationTexture(size_t height) override { allocateTessellationTexture(height); }
+
+ void* mapPathTexture() override { return m_pathBuffer->mapBuffer(); }
+ void* mapContourTexture() override { return m_contourBuffer->mapBuffer(); }
+ void* mapSimpleColorRampsBuffer() override { return m_simpleColorRampsBuffer->mapBuffer(); }
+ void* mapGradSpanBuffer() override { return m_gradSpanBuffer->mapBuffer(); }
+ void* mapTessVertexSpanBuffer() override { return m_tessSpanBuffer->mapBuffer(); }
+ void* mapTriangleVertexBuffer() override { return m_triangleBuffer->mapBuffer(); }
+
+ void unmapPathTexture(size_t widthWritten, size_t heightWritten) override;
+ void unmapContourTexture(size_t widthWritten, size_t heightWritten) override;
+ void unmapSimpleColorRampsBuffer(size_t bytesWritten) override;
+ void unmapGradSpanBuffer(size_t bytesWritten) override;
+ void unmapTessVertexSpanBuffer(size_t bytesWritten) override;
+ void unmapTriangleVertexBuffer(size_t bytesWritten) override;
+
+ void updateFlushUniforms(const FlushUniforms*) override;
+
+protected:
+ const TexelBufferRing* pathBufferRing() { return m_pathBuffer.get(); }
+ const TexelBufferRing* contourBufferRing() { return m_contourBuffer.get(); }
+ const BufferRingImpl* simpleColorRampsBufferRing() const
+ {
+ return m_simpleColorRampsBuffer.get();
+ }
+ const BufferRingImpl* gradSpanBufferRing() const { return m_gradSpanBuffer.get(); }
+ const BufferRingImpl* tessSpanBufferRing() { return m_tessSpanBuffer.get(); }
+ const BufferRingImpl* triangleBufferRing() { return m_triangleBuffer.get(); }
+ const BufferRingImpl* uniformBufferRing() const { return m_uniformBuffer.get(); }
+
+ virtual std::unique_ptr<BufferRingImpl> makeVertexBufferRing(size_t capacity,
+ size_t itemSizeInBytes) = 0;
+
+ virtual std::unique_ptr<TexelBufferRing> makeTexelBufferRing(TexelBufferRing::Format,
+ size_t widthInItems,
+ size_t height,
+ size_t texelsPerItem,
+ int textureIdx,
+ TexelBufferRing::Filter) = 0;
+
+ virtual std::unique_ptr<BufferRingImpl> makePixelUnpackBufferRing(size_t capacity,
+ size_t itemSizeInBytes) = 0;
+
+ virtual std::unique_ptr<BufferRingImpl> makeUniformBufferRing(size_t sizeInBytes) = 0;
+
+ virtual void allocateGradientTexture(size_t height) = 0;
+ virtual void allocateTessellationTexture(size_t height) = 0;
+
+private:
+ std::unique_ptr<TexelBufferRing> m_pathBuffer;
+ std::unique_ptr<TexelBufferRing> m_contourBuffer;
+ std::unique_ptr<BufferRingImpl> m_simpleColorRampsBuffer;
+ std::unique_ptr<BufferRingImpl> m_gradSpanBuffer;
+ std::unique_ptr<BufferRingImpl> m_tessSpanBuffer;
+ std::unique_ptr<BufferRingImpl> m_triangleBuffer;
+ std::unique_ptr<BufferRingImpl> m_uniformBuffer;
+};
+} // namespace rive::pls
diff --git a/include/rive/pls/pls_render_context_impl.hpp b/include/rive/pls/pls_render_context_impl.hpp
new file mode 100644
index 0000000..7ef295f
--- /dev/null
+++ b/include/rive/pls/pls_render_context_impl.hpp
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2023 Rive
+ */
+
+#pragma once
+
+#include "rive/pls/pls_render_context.hpp"
+
+namespace rive::pls
+{
+class PLSRenderContextImpl
+{
+public:
+ virtual ~PLSRenderContextImpl() {}
+
+ const PlatformFeatures& platformFeatures() const { return m_platformFeatures; }
+
+ virtual void prepareToMapBuffers() {}
+
+ virtual void resizePathTexture(size_t width, size_t height) = 0;
+ virtual void resizeContourTexture(size_t width, size_t height) = 0;
+ virtual void resizeSimpleColorRampsBuffer(size_t sizeInBytes) = 0;
+ virtual void resizeGradSpanBuffer(size_t sizeInBytes) = 0;
+ virtual void resizeTessVertexSpanBuffer(size_t sizeInBytes) = 0;
+ virtual void resizeTriangleVertexBuffer(size_t sizeInBytes) = 0;
+ virtual void resizeGradientTexture(size_t height) = 0;
+ virtual void resizeTessellationTexture(size_t height) = 0;
+
+ virtual void* mapPathTexture() = 0;
+ virtual void* mapContourTexture() = 0;
+ virtual void* mapSimpleColorRampsBuffer() = 0;
+ virtual void* mapGradSpanBuffer() = 0;
+ virtual void* mapTessVertexSpanBuffer() = 0;
+ virtual void* mapTriangleVertexBuffer() = 0;
+
+ virtual void unmapPathTexture(size_t widthWritten, size_t heightWritten) = 0;
+ virtual void unmapContourTexture(size_t widthWritten, size_t heightWritten) = 0;
+ virtual void unmapSimpleColorRampsBuffer(size_t bytesWritten) = 0;
+ virtual void unmapGradSpanBuffer(size_t bytesWritten) = 0;
+ virtual void unmapTessVertexSpanBuffer(size_t bytesWritten) = 0;
+ virtual void unmapTriangleVertexBuffer(size_t bytesWritten) = 0;
+
+ virtual void updateFlushUniforms(const FlushUniforms*) = 0;
+
+ virtual void flush(const PLSRenderContext::FlushDescriptor&) = 0;
+
+protected:
+ PlatformFeatures m_platformFeatures;
+};
+} // namespace rive::pls
diff --git a/obfuscator/pls_renames.h b/obfuscator/pls_renames.h
index 45283ed..d5c0ca3 100644
--- a/obfuscator/pls_renames.h
+++ b/obfuscator/pls_renames.h
@@ -57,7 +57,7 @@
#define PLSPaint r_38
#define PLSPath r_39
#define PLSRenderContext r_3a
-#define PLSRenderContextGL r_3b
+#define PLSRenderContextGLImpl r_3b
#define PLSRenderContextMetal r_3c
#define PLSRenderTarget r_3d
#define PLSRenderTargetGL r_3e
diff --git a/out/premake5_pls_renderer.lua b/out/premake5_pls_renderer.lua
index dd3e22b..f24dd44 100644
--- a/out/premake5_pls_renderer.lua
+++ b/out/premake5_pls_renderer.lua
@@ -121,7 +121,7 @@
do
files {"../renderer/gl/buffer_ring_gl.cpp",
"../renderer/gl/gl_utils.cpp",
- "../renderer/gl/pls_render_context_gl.cpp",
+ "../renderer/gl/pls_render_context_gl_impl.cpp",
"../renderer/gl/pls_render_target_gl.cpp"}
end
diff --git a/path_fiddle/fiddle_context_d3d.cpp b/path_fiddle/fiddle_context_d3d.cpp
index 10b6829..60498f8 100644
--- a/path_fiddle/fiddle_context_d3d.cpp
+++ b/path_fiddle/fiddle_context_d3d.cpp
@@ -2,7 +2,7 @@
#include "rive/pls/pls_factory.hpp"
#include "rive/pls/pls_renderer.hpp"
-#include "rive/pls/d3d/pls_render_context_d3d.hpp"
+#include "rive/pls/d3d/pls_render_context_d3d_impl.hpp"
#include "rive/pls/d3d/d3d11.hpp"
#include <array>
#include <dxgi1_2.h>
@@ -25,7 +25,8 @@
m_d3dFactory(std::move(d3dFactory)),
m_gpu(std::move(gpu)),
m_gpuContext(std::move(gpuContext)),
- m_plsContext(new PLSRenderContextD3D(m_gpu, m_gpuContext, isIntel))
+ m_plsContext(new PLSRenderContext(
+ std::make_unique<PLSRenderContextD3DImpl>(m_gpu, m_gpuContext, isIntel)))
{}
float dpiScale() const override { return 1; }
@@ -51,7 +52,8 @@
NULL,
m_swapchain.GetAddressOf()));
- m_renderTarget = m_plsContext->makeRenderTarget(width, height);
+ auto d3dContext = static_cast<PLSRenderContextD3DImpl*>(m_plsContext->impl());
+ m_renderTarget = d3dContext->makeRenderTarget(width, height);
}
void toggleZoomWindow() override {}
@@ -91,7 +93,7 @@
ComPtr<ID3D11Device> m_gpu;
ComPtr<ID3D11DeviceContext> m_gpuContext;
ComPtr<IDXGISwapChain1> m_swapchain;
- std::unique_ptr<PLSRenderContextD3D> m_plsContext;
+ std::unique_ptr<PLSRenderContext> m_plsContext;
rcp<PLSRenderTargetD3D> m_renderTarget;
};
diff --git a/path_fiddle/fiddle_context_gl.cpp b/path_fiddle/fiddle_context_gl.cpp
index 03ebb40..4da4033 100644
--- a/path_fiddle/fiddle_context_gl.cpp
+++ b/path_fiddle/fiddle_context_gl.cpp
@@ -3,7 +3,7 @@
#include "rive/pls/gl/gles3.hpp"
#include "rive/pls/pls_factory.hpp"
#include "rive/pls/pls_renderer.hpp"
-#include "rive/pls/gl/pls_render_context_gl.hpp"
+#include "rive/pls/gl/pls_render_context_gl_impl.hpp"
#include "rive/pls/gl/pls_render_target_gl.hpp"
#ifdef RIVE_WASM
@@ -274,7 +274,8 @@
void onSizeChanged(int width, int height) override
{
- m_renderTarget = m_plsContext->makeOffscreenRenderTarget(width, height);
+ auto glContext = static_cast<PLSRenderContextGLImpl*>(m_plsContext->impl());
+ m_renderTarget = glContext->makeOffscreenRenderTarget(width, height);
}
std::unique_ptr<Renderer> makeRenderer(int width, int height) override
@@ -305,7 +306,8 @@
void shrinkGPUResourcesToFit() final { m_plsContext->shrinkGPUResourcesToFit(); }
private:
- std::unique_ptr<PLSRenderContextGL> m_plsContext = PLSRenderContextGL::Make();
+ std::unique_ptr<PLSRenderContext> m_plsContext =
+ std::make_unique<PLSRenderContext>(PLSRenderContextGLImpl::Make());
rcp<PLSRenderTargetGL> m_renderTarget;
};
diff --git a/path_fiddle/fiddle_context_metal.mm b/path_fiddle/fiddle_context_metal.mm
index e77ca29..01c107d 100644
--- a/path_fiddle/fiddle_context_metal.mm
+++ b/path_fiddle/fiddle_context_metal.mm
@@ -2,7 +2,7 @@
#include "rive/pls/pls_factory.hpp"
#include "rive/pls/pls_renderer.hpp"
-#include "rive/pls/gl/pls_render_context_gl.hpp"
+#include "rive/pls/gl/pls_render_context_gl_impl.hpp"
#include "rive/pls/gl/pls_render_target_gl.hpp"
#include "rive/pls/metal/pls_render_context_metal.h"
#include "rive/pls/metal/pls_render_target_metal.h"
diff --git a/renderer/d3d/pls_render_context_d3d.cpp b/renderer/d3d/pls_render_context_d3d_impl.cpp
similarity index 95%
rename from renderer/d3d/pls_render_context_d3d.cpp
rename to renderer/d3d/pls_render_context_d3d_impl.cpp
index 7f1ef56..4cbee67 100644
--- a/renderer/d3d/pls_render_context_d3d.cpp
+++ b/renderer/d3d/pls_render_context_d3d_impl.cpp
@@ -2,7 +2,7 @@
* Copyright 2023 Rive
*/
-#include "rive/pls/d3d/pls_render_context_d3d.hpp"
+#include "rive/pls/d3d/pls_render_context_d3d_impl.hpp"
#include <D3DCompiler.h>
#include <sstream>
@@ -151,10 +151,10 @@
return platformFeatures;
}
-PLSRenderContextD3D::PLSRenderContextD3D(ComPtr<ID3D11Device> gpu,
- ComPtr<ID3D11DeviceContext> gpuContext,
- bool isIntel) :
- PLSRenderContext(platform_features_d3d()),
+PLSRenderContextD3DImpl::PLSRenderContextD3DImpl(ComPtr<ID3D11Device> gpu,
+ ComPtr<ID3D11DeviceContext> gpuContext,
+ bool isIntel) :
+ PLSRenderContextBufferRingImpl(platform_features_d3d()),
m_isIntel(isIntel),
m_gpu(gpu),
m_gpuContext(gpuContext)
@@ -345,7 +345,6 @@
desc.Usage = D3D11_USAGE_DEFAULT;
desc.BindFlags = bindFlags;
desc.CPUAccessFlags = 0;
- desc.StructureByteStride = itemSizeInBytes;
for (size_t i = 0; i < kBufferRingSize; ++i)
{
@@ -383,8 +382,9 @@
ComPtr<ID3D11Buffer> m_buffers[kBufferRingSize];
};
-std::unique_ptr<BufferRingImpl> PLSRenderContextD3D::makeVertexBufferRing(size_t capacity,
- size_t itemSizeInBytes)
+std::unique_ptr<BufferRingImpl> PLSRenderContextD3DImpl::makeVertexBufferRing(
+ size_t capacity,
+ size_t itemSizeInBytes)
{
return std::make_unique<BufferRingD3D>(m_gpu.Get(),
m_gpuContext,
@@ -393,7 +393,7 @@
D3D11_BIND_VERTEX_BUFFER);
}
-std::unique_ptr<BufferRingImpl> PLSRenderContextD3D::makePixelUnpackBufferRing(
+std::unique_ptr<BufferRingImpl> PLSRenderContextD3DImpl::makePixelUnpackBufferRing(
size_t capacity,
size_t itemSizeInBytes)
{
@@ -401,7 +401,8 @@
return std::make_unique<CPUOnlyBufferRing>(capacity, itemSizeInBytes);
}
-std::unique_ptr<BufferRingImpl> PLSRenderContextD3D::makeUniformBufferRing(size_t itemSizeInBytes)
+std::unique_ptr<BufferRingImpl> PLSRenderContextD3DImpl::makeUniformBufferRing(
+ size_t itemSizeInBytes)
{
return std::make_unique<BufferRingD3D>(m_gpu.Get(),
m_gpuContext,
@@ -456,7 +457,7 @@
ComPtr<ID3D11ShaderResourceView> m_srvs[kBufferRingSize];
};
-std::unique_ptr<TexelBufferRing> PLSRenderContextD3D::makeTexelBufferRing(
+std::unique_ptr<TexelBufferRing> PLSRenderContextD3DImpl::makeTexelBufferRing(
TexelBufferRing::Format format,
size_t widthInItems,
size_t height,
@@ -510,12 +511,12 @@
m_targetUAV = make_simple_2d_uav(gpu, m_targetTexture.Get(), DXGI_FORMAT_R8G8B8A8_UNORM);
}
-rcp<PLSRenderTargetD3D> PLSRenderContextD3D::makeRenderTarget(size_t width, size_t height)
+rcp<PLSRenderTargetD3D> PLSRenderContextD3DImpl::makeRenderTarget(size_t width, size_t height)
{
return rcp(new PLSRenderTargetD3D(m_gpu.Get(), width, height));
}
-void PLSRenderContextD3D::allocateGradientTexture(size_t height)
+void PLSRenderContextD3DImpl::allocateGradientTexture(size_t height)
{
m_gradTexture = make_simple_2d_texture(m_gpu.Get(),
DXGI_FORMAT_R8G8B8A8_UNORM,
@@ -528,7 +529,7 @@
make_simple_2d_rtv(m_gpu.Get(), m_gradTexture.Get(), DXGI_FORMAT_R8G8B8A8_UNORM);
}
-void PLSRenderContextD3D::allocateTessellationTexture(size_t height)
+void PLSRenderContextD3DImpl::allocateTessellationTexture(size_t height)
{
m_tessTexture = make_simple_2d_texture(m_gpu.Get(),
DXGI_FORMAT_R32G32B32A32_UINT,
@@ -541,8 +542,8 @@
make_simple_2d_rtv(m_gpu.Get(), m_tessTexture.Get(), DXGI_FORMAT_R32G32B32A32_UINT);
}
-void PLSRenderContextD3D::setPipelineLayoutAndShaders(DrawType drawType,
- const ShaderFeatures& shaderFeatures)
+void PLSRenderContextD3DImpl::setPipelineLayoutAndShaders(DrawType drawType,
+ const ShaderFeatures& shaderFeatures)
{
uint32_t vertexShaderKey = ShaderUniqueKey(SourceType::vertexOnly, drawType, shaderFeatures);
auto vertexEntry = m_drawVertexShaders.find(vertexShaderKey);
@@ -670,16 +671,15 @@
return static_cast<const TexelBufferD3D*>(texelBufferRing)->submittedSRV();
}
-void PLSRenderContextD3D::onFlush(const FlushDescriptor& desc)
+void PLSRenderContextD3DImpl::flush(const PLSRenderContext::FlushDescriptor& desc)
{
- auto renderTarget =
- static_cast<const PLSRenderTargetD3D*>(frameDescriptor().renderTarget.get());
+ auto renderTarget = static_cast<const PLSRenderTargetD3D*>(desc.renderTarget);
constexpr static UINT kZero[4]{};
if (desc.loadAction == LoadAction::clear)
{
float clearColor4f[4];
- UnpackColorToRGBA32F(frameDescriptor().clearColor, clearColor4f);
+ UnpackColorToRGBA32F(desc.clearColor, clearColor4f);
m_gpuContext->ClearUnorderedAccessViewFloat(renderTarget->m_targetUAV.Get(), clearColor4f);
}
m_gpuContext->ClearUnorderedAccessViewUint(renderTarget->m_coverageUAV.Get(), kZero);
@@ -803,7 +803,11 @@
static_assert(kTriangleVertexDataSlot == 1);
UINT vertexStrides[] = {sizeof(PatchVertex), sizeof(TriangleVertex)};
UINT vertexOffsets[] = {0, 0};
- m_gpuContext->IASetVertexBuffers(0, 2, vertexBuffers, vertexStrides, vertexOffsets);
+ m_gpuContext->IASetVertexBuffers(0,
+ desc.hasTriangleVertices ? 2 : 1,
+ vertexBuffers,
+ vertexStrides,
+ vertexOffsets);
ID3D11ShaderResourceView* vertexTextureViews[] = {m_tessTextureSRV.Get(),
submitted_srv(pathBufferRing()),
@@ -820,14 +824,14 @@
0,
1};
m_gpuContext->RSSetViewports(1, &viewport);
- if (frameDescriptor().wireframe)
+ if (desc.wireframe)
{
m_gpuContext->RSSetState(m_debugWireframeState.Get());
}
m_gpuContext->PSSetShaderResources(kGradTextureIdx, 1, m_gradTextureSRV.GetAddressOf());
- for (const Draw& draw : m_drawList)
+ for (const Draw& draw : *desc.drawList)
{
if (draw.vertexOrInstanceCount == 0)
{
@@ -857,7 +861,7 @@
}
}
- if (frameDescriptor().wireframe)
+ if (desc.wireframe)
{
m_gpuContext->RSSetState(m_rasterState.Get());
}
diff --git a/renderer/gl/pls_impl_ext_native.cpp b/renderer/gl/pls_impl_ext_native.cpp
index 94c11d4..6bfde49 100644
--- a/renderer/gl/pls_impl_ext_native.cpp
+++ b/renderer/gl/pls_impl_ext_native.cpp
@@ -2,7 +2,7 @@
* Copyright 2023 Rive
*/
-#include "rive/pls/gl/pls_render_context_gl.hpp"
+#include "rive/pls/gl/pls_render_context_gl_impl.hpp"
#include "gl/gl_utils.hpp"
#include "rive/math/simd.hpp"
@@ -86,7 +86,7 @@
GLint m_clearColorUniLocation = -1;
};
-class PLSRenderContextGL::PLSImplEXTNative : public PLSRenderContextGL::PLSImpl
+class PLSRenderContextGLImpl::PLSImplEXTNative : public PLSRenderContextGLImpl::PLSImpl
{
public:
PLSImplEXTNative(const GLExtensions& extensions) : m_extensions(extensions)
@@ -120,30 +120,29 @@
return rcp(new PLSRenderTargetGL(width, height, platformFeatures));
}
- void activatePixelLocalStorage(PLSRenderContextGL* context,
- const PLSRenderTargetGL* renderTarget,
- LoadAction loadAction,
- bool needsClipBuffer) override
+ void activatePixelLocalStorage(PLSRenderContextGLImpl* context,
+ const PLSRenderContext::FlushDescriptor& desc) override
{
assert(context->m_extensions.EXT_shader_pixel_local_storage);
assert(context->m_extensions.EXT_shader_framebuffer_fetch ||
context->m_extensions.ARM_shader_framebuffer_fetch);
+ auto renderTarget = static_cast<const PLSRenderTargetGL*>(desc.renderTarget);
glBindFramebuffer(GL_FRAMEBUFFER, renderTarget->drawFramebufferID());
glEnable(GL_SHADER_PIXEL_LOCAL_STORAGE_EXT);
uint32_t ops = loadstoreops::kClearCoverage;
float clearColor4f[4];
- if (loadAction == LoadAction::clear)
+ if (desc.loadAction == LoadAction::clear)
{
- UnpackColorToRGBA32F(context->frameDescriptor().clearColor, clearColor4f);
+ UnpackColorToRGBA32F(desc.clearColor, clearColor4f);
ops |= loadstoreops::kClearColor;
}
else
{
ops |= loadstoreops::kLoadColor;
}
- if (needsClipBuffer)
+ if (desc.needsClipBuffer)
{
ops |= loadstoreops::kClearClip;
}
@@ -171,7 +170,7 @@
}
}
- void deactivatePixelLocalStorage(PLSRenderContextGL* context) override
+ void deactivatePixelLocalStorage(PLSRenderContextGLImpl* context) override
{
// Issue a fullscreen draw that transfers the color information in pixel local storage to
// the main framebuffer.
@@ -195,7 +194,7 @@
GLuint m_plsLoadStoreVAO = 0;
};
-std::unique_ptr<PLSRenderContextGL::PLSImpl> PLSRenderContextGL::MakePLSImplEXTNative(
+std::unique_ptr<PLSRenderContextGLImpl::PLSImpl> PLSRenderContextGLImpl::MakePLSImplEXTNative(
const GLExtensions& extensions)
{
return std::make_unique<PLSImplEXTNative>(extensions);
diff --git a/renderer/gl/pls_impl_framebuffer_fetch.cpp b/renderer/gl/pls_impl_framebuffer_fetch.cpp
index 7454cd6..79a65f0 100644
--- a/renderer/gl/pls_impl_framebuffer_fetch.cpp
+++ b/renderer/gl/pls_impl_framebuffer_fetch.cpp
@@ -2,7 +2,7 @@
* Copyright 2023 Rive
*/
-#include "rive/pls/gl/pls_render_context_gl.hpp"
+#include "rive/pls/gl/pls_render_context_gl_impl.hpp"
#include "rive/pls/gl/pls_render_target_gl.hpp"
@@ -15,7 +15,7 @@
GL_COLOR_ATTACHMENT2,
GL_COLOR_ATTACHMENT3};
-class PLSRenderContextGL::PLSImplFramebufferFetch : public PLSRenderContextGL::PLSImpl
+class PLSRenderContextGLImpl::PLSImplFramebufferFetch : public PLSRenderContextGLImpl::PLSImpl
{
public:
PLSImplFramebufferFetch(const GLExtensions& extensions) : m_extensions(extensions) {}
@@ -47,13 +47,12 @@
return renderTarget;
}
- void activatePixelLocalStorage(PLSRenderContextGL* context,
- const PLSRenderTargetGL* renderTarget,
- LoadAction loadAction,
- bool needsClipBuffer) override
+ void activatePixelLocalStorage(PLSRenderContextGLImpl* context,
+ const PLSRenderContext::FlushDescriptor& desc) override
{
assert(context->m_extensions.EXT_shader_framebuffer_fetch);
+ auto renderTarget = static_cast<const PLSRenderTargetGL*>(desc.renderTarget);
glBindFramebuffer(GL_FRAMEBUFFER, renderTarget->drawFramebufferID());
// Enable multiple render targets, with a draw buffer for each PLS plane.
@@ -63,26 +62,26 @@
// exception of the color buffer after an intermediate flush.
static_assert(kFramebufferPlaneIdx == 0);
glInvalidateFramebuffer(GL_FRAMEBUFFER,
- loadAction == LoadAction::clear ? 4 : 3,
- loadAction == LoadAction::clear ? kPLSDrawBuffers
- : kPLSDrawBuffers + 1);
+ desc.loadAction == LoadAction::clear ? 4 : 3,
+ desc.loadAction == LoadAction::clear ? kPLSDrawBuffers
+ : kPLSDrawBuffers + 1);
// Clear the PLS planes.
constexpr static uint32_t kZero[4]{};
- if (loadAction == LoadAction::clear)
+ if (desc.loadAction == LoadAction::clear)
{
float clearColor4f[4];
- UnpackColorToRGBA32F(context->frameDescriptor().clearColor, clearColor4f);
+ UnpackColorToRGBA32F(desc.clearColor, clearColor4f);
glClearBufferfv(GL_COLOR, kFramebufferPlaneIdx, clearColor4f);
}
glClearBufferuiv(GL_COLOR, kCoveragePlaneIdx, kZero);
- if (needsClipBuffer)
+ if (desc.needsClipBuffer)
{
glClearBufferuiv(GL_COLOR, kClipPlaneIdx, kZero);
}
}
- void deactivatePixelLocalStorage(PLSRenderContextGL*) override
+ void deactivatePixelLocalStorage(PLSRenderContextGLImpl*) override
{
// Instruct the driver not to flush PLS contents from tiled memory, with the exception of
// the color buffer.
@@ -124,8 +123,8 @@
const GLExtensions m_extensions;
};
-std::unique_ptr<PLSRenderContextGL::PLSImpl> PLSRenderContextGL::MakePLSImplFramebufferFetch(
- const GLExtensions& extensions)
+std::unique_ptr<PLSRenderContextGLImpl::PLSImpl> PLSRenderContextGLImpl::
+ MakePLSImplFramebufferFetch(const GLExtensions& extensions)
{
return std::make_unique<PLSImplFramebufferFetch>(extensions);
}
diff --git a/renderer/gl/pls_impl_rw_texture.cpp b/renderer/gl/pls_impl_rw_texture.cpp
index 383d240..353f510 100644
--- a/renderer/gl/pls_impl_rw_texture.cpp
+++ b/renderer/gl/pls_impl_rw_texture.cpp
@@ -2,7 +2,7 @@
* Copyright 2023 Rive
*/
-#include "rive/pls/gl/pls_render_context_gl.hpp"
+#include "rive/pls/gl/pls_render_context_gl_impl.hpp"
#include "../out/obj/generated/glsl.exports.h"
@@ -13,7 +13,7 @@
GL_COLOR_ATTACHMENT2,
GL_COLOR_ATTACHMENT3};
-class PLSRenderContextGL::PLSImplRWTexture : public PLSRenderContextGL::PLSImpl
+class PLSRenderContextGLImpl::PLSImplRWTexture : public PLSRenderContextGLImpl::PLSImpl
{
rcp<PLSRenderTargetGL> wrapGLRenderTarget(GLuint framebufferID,
size_t width,
@@ -39,22 +39,22 @@
return renderTarget;
}
- void activatePixelLocalStorage(PLSRenderContextGL* context,
- const PLSRenderTargetGL* renderTarget,
- LoadAction loadAction,
- bool needsClipBuffer) override
+ void activatePixelLocalStorage(PLSRenderContextGLImpl*,
+ const PLSRenderContext::FlushDescriptor& desc) override
{
+ auto renderTarget = static_cast<const PLSRenderTargetGL*>(desc.renderTarget);
+
// Clear the necessary textures.
constexpr static GLuint kZero[4]{};
glBindFramebuffer(GL_FRAMEBUFFER, renderTarget->sideFramebufferID());
- if (loadAction == LoadAction::clear)
+ if (desc.loadAction == LoadAction::clear)
{
float clearColor4f[4];
- UnpackColorToRGBA32F(context->frameDescriptor().clearColor, clearColor4f);
+ UnpackColorToRGBA32F(desc.clearColor, clearColor4f);
glClearBufferfv(GL_COLOR, kFramebufferPlaneIdx, clearColor4f);
}
glClearBufferuiv(GL_COLOR, kCoveragePlaneIdx, kZero);
- if (needsClipBuffer)
+ if (desc.needsClipBuffer)
{
glClearBufferuiv(GL_COLOR, kClipPlaneIdx, kZero);
}
@@ -81,7 +81,7 @@
0,
GL_READ_WRITE,
GL_RGBA8);
- if (needsClipBuffer)
+ if (desc.needsClipBuffer)
{
glBindImageTexture(kClipPlaneIdx,
renderTarget->m_clipTextureID,
@@ -96,7 +96,7 @@
glMemoryBarrier(GL_SHADER_IMAGE_ACCESS_BARRIER_BIT);
}
- void deactivatePixelLocalStorage(PLSRenderContextGL*) override
+ void deactivatePixelLocalStorage(PLSRenderContextGLImpl*) override
{
glMemoryBarrier(GL_ALL_BARRIER_BITS);
}
@@ -106,7 +106,7 @@
void onBarrier() override { return glMemoryBarrier(GL_SHADER_IMAGE_ACCESS_BARRIER_BIT); }
};
-std::unique_ptr<PLSRenderContextGL::PLSImpl> PLSRenderContextGL::MakePLSImplRWTexture()
+std::unique_ptr<PLSRenderContextGLImpl::PLSImpl> PLSRenderContextGLImpl::MakePLSImplRWTexture()
{
return std::make_unique<PLSImplRWTexture>();
}
diff --git a/renderer/gl/pls_impl_webgl.cpp b/renderer/gl/pls_impl_webgl.cpp
index 7a91781..512c79d 100644
--- a/renderer/gl/pls_impl_webgl.cpp
+++ b/renderer/gl/pls_impl_webgl.cpp
@@ -2,7 +2,7 @@
* Copyright 2022 Rive
*/
-#include "rive/pls/gl/pls_render_context_gl.hpp"
+#include "rive/pls/gl/pls_render_context_gl_impl.hpp"
#include <stdio.h>
@@ -15,7 +15,7 @@
namespace rive::pls
{
-class PLSRenderContextGL::PLSImplWebGL : public PLSRenderContextGL::PLSImpl
+class PLSRenderContextGLImpl::PLSImplWebGL : public PLSRenderContextGLImpl::PLSImpl
{
rcp<PLSRenderTargetGL> wrapGLRenderTarget(GLuint framebufferID,
size_t width,
@@ -53,30 +53,29 @@
return renderTarget;
}
- void activatePixelLocalStorage(PLSRenderContextGL* context,
- const PLSRenderTargetGL* renderTarget,
- LoadAction loadAction,
- bool needsClipBuffer) override
+ void activatePixelLocalStorage(PLSRenderContextGLImpl*,
+ const PLSRenderContext::FlushDescriptor& desc) override
{
+ auto renderTarget = static_cast<const PLSRenderTargetGL*>(desc.renderTarget);
glBindFramebuffer(GL_FRAMEBUFFER, renderTarget->drawFramebufferID());
- if (loadAction == LoadAction::clear)
+ if (desc.loadAction == LoadAction::clear)
{
float clearColor4f[4];
- UnpackColorToRGBA32F(context->frameDescriptor().clearColor, clearColor4f);
+ UnpackColorToRGBA32F(desc.clearColor, clearColor4f);
glFramebufferPixelLocalClearValuefvWEBGL(kFramebufferPlaneIdx, clearColor4f);
}
- GLenum loadOps[4] = {(GLenum)(loadAction == LoadAction::clear ? GL_LOAD_OP_CLEAR_WEBGL
- : GL_LOAD_OP_LOAD_WEBGL),
+ GLenum loadOps[4] = {(GLenum)(desc.loadAction == LoadAction::clear ? GL_LOAD_OP_CLEAR_WEBGL
+ : GL_LOAD_OP_LOAD_WEBGL),
GL_LOAD_OP_ZERO_WEBGL,
GL_DONT_CARE,
- (GLenum)(needsClipBuffer ? GL_LOAD_OP_ZERO_WEBGL : GL_DONT_CARE)};
+ (GLenum)(desc.needsClipBuffer ? GL_LOAD_OP_ZERO_WEBGL : GL_DONT_CARE)};
glBeginPixelLocalStorageWEBGL(4, loadOps);
}
- void deactivatePixelLocalStorage(PLSRenderContextGL*) override
+ void deactivatePixelLocalStorage(PLSRenderContextGLImpl*) override
{
constexpr static GLenum kStoreOps[4] = {GL_STORE_OP_STORE_WEBGL,
GL_DONT_CARE,
@@ -88,7 +87,7 @@
const char* shaderDefineName() const override { return GLSL_PLS_IMPL_WEBGL; }
};
-std::unique_ptr<PLSRenderContextGL::PLSImpl> PLSRenderContextGL::MakePLSImplWebGL()
+std::unique_ptr<PLSRenderContextGLImpl::PLSImpl> PLSRenderContextGLImpl::MakePLSImplWebGL()
{
return std::make_unique<PLSImplWebGL>();
}
diff --git a/renderer/gl/pls_render_context_gl.cpp b/renderer/gl/pls_render_context_gl_impl.cpp
similarity index 88%
rename from renderer/gl/pls_render_context_gl.cpp
rename to renderer/gl/pls_render_context_gl_impl.cpp
index 48445dd..70c0e01 100644
--- a/renderer/gl/pls_render_context_gl.cpp
+++ b/renderer/gl/pls_render_context_gl_impl.cpp
@@ -2,7 +2,7 @@
* Copyright 2022 Rive
*/
-#include "rive/pls/gl/pls_render_context_gl.hpp"
+#include "rive/pls/gl/pls_render_context_gl_impl.hpp"
#include "buffer_ring_gl.hpp"
#include "gl_utils.hpp"
@@ -32,10 +32,12 @@
});
#endif
-PLSRenderContextGL::PLSRenderContextGL(const PlatformFeatures& platformFeatures,
- GLExtensions extensions,
- std::unique_ptr<PLSImpl> plsImpl) :
- PLSRenderContext(platformFeatures), m_extensions(extensions), m_plsImpl(std::move(plsImpl))
+PLSRenderContextGLImpl::PLSRenderContextGLImpl(const PlatformFeatures& platformFeatures,
+ GLExtensions extensions,
+ std::unique_ptr<PLSImpl> plsImpl) :
+ PLSRenderContextBufferRingImpl(platformFeatures),
+ m_extensions(extensions),
+ m_plsImpl(std::move(plsImpl))
{
m_shaderVersionString[kShaderVersionStringBuffSize - 1] = '\0';
@@ -175,7 +177,7 @@
#endif
}
-PLSRenderContextGL::~PLSRenderContextGL()
+PLSRenderContextGLImpl::~PLSRenderContextGLImpl()
{
glDeleteProgram(m_colorRampProgram);
glDeleteVertexArrays(1, &m_colorRampVAO);
@@ -192,13 +194,13 @@
glDeleteBuffers(1, &m_patchIndicesBuffer);
}
-std::unique_ptr<BufferRingImpl> PLSRenderContextGL::makeVertexBufferRing(size_t capacity,
- size_t itemSizeInBytes)
+std::unique_ptr<BufferRingImpl> PLSRenderContextGLImpl::makeVertexBufferRing(size_t capacity,
+ size_t itemSizeInBytes)
{
return std::make_unique<BufferGL>(GL_ARRAY_BUFFER, capacity, itemSizeInBytes);
}
-std::unique_ptr<TexelBufferRing> PLSRenderContextGL::makeTexelBufferRing(
+std::unique_ptr<TexelBufferRing> PLSRenderContextGLImpl::makeTexelBufferRing(
TexelBufferRing::Format format,
size_t widthInItems,
size_t height,
@@ -214,19 +216,19 @@
filter);
}
-std::unique_ptr<BufferRingImpl> PLSRenderContextGL::makePixelUnpackBufferRing(
+std::unique_ptr<BufferRingImpl> PLSRenderContextGLImpl::makePixelUnpackBufferRing(
size_t capacity,
size_t itemSizeInBytes)
{
return std::make_unique<BufferGL>(GL_PIXEL_UNPACK_BUFFER, capacity, itemSizeInBytes);
}
-std::unique_ptr<BufferRingImpl> PLSRenderContextGL::makeUniformBufferRing(size_t sizeInBytes)
+std::unique_ptr<BufferRingImpl> PLSRenderContextGLImpl::makeUniformBufferRing(size_t sizeInBytes)
{
return std::make_unique<BufferGL>(GL_UNIFORM_BUFFER, 1, sizeInBytes);
}
-void PLSRenderContextGL::allocateGradientTexture(size_t height)
+void PLSRenderContextGLImpl::allocateGradientTexture(size_t height)
{
glDeleteTextures(1, &m_gradientTexture);
@@ -247,7 +249,7 @@
0);
}
-void PLSRenderContextGL::allocateTessellationTexture(size_t height)
+void PLSRenderContextGLImpl::allocateTessellationTexture(size_t height)
{
glDeleteTextures(1, &m_tessVertexTexture);
@@ -270,13 +272,13 @@
// Wraps a compiled GL shader of draw.glsl, either vertex or fragment, with a specific set of
// features enabled via #define. The set of features to enable is dictated by ShaderFeatures.
-class PLSRenderContextGL::DrawShader
+class PLSRenderContextGLImpl::DrawShader
{
public:
DrawShader(const DrawShader&) = delete;
DrawShader& operator=(const DrawShader&) = delete;
- DrawShader(PLSRenderContextGL* context,
+ DrawShader(PLSRenderContextGLImpl* context,
GLenum shaderType,
DrawType drawType,
const ShaderFeatures& shaderFeatures)
@@ -317,7 +319,7 @@
sources.push_back(glsl::advanced_blend);
}
}
- if (context->m_platformFeatures.avoidFlatVaryings)
+ if (context->platformFeatures().avoidFlatVaryings)
{
sources.push_back("#define " GLSL_OPTIONALLY_FLAT "\n");
}
@@ -343,9 +345,9 @@
GLuint m_id;
};
-PLSRenderContextGL::DrawProgram::DrawProgram(PLSRenderContextGL* context,
- DrawType drawType,
- const ShaderFeatures& shaderFeatures)
+PLSRenderContextGLImpl::DrawProgram::DrawProgram(PLSRenderContextGLImpl* context,
+ DrawType drawType,
+ const ShaderFeatures& shaderFeatures)
{
m_id = glCreateProgram();
@@ -378,14 +380,14 @@
}
}
-PLSRenderContextGL::DrawProgram::~DrawProgram() { glDeleteProgram(m_id); }
+PLSRenderContextGLImpl::DrawProgram::~DrawProgram() { glDeleteProgram(m_id); }
static GLuint gl_buffer_id(const BufferRingImpl* bufferRing)
{
return static_cast<const BufferGL*>(bufferRing)->submittedBufferID();
}
-void PLSRenderContextGL::onFlush(const FlushDescriptor& desc)
+void PLSRenderContextGLImpl::flush(const PLSRenderContext::FlushDescriptor& desc)
{
// All programs use the same set of per-flush uniforms.
glBindBufferBase(GL_UNIFORM_BUFFER, 0, gl_buffer_id(uniformBufferRing()));
@@ -450,7 +452,7 @@
// Compile the draw programs before activating pixel local storage.
// (ANGLE_shader_pixel_local_storage doesn't allow shader compilation while active.)
- for (const Draw& draw : m_drawList)
+ for (const Draw& draw : *desc.drawList)
{
// Compile the draw program before activating pixel local storage.
// Cache specific compilations of draw.glsl by ShaderFeatures.
@@ -460,30 +462,28 @@
}
// Bind the currently-submitted buffer in the triangleBufferRing to its vertex array.
- if (m_maxTriangleVertexCount > 0)
+ if (desc.hasTriangleVertices)
{
bindVAO(m_interiorTrianglesVAO);
glBindBuffer(GL_ARRAY_BUFFER, gl_buffer_id(triangleBufferRing()));
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
}
- glViewport(0, 0, renderTarget()->width(), renderTarget()->height());
+ auto renderTarget = static_cast<const PLSRenderTargetGL*>(desc.renderTarget);
+ glViewport(0, 0, renderTarget->width(), renderTarget->height());
#ifdef RIVE_DESKTOP_GL
- if (m_extensions.ANGLE_polygon_mode && frameDescriptor().wireframe)
+ if (m_extensions.ANGLE_polygon_mode && desc.wireframe)
{
glPolygonModeANGLE(GL_FRONT_AND_BACK, GL_LINE_ANGLE);
glLineWidth(2);
}
#endif
- m_plsImpl->activatePixelLocalStorage(this,
- renderTarget(),
- desc.loadAction,
- desc.needsClipBuffer);
+ m_plsImpl->activatePixelLocalStorage(this, desc);
// Execute the DrawList.
- for (const Draw& draw : m_drawList)
+ for (const Draw& draw : *desc.drawList)
{
if (draw.vertexOrInstanceCount == 0)
{
@@ -538,14 +538,14 @@
m_plsImpl->deactivatePixelLocalStorage(this);
#ifdef RIVE_DESKTOP_GL
- if (m_extensions.ANGLE_polygon_mode && frameDescriptor().wireframe)
+ if (m_extensions.ANGLE_polygon_mode && desc.wireframe)
{
glPolygonModeANGLE(GL_FRONT_AND_BACK, GL_FILL_ANGLE);
}
#endif
}
-void PLSRenderContextGL::bindProgram(GLuint programID)
+void PLSRenderContextGLImpl::bindProgram(GLuint programID)
{
if (programID != m_boundProgramID)
{
@@ -554,7 +554,7 @@
}
}
-void PLSRenderContextGL::bindVAO(GLuint vao)
+void PLSRenderContextGLImpl::bindVAO(GLuint vao)
{
if (vao != m_boundVAO)
{
@@ -563,7 +563,7 @@
}
}
-std::unique_ptr<PLSRenderContextGL> PLSRenderContextGL::Make()
+std::unique_ptr<PLSRenderContextGLImpl> PLSRenderContextGLImpl::Make()
{
GLExtensions extensions{};
GLint extensionCount;
@@ -665,30 +665,32 @@
if (extensions.EXT_shader_pixel_local_storage &&
(extensions.ARM_shader_framebuffer_fetch || extensions.EXT_shader_framebuffer_fetch))
{
- return std::unique_ptr<PLSRenderContextGL>(
- new PLSRenderContextGL(platformFeatures, extensions, MakePLSImplEXTNative(extensions)));
+ return std::unique_ptr<PLSRenderContextGLImpl>(
+ new PLSRenderContextGLImpl(platformFeatures,
+ extensions,
+ MakePLSImplEXTNative(extensions)));
}
if (extensions.EXT_shader_framebuffer_fetch)
{
- return std::unique_ptr<PLSRenderContextGL>(
- new PLSRenderContextGL(platformFeatures,
- extensions,
- MakePLSImplFramebufferFetch(extensions)));
+ return std::unique_ptr<PLSRenderContextGLImpl>(
+ new PLSRenderContextGLImpl(platformFeatures,
+ extensions,
+ MakePLSImplFramebufferFetch(extensions)));
}
#endif
#ifdef RIVE_DESKTOP_GL
if (extensions.ANGLE_shader_pixel_local_storage_coherent)
{
- return std::unique_ptr<PLSRenderContextGL>(
- new PLSRenderContextGL(platformFeatures, extensions, MakePLSImplWebGL()));
+ return std::unique_ptr<PLSRenderContextGLImpl>(
+ new PLSRenderContextGLImpl(platformFeatures, extensions, MakePLSImplWebGL()));
}
if (extensions.ARB_fragment_shader_interlock || extensions.INTEL_fragment_shader_ordering)
{
- return std::unique_ptr<PLSRenderContextGL>(
- new PLSRenderContextGL(platformFeatures, extensions, MakePLSImplRWTexture()));
+ return std::unique_ptr<PLSRenderContextGLImpl>(
+ new PLSRenderContextGLImpl(platformFeatures, extensions, MakePLSImplRWTexture()));
}
#endif
@@ -697,8 +699,8 @@
emscripten_webgl_get_current_context()) &&
emscripten_webgl_shader_pixel_local_storage_is_coherent())
{
- return std::unique_ptr<PLSRenderContextGL>(
- new PLSRenderContextGL(platformFeatures, extensions, MakePLSImplWebGL()));
+ return std::unique_ptr<PLSRenderContextGLImpl>(
+ new PLSRenderContextGLImpl(platformFeatures, extensions, MakePLSImplWebGL()));
}
#endif
diff --git a/renderer/gr_inner_fan_triangulator.hpp b/renderer/gr_inner_fan_triangulator.hpp
index 32b90fb..1924485 100644
--- a/renderer/gr_inner_fan_triangulator.hpp
+++ b/renderer/gr_inner_fan_triangulator.hpp
@@ -48,7 +48,7 @@
void setPathID(uint16_t pathID) { m_pathID = pathID; }
uint16_t pathID() const { return m_pathID; }
- size_t polysToTriangles(pls::BufferRing<pls::TriangleVertex>* bufferRing) const
+ size_t polysToTriangles(pls::WriteOnlyMappedMemory<pls::TriangleVertex>* bufferRing) const
{
if (m_polys == nullptr)
diff --git a/renderer/gr_triangulator.cpp b/renderer/gr_triangulator.cpp
index e1ef9e9..59ceb33 100644
--- a/renderer/gr_triangulator.cpp
+++ b/renderer/gr_triangulator.cpp
@@ -114,11 +114,11 @@
static inline void emit_vertex(Vertex* v,
int winding,
uint16_t pathID,
- pls::BufferRing<pls::TriangleVertex>* bufferRing)
+ pls::WriteOnlyMappedMemory<pls::TriangleVertex>* mappedMemory)
{
// GrTriangulator and pls unfortunately have opposite winding senses.
int16_t plsWeight = -winding;
- bufferRing->emplace_back(v->fPoint, plsWeight, pathID);
+ mappedMemory->emplace_back(v->fPoint, plsWeight, pathID);
}
static void emit_triangle(Vertex* v0,
@@ -126,22 +126,22 @@
Vertex* v2,
int winding,
uint16_t pathID,
- pls::BufferRing<pls::TriangleVertex>* bufferRing)
+ pls::WriteOnlyMappedMemory<pls::TriangleVertex>* mappedMemory)
{
TESS_LOG("emit_triangle %g (%g, %g) %d\n", v0->fID, v0->fPoint.x, v0->fPoint.y, v0->fAlpha);
TESS_LOG(" %g (%g, %g) %d\n", v1->fID, v1->fPoint.x, v1->fPoint.y, v1->fAlpha);
TESS_LOG(" %g (%g, %g) %d\n", v2->fID, v2->fPoint.x, v2->fPoint.y, v2->fAlpha);
#if TESSELLATOR_WIREFRAME
- emit_vertex(v0, winding, pathID, bufferRing);
- emit_vertex(v1, winding, pathID, bufferRing);
- emit_vertex(v1, winding, pathID, bufferRing);
- emit_vertex(v2, winding, pathID, bufferRing);
- emit_vertex(v2, winding, pathID, bufferRing);
- emit_vertex(v0, winding, pathID, bufferRing);
+ emit_vertex(v0, winding, pathID, mappedMemory);
+ emit_vertex(v1, winding, pathID, mappedMemory);
+ emit_vertex(v1, winding, pathID, mappedMemory);
+ emit_vertex(v2, winding, pathID, mappedMemory);
+ emit_vertex(v2, winding, pathID, mappedMemory);
+ emit_vertex(v0, winding, pathID, mappedMemory);
#else
- emit_vertex(v0, winding, pathID, bufferRing);
- emit_vertex(v1, winding, pathID, bufferRing);
- emit_vertex(v2, winding, pathID, bufferRing);
+ emit_vertex(v0, winding, pathID, mappedMemory);
+ emit_vertex(v1, winding, pathID, mappedMemory);
+ emit_vertex(v2, winding, pathID, mappedMemory);
#endif
}
@@ -407,10 +407,11 @@
}
}
-void GrTriangulator::emitMonotonePoly(const MonotonePoly* monotonePoly,
- uint16_t pathID,
- bool reverseTriangles,
- pls::BufferRing<pls::TriangleVertex>* bufferRing) const
+void GrTriangulator::emitMonotonePoly(
+ const MonotonePoly* monotonePoly,
+ uint16_t pathID,
+ bool reverseTriangles,
+ pls::WriteOnlyMappedMemory<pls::TriangleVertex>* mappedMemory) const
{
assert(monotonePoly->fWinding != 0);
Edge* e = monotonePoly->fFirstEdge;
@@ -447,7 +448,7 @@
monotonePoly->fWinding,
pathID,
reverseTriangles,
- bufferRing);
+ mappedMemory);
}
double ax = static_cast<double>(curr->fPoint.x) - prev->fPoint.x;
double ay = static_cast<double>(curr->fPoint.y) - prev->fPoint.y;
@@ -461,7 +462,7 @@
monotonePoly->fWinding,
pathID,
reverseTriangles,
- bufferRing);
+ mappedMemory);
v->fPrev->fNext = v->fNext;
v->fNext->fPrev = v->fPrev;
count--;
@@ -481,19 +482,20 @@
}
}
-void GrTriangulator::emitTriangle(Vertex* prev,
- Vertex* curr,
- Vertex* next,
- int winding,
- uint16_t pathID,
- bool reverseTriangles,
- pls::BufferRing<pls::TriangleVertex>* bufferRing) const
+void GrTriangulator::emitTriangle(
+ Vertex* prev,
+ Vertex* curr,
+ Vertex* next,
+ int winding,
+ uint16_t pathID,
+ bool reverseTriangles,
+ pls::WriteOnlyMappedMemory<pls::TriangleVertex>* mappedMemory) const
{
if (reverseTriangles)
{
std::swap(prev, next);
}
- return emit_triangle(prev, curr, next, winding, pathID, bufferRing);
+ return emit_triangle(prev, curr, next, winding, pathID, mappedMemory);
}
GrTriangulator::Poly::Poly(Vertex* v, int winding) :
@@ -577,7 +579,7 @@
void GrTriangulator::emitPoly(const Poly* poly,
uint16_t pathID,
bool reverseTriangles,
- pls::BufferRing<pls::TriangleVertex>* bufferRing) const
+ pls::WriteOnlyMappedMemory<pls::TriangleVertex>* mappedMemory) const
{
if (poly->fCount < 3)
{
@@ -586,7 +588,7 @@
TESS_LOG("emit() %d, size %d\n", poly->fID, poly->fCount);
for (MonotonePoly* m = poly->fHead; m != nullptr; m = m->fNext)
{
- emitMonotonePoly(m, pathID, reverseTriangles, bufferRing);
+ emitMonotonePoly(m, pathID, reverseTriangles, mappedMemory);
}
}
@@ -2084,17 +2086,18 @@
}
// Stage 6: Triangulate the monotone polygons into a vertex buffer.
-void GrTriangulator::polysToTriangles(const Poly* polys,
- FillRule overrideFillType,
- uint16_t pathID,
- bool reverseTriangles,
- pls::BufferRing<pls::TriangleVertex>* bufferRing) const
+void GrTriangulator::polysToTriangles(
+ const Poly* polys,
+ FillRule overrideFillType,
+ uint16_t pathID,
+ bool reverseTriangles,
+ pls::WriteOnlyMappedMemory<pls::TriangleVertex>* mappedMemory) const
{
for (const Poly* poly = polys; poly; poly = poly->fNext)
{
if (apply_fill_type(overrideFillType, poly))
{
- emitPoly(poly, pathID, reverseTriangles, bufferRing);
+ emitPoly(poly, pathID, reverseTriangles, mappedMemory);
}
}
}
@@ -2178,11 +2181,12 @@
return CountPoints(polys, fFillRule);
}
-size_t GrTriangulator::polysToTriangles(const Poly* polys,
- uint64_t maxVertexCount,
- uint16_t pathID,
- bool reverseTriangles,
- pls::BufferRing<pls::TriangleVertex>* bufferRing) const
+size_t GrTriangulator::polysToTriangles(
+ const Poly* polys,
+ uint64_t maxVertexCount,
+ uint16_t pathID,
+ bool reverseTriangles,
+ pls::WriteOnlyMappedMemory<pls::TriangleVertex>* mappedMemory) const
{
if (0 == maxVertexCount || maxVertexCount > std::numeric_limits<int32_t>::max())
{
@@ -2199,9 +2203,9 @@
}
#endif
- size_t start = bufferRing->bytesWritten();
- polysToTriangles(polys, fFillRule, pathID, reverseTriangles, bufferRing);
- size_t actualCount = (bufferRing->bytesWritten() - start) / vertexStride;
+ size_t start = mappedMemory->bytesWritten();
+ polysToTriangles(polys, fFillRule, pathID, reverseTriangles, mappedMemory);
+ size_t actualCount = (mappedMemory->bytesWritten() - start) / vertexStride;
assert(actualCount <= maxVertexCount * vertexStride);
return actualCount;
}
diff --git a/renderer/gr_triangulator.hpp b/renderer/gr_triangulator.hpp
index 45a4ea3..694cfe6 100644
--- a/renderer/gr_triangulator.hpp
+++ b/renderer/gr_triangulator.hpp
@@ -18,7 +18,6 @@
#include "rive/math/vec2d.hpp"
#include "rive/math/aabb.hpp"
#include "rive/pls/pls.hpp"
-#include "rive/pls/buffer_ring.hpp"
#include "rive/pls/trivial_block_allocator.hpp"
namespace rive
@@ -99,7 +98,7 @@
FillRule overrideFillRule,
uint16_t pathID,
bool reverseTriangles,
- pls::BufferRing<pls::TriangleVertex>*) const;
+ pls::WriteOnlyMappedMemory<pls::TriangleVertex>*) const;
// The vertex sorting in step (3) is a merge sort, since it plays well with the linked list
// of vertices (and the necessity of inserting new vertices on intersection).
@@ -148,18 +147,18 @@
void emitMonotonePoly(const MonotonePoly*,
uint16_t pathID,
bool reverseTriangles,
- pls::BufferRing<pls::TriangleVertex>*) const;
+ pls::WriteOnlyMappedMemory<pls::TriangleVertex>*) const;
void emitTriangle(Vertex* prev,
Vertex* curr,
Vertex* next,
int winding,
uint16_t pathID,
bool reverseTriangles,
- pls::BufferRing<pls::TriangleVertex>*) const;
+ pls::WriteOnlyMappedMemory<pls::TriangleVertex>*) const;
void emitPoly(const Poly*,
uint16_t pathID,
bool reverseTriangles,
- pls::BufferRing<pls::TriangleVertex>*) const;
+ pls::WriteOnlyMappedMemory<pls::TriangleVertex>*) const;
Poly* makePoly(Poly** head, Vertex* v, int winding) const;
void appendPointToContour(const Vec2D& p, VertexList* contour) const;
@@ -247,7 +246,7 @@
uint64_t maxVertexCount,
uint16_t pathID,
bool reverseTriangles,
- pls::BufferRing<pls::TriangleVertex>*) const;
+ pls::WriteOnlyMappedMemory<pls::TriangleVertex>*) const;
AABB fPathBounds;
FillRule fFillRule;
diff --git a/renderer/metal/pls_render_context_metal.mm b/renderer/metal/pls_render_context_metal.mm
index cbf5479..240d7ea 100644
--- a/renderer/metal/pls_render_context_metal.mm
+++ b/renderer/metal/pls_render_context_metal.mm
@@ -507,13 +507,6 @@
thisFlushLock.unlock();
}];
- if (desc.flushType == FlushType::intermediate)
- {
- // The frame isn't complete yet. The caller will begin preparing a new flush immediately
- // after this method returns, so lock buffers for the next flush now.
- lockNextBufferRingIndex();
- }
-
[commandBuffer commit];
}
} // namespace rive::pls
diff --git a/renderer/pls_render_context.cpp b/renderer/pls_render_context.cpp
index c7b6456..f93675e 100644
--- a/renderer/pls_render_context.cpp
+++ b/renderer/pls_render_context.cpp
@@ -8,6 +8,7 @@
#include "pls_path.hpp"
#include "pls_paint.hpp"
#include "rive/math/math_types.hpp"
+#include "rive/pls/pls_render_context_impl.hpp"
#include <string_view>
@@ -29,9 +30,9 @@
constexpr size_t kMinTessTextureHeight = 32;
constexpr size_t kMaxTessTextureHeight = 2048; // GL_MAX_TEXTURE_SIZE spec minimum.
-constexpr size_t kMaxTessellationVertices = kMaxTessTextureHeight * kTessTextureWidth;
+constexpr size_t kMaxTessellationVertexCount = kMaxTessTextureHeight * kTessTextureWidth;
-uint32_t PLSRenderContext::ShaderFeatures::getPreprocessorDefines(SourceType sourceType) const
+uint32_t ShaderFeatures::getPreprocessorDefines(SourceType sourceType) const
{
uint32_t defines = 0;
if (programFeatures.blendTier != BlendTier::srcOver)
@@ -56,7 +57,7 @@
return defines;
}
-PLSRenderContext::BlendTier PLSRenderContext::BlendTierForBlendMode(PLSBlendMode blendMode)
+BlendTier PLSRenderContext::BlendTierForBlendMode(PLSBlendMode blendMode)
{
switch (blendMode)
{
@@ -120,9 +121,10 @@
return x ^ y;
}
-PLSRenderContext::PLSRenderContext(const PlatformFeatures& platformFeatures) :
- m_platformFeatures(platformFeatures),
- m_maxPathID(MaxPathID(m_platformFeatures.pathIDGranularity))
+PLSRenderContext::PLSRenderContext(std::unique_ptr<PLSRenderContextImpl> impl) :
+ m_platformFeatures(impl->platformFeatures()),
+ m_maxPathID(MaxPathID(m_platformFeatures.pathIDGranularity)),
+ m_impl(std::move(impl))
{}
PLSRenderContext::~PLSRenderContext()
@@ -218,13 +220,6 @@
#define COUNT_RESOURCE_SIZE(SIZE_IN_BYTES)
#endif
- // One-time allocation of the uniform buffer ring.
- if (m_uniformBuffer.impl() == nullptr)
- {
- m_uniformBuffer.reset(makeUniformBufferRing(sizeof(FlushUniforms)));
- }
- COUNT_RESOURCE_SIZE(m_uniformBuffer.totalSizeInBytes());
-
// Path data texture ring.
constexpr size_t kMinPathIDCount = kPathTextureWidthInItems * 32; // 32 texels tall.
size_t targetMaxPathID = resource_texture_height<kPathTextureWidthInItems>(targets.maxPathID) *
@@ -236,20 +231,15 @@
resource_texture_height<kPathTextureWidthInItems>(m_currentResourceLimits.maxPathID);
if (shouldReallocate(targetPathTextureHeight, currentPathTextureHeight))
{
- assert(!m_pathBuffer.mapped());
- m_pathBuffer.reset(makeTexelBufferRing(TexelBufferRing::Format::rgba32ui,
- kPathTextureWidthInItems,
- targetPathTextureHeight,
- kPathTexelsPerItem,
- kPathTextureIdx,
- TexelBufferRing::Filter::nearest));
+ assert(!m_pathData);
+ m_impl->resizePathTexture(kPathTextureWidthInTexels, targetPathTextureHeight);
LOG_CHANGED_SIZE("path texture height",
currentPathTextureHeight,
targetPathTextureHeight,
- m_pathBuffer.totalSizeInBytes());
+ m_pathBuffer->totalSizeInBytes());
m_currentResourceLimits.maxPathID = targetMaxPathID;
}
- COUNT_RESOURCE_SIZE(m_pathBuffer.totalSizeInBytes());
+ COUNT_RESOURCE_SIZE(m_pathBuffer->totalSizeInBytes());
// Contour data texture ring.
constexpr size_t kMinContourIDCount = kContourTextureWidthInItems * 32; // 32 texels tall.
@@ -263,109 +253,101 @@
resource_texture_height<kContourTextureWidthInItems>(m_currentResourceLimits.maxContourID);
if (shouldReallocate(targetContourTextureHeight, currentContourTextureHeight))
{
- assert(!m_contourBuffer.mapped());
- m_contourBuffer.reset(makeTexelBufferRing(TexelBufferRing::Format::rgba32ui,
- kContourTextureWidthInItems,
- targetContourTextureHeight,
- kContourTexelsPerItem,
- pls::kContourTextureIdx,
- TexelBufferRing::Filter::nearest));
+ assert(!m_contourData);
+ m_impl->resizeContourTexture(kContourTextureWidthInTexels, targetContourTextureHeight);
LOG_CHANGED_SIZE("contour texture height",
currentContourTextureHeight,
targetContourTextureHeight,
- m_contourBuffer.totalSizeInBytes());
+ m_contourBuffer->totalSizeInBytes());
m_currentResourceLimits.maxContourID = targetMaxContourID;
}
- COUNT_RESOURCE_SIZE(m_contourBuffer.totalSizeInBytes());
+ COUNT_RESOURCE_SIZE(m_contourBuffer->totalSizeInBytes());
// Simple gradient color ramp pixel unpack buffer ring.
- size_t targetSimpleGradientRows =
+ size_t targetSimpleGradientRowCount =
resource_texture_height<kGradTextureWidthInSimpleRamps>(targets.maxSimpleGradients);
- targetSimpleGradientRows =
- std::clamp(targetSimpleGradientRows, kMinSimpleColorRampRows, kMaxSimpleColorRampRows);
+ targetSimpleGradientRowCount =
+ std::clamp(targetSimpleGradientRowCount, kMinSimpleColorRampRows, kMaxSimpleColorRampRows);
assert(m_currentResourceLimits.maxSimpleGradients % kGradTextureWidthInSimpleRamps == 0);
- assert(m_reservedGradTextureRowsForSimpleRamps ==
+ assert(m_reservedSimpleGradientRowCount ==
resource_texture_height<kGradTextureWidthInSimpleRamps>(
m_currentResourceLimits.maxSimpleGradients));
- if (shouldReallocate(targetSimpleGradientRows, m_reservedGradTextureRowsForSimpleRamps))
+ if (shouldReallocate(targetSimpleGradientRowCount, m_reservedSimpleGradientRowCount))
{
- assert(!m_simpleColorRampsBuffer.mapped());
- m_simpleColorRampsBuffer.reset(
- makePixelUnpackBufferRing(targetSimpleGradientRows * kGradTextureWidthInSimpleRamps,
- sizeof(TwoTexelRamp)));
+ assert(!m_simpleColorRampsData);
+ m_impl->resizeSimpleColorRampsBuffer(targetSimpleGradientRowCount *
+ kGradTextureWidthInSimpleRamps * sizeof(TwoTexelRamp));
LOG_CHANGED_SIZE("maxSimpleGradients",
- m_reservedGradTextureRowsForSimpleRamps * kGradTextureWidthInSimpleRamps,
- targetSimpleGradientRows * kGradTextureWidthInSimpleRamps,
- m_simpleColorRampsBuffer.totalSizeInBytes());
+ m_reservedSimpleGradientRowCount * kGradTextureWidthInSimpleRamps,
+ targetSimpleGradientRowCount * kGradTextureWidthInSimpleRamps,
+ m_simpleColorRampsBuffer->totalSizeInBytes());
m_currentResourceLimits.maxSimpleGradients =
- targetSimpleGradientRows * kGradTextureWidthInSimpleRamps;
- m_reservedGradTextureRowsForSimpleRamps = targetSimpleGradientRows;
+ targetSimpleGradientRowCount * kGradTextureWidthInSimpleRamps;
+ m_reservedSimpleGradientRowCount = targetSimpleGradientRowCount;
}
- COUNT_RESOURCE_SIZE(m_simpleColorRampsBuffer.totalSizeInBytes());
+ COUNT_RESOURCE_SIZE(m_simpleColorRampsBuffer->totalSizeInBytes());
// Instance buffer ring for rendering complex gradients.
constexpr size_t kMinComplexGradientSpans = kMinComplexGradients * 32;
constexpr size_t kMaxComplexGradientSpans = kMaxComplexGradients * 64;
- size_t targetComplexGradientSpans = std::clamp(targets.maxComplexGradientSpans,
- kMinComplexGradientSpans,
- kMaxComplexGradientSpans);
- if (shouldReallocate(targetComplexGradientSpans,
+ size_t targetComplexGradientSpanCount = std::clamp(targets.maxComplexGradientSpans,
+ kMinComplexGradientSpans,
+ kMaxComplexGradientSpans);
+ if (shouldReallocate(targetComplexGradientSpanCount,
m_currentResourceLimits.maxComplexGradientSpans))
{
- assert(!m_gradSpanBuffer.mapped());
- m_gradSpanBuffer.reset(
- makeVertexBufferRing(targetComplexGradientSpans, sizeof(GradientSpan)));
+ assert(!m_gradSpanData);
+ m_impl->resizeGradSpanBuffer(targetComplexGradientSpanCount * sizeof(GradientSpan));
LOG_CHANGED_SIZE("maxComplexGradientSpans",
m_currentResourceLimits.maxComplexGradientSpans,
- targetComplexGradientSpans,
- m_gradSpanBuffer.totalSizeInBytes());
- m_currentResourceLimits.maxComplexGradientSpans = targetComplexGradientSpans;
+ targetComplexGradientSpanCount,
+ m_gradSpanBuffer->totalSizeInBytes());
+ m_currentResourceLimits.maxComplexGradientSpans = targetComplexGradientSpanCount;
}
- COUNT_RESOURCE_SIZE(m_gradSpanBuffer.totalSizeInBytes());
+ COUNT_RESOURCE_SIZE(m_gradSpanBuffer->totalSizeInBytes());
// Instance buffer ring for rendering path tessellation vertices.
constexpr size_t kMinTessellationSpans = kMinTessTextureHeight * kTessTextureWidth / 4;
const size_t maxTessellationSpans = kMaxTessTextureHeight * kTessTextureWidth / 8; // ~100MiB
- size_t targetTessellationSpans =
+ size_t targetTessellationSpanCount =
std::clamp(targets.maxTessellationSpans, kMinTessellationSpans, maxTessellationSpans);
- if (shouldReallocate(targetTessellationSpans, m_currentResourceLimits.maxTessellationSpans))
+ if (shouldReallocate(targetTessellationSpanCount, m_currentResourceLimits.maxTessellationSpans))
{
- assert(!m_tessSpanBuffer.mapped());
- m_tessSpanBuffer.reset(
- makeVertexBufferRing(targetTessellationSpans, sizeof(TessVertexSpan)));
+ assert(!m_tessSpanData);
+ m_impl->resizeTessVertexSpanBuffer(targetTessellationSpanCount * sizeof(TessVertexSpan));
LOG_CHANGED_SIZE("maxTessellationSpans",
m_currentResourceLimits.maxTessellationSpans,
- targetTessellationSpans,
- m_tessSpanBuffer.totalSizeInBytes());
- m_currentResourceLimits.maxTessellationSpans = targetTessellationSpans;
+ targetTessellationSpanCount,
+ m_tessSpanBuffer->totalSizeInBytes());
+ m_currentResourceLimits.maxTessellationSpans = targetTessellationSpanCount;
}
- COUNT_RESOURCE_SIZE(m_tessSpanBuffer.totalSizeInBytes());
+ COUNT_RESOURCE_SIZE(m_tessSpanBuffer->totalSizeInBytes());
// Instance buffer ring for literal triangles fed directly by the CPU.
- constexpr size_t kMinTriangleVertices = 3072 * 3; // 324 KiB
+ constexpr size_t kMinTriangleVertexCount = 3072 * 3; // 324 KiB
// Triangle vertices don't have a maximum limit; we let the other components be the limiting
// factor and allocate whatever buffer size we need at flush time.
- size_t targetTriangleVertices =
- std::max(targets.triangleVertexBufferSize, kMinTriangleVertices);
- if (shouldReallocate(targetTriangleVertices, m_currentResourceLimits.triangleVertexBufferSize))
+ size_t targetTriangleVertexCount =
+ std::max(targets.triangleVertexBufferCount, kMinTriangleVertexCount);
+ if (shouldReallocate(targetTriangleVertexCount,
+ m_currentResourceLimits.triangleVertexBufferCount))
{
- assert(!m_triangleBuffer.mapped());
- m_triangleBuffer.reset(
- makeVertexBufferRing(targetTriangleVertices, sizeof(TriangleVertex)));
- LOG_CHANGED_SIZE("triangleVertexBufferSize",
- m_currentResourceLimits.triangleVertexBufferSize,
- targetTriangleVertices,
- m_triangleBuffer.totalSizeInBytes());
- m_currentResourceLimits.triangleVertexBufferSize = targetTriangleVertices;
+ assert(!m_triangleVertexData);
+ m_impl->resizeTriangleVertexBuffer(targetTriangleVertexCount * sizeof(TriangleVertex));
+ LOG_CHANGED_SIZE("triangleVertexBufferCount",
+ m_currentResourceLimits.triangleVertexBufferCount,
+ targetTriangleVertexCount,
+ m_triangleBuffer->totalSizeInBytes());
+ m_currentResourceLimits.triangleVertexBufferCount = targetTriangleVertexCount;
}
- COUNT_RESOURCE_SIZE(m_triangleBuffer.totalSizeInBytes());
+ COUNT_RESOURCE_SIZE(m_triangleBuffer->totalSizeInBytes());
// Gradient color ramp texture.
size_t targetGradTextureHeight =
std::clamp(targets.gradientTextureHeight, kMinGradTextureHeight, kMaxGradTextureHeight);
if (shouldReallocate(targetGradTextureHeight, m_currentResourceLimits.gradientTextureHeight))
{
- allocateGradientTexture(targetGradTextureHeight);
+ m_impl->resizeGradientTexture(targetGradTextureHeight);
LOG_CHANGED_SIZE("gradientTextureHeight",
m_currentResourceLimits.gradientTextureHeight,
targetGradTextureHeight,
@@ -381,7 +363,7 @@
if (shouldReallocate(targetTessTextureHeight,
m_currentResourceLimits.tessellationTextureHeight))
{
- allocateTessellationTexture(targetTessTextureHeight);
+ m_impl->resizeTessellationTexture(targetTessTextureHeight);
LOG_CHANGED_SIZE("tessellationTextureHeight",
m_currentResourceLimits.tessellationTextureHeight,
targetTessTextureHeight,
@@ -402,7 +384,7 @@
growExceededGPUResources(m_maxRecentResourceUsage.resetFlushTimeLimits(), kGPUResourcePadding);
m_frameDescriptor = std::move(frameDescriptor);
m_isFirstFlushOfFrame = true;
- onBeginFrame();
+ m_impl->prepareToMapBuffers();
RIVE_DEBUG_CODE(m_didBeginFrame = true);
}
@@ -461,9 +443,9 @@
newLimits.maxTessellationSpans = maxTessellationSpans;
needsRealloc = true;
}
- assert(!m_pathBuffer.mapped());
- assert(!m_contourBuffer.mapped());
- assert(!m_tessSpanBuffer.mapped());
+ assert(!m_pathData);
+ assert(!m_contourData);
+ assert(!m_tessSpanData);
if (needsRealloc)
{
// The very first draw of the flush overwhelmed our GPU resources. Since we haven't
@@ -472,22 +454,28 @@
}
}
- m_pathBuffer.ensureMapped();
- m_contourBuffer.ensureMapped();
- m_tessSpanBuffer.ensureMapped();
+ if (!m_pathData)
+ {
+ assert(!m_contourData);
+ assert(!m_tessSpanData);
+ m_pathData.reset(m_impl->mapPathTexture(), m_currentResourceLimits.maxPathID);
+ m_contourData.reset(m_impl->mapContourTexture(), m_currentResourceLimits.maxContourID);
+ m_tessSpanData.reset(m_impl->mapTessVertexSpanBuffer(),
+ m_currentResourceLimits.maxTessellationSpans);
+ }
// Does the path fit in our current buffers?
if (m_currentPathID + pathCount <= m_currentResourceLimits.maxPathID &&
m_currentContourID + contourCount <= m_currentResourceLimits.maxContourID &&
- m_tessSpanBuffer.hasRoomFor(maxTessellationSpans) &&
- m_tessVertexCount + maxTessVertexCountWithInternalPadding <= kMaxTessellationVertices)
+ m_tessSpanData.hasRoomFor(maxTessellationSpans) &&
+ m_tessVertexCount + maxTessVertexCountWithInternalPadding <= kMaxTessellationVertexCount)
{
- assert(m_pathBuffer.hasRoomFor(pathCount));
- assert(m_contourBuffer.hasRoomFor(contourCount));
+ assert(m_pathData.hasRoomFor(pathCount));
+ assert(m_contourData.hasRoomFor(contourCount));
RIVE_DEBUG_CODE(m_expectedTessVertexCountAtNextReserve =
m_tessVertexCount +
tessVertexCounter.totalVertexCountIncludingReflectionsAndPadding());
- assert(m_expectedTessVertexCountAtNextReserve <= kMaxTessellationVertices);
+ assert(m_expectedTessVertexCountAtNextReserve <= kMaxTessellationVertexCount);
return true;
}
@@ -540,8 +528,12 @@
return false;
}
rampTexelsIdx = m_simpleGradients.size() * 2;
- m_simpleColorRampsBuffer.ensureMapped();
- m_simpleColorRampsBuffer.set_back(colors);
+ if (!m_simpleColorRampsData)
+ {
+ m_simpleColorRampsData.reset(m_impl->mapSimpleColorRampsBuffer(),
+ m_currentResourceLimits.maxSimpleGradients);
+ }
+ m_simpleColorRampsData.set_back(colors);
m_simpleGradients.insert({simpleKey, rampTexelsIdx});
}
row = rampTexelsIdx / kGradTextureWidth;
@@ -572,7 +564,7 @@
// the gradient span buffer hasn't been mapped yet, we have a unique opportunity to grow
// it if needed.
size_t spanCount = stopCount + 1;
- if (!m_gradSpanBuffer.mapped())
+ if (!m_gradSpanData)
{
if (spanCount > m_currentResourceLimits.maxComplexGradientSpans)
{
@@ -583,10 +575,11 @@
newLimits.maxComplexGradientSpans = spanCount;
growExceededGPUResources(newLimits, kGPUResourceIntermediateGrowthFactor);
}
- m_gradSpanBuffer.ensureMapped();
+ m_gradSpanData.reset(m_impl->mapGradSpanBuffer(),
+ m_currentResourceLimits.maxComplexGradientSpans);
}
- if (!m_gradSpanBuffer.hasRoomFor(spanCount))
+ if (!m_gradSpanData.hasRoomFor(spanCount))
{
// We ran out of instances for rendering complex color ramps. The caller needs to
// flush and try again.
@@ -596,7 +589,7 @@
// Push "GradientSpan" instances that will render each section of the color ramp.
ColorInt lastColor = colors[0];
uint32_t lastXFixed = 0;
- // The viewport will start at m_reservedGradTextureRowsForSimpleRamps when rendering
+ // The viewport will start at m_reservedSimpleGradientRowCount when rendering
// color ramps.
uint32_t y = static_cast<uint32_t>(m_complexGradients.size());
// "stop * w + .5" converts a stop position to an x-coordinate in the gradient texture.
@@ -609,13 +602,13 @@
float x = stops[i] * w + .5f;
uint32_t xFixed = static_cast<uint32_t>(x * (65536.f / kGradTextureWidth));
assert(lastXFixed <= xFixed && xFixed < 65536);
- m_gradSpanBuffer.set_back(lastXFixed, xFixed, y, lastColor, colors[i]);
+ m_gradSpanData.set_back(lastXFixed, xFixed, y, lastColor, colors[i]);
lastColor = colors[i];
lastXFixed = xFixed;
}
- m_gradSpanBuffer.set_back(lastXFixed, 65535u, y, lastColor, lastColor);
+ m_gradSpanData.set_back(lastXFixed, 65535u, y, lastColor, lastColor);
- row = m_reservedGradTextureRowsForSimpleRamps + m_complexGradients.size();
+ row = m_reservedSimpleGradientRowCount + m_complexGradients.size();
m_complexGradients.emplace(std::move(key), row);
}
}
@@ -640,11 +633,11 @@
m_currentPathIsStroked = strokeRadius != 0;
m_currentPathNeedsMirroredContours = !m_currentPathIsStroked;
- m_pathBuffer.set_back(matrix, strokeRadius, fillRule, paintType, clipID, blendMode, paintData);
+ m_pathData.set_back(matrix, strokeRadius, fillRule, paintType, clipID, blendMode, paintData);
++m_currentPathID;
assert(0 < m_currentPathID && m_currentPathID <= m_maxPathID);
- assert(m_currentPathID == m_pathBuffer.bytesWritten() / sizeof(PathData));
+ assert(m_currentPathID == m_pathData.bytesWritten() / sizeof(PathData));
auto drawType = patchType == PatchType::midpointFan ? DrawType::midpointFanPatches
: DrawType::outerCurvePatches;
@@ -686,13 +679,13 @@
RIVE_DEBUG_CODE(m_expectedTessVertexCountAtEndOfPath =
m_tessVertexCount + tessVertexCountWithoutPadding);
assert(m_expectedTessVertexCountAtEndOfPath <= m_expectedTessVertexCountAtNextReserve);
- assert(m_expectedTessVertexCountAtEndOfPath <= kMaxTessellationVertices);
+ assert(m_expectedTessVertexCountAtEndOfPath <= kMaxTessellationVertexCount);
}
void PLSRenderContext::pushContour(Vec2D midpoint, bool closed, uint32_t paddingVertexCount)
{
assert(m_didBeginFrame);
- assert(!m_pathBuffer.empty());
+ assert(m_pathData.bytesWritten() > 0);
assert(m_currentPathIsStroked || closed);
assert(m_currentPathID != 0); // pathID can't be zero.
@@ -700,12 +693,10 @@
{
midpoint.x = closed ? 1 : 0;
}
- m_contourBuffer.emplace_back(midpoint,
- m_currentPathID,
- static_cast<uint32_t>(m_tessVertexCount));
+ m_contourData.emplace_back(midpoint, m_currentPathID, static_cast<uint32_t>(m_tessVertexCount));
++m_currentContourID;
assert(0 < m_currentContourID && m_currentContourID <= kMaxContourID);
- assert(m_currentContourID == m_contourBuffer.bytesWritten() / sizeof(ContourData));
+ assert(m_currentContourID == m_contourData.bytesWritten() / sizeof(ContourData));
// The first curve of the contour will be pre-padded with 'paddingVertexCount' tessellation
// vertices, colocated at T=0. The caller must use this argument align the end of the contour on
@@ -765,7 +756,7 @@
constexpr static uint32_t kInvalidContourID = 0;
assert(m_tessVertexCount == m_expectedTessVertexCountAtEndOfPath);
RIVE_DEBUG_CODE(m_expectedTessVertexCountAtEndOfPath = m_tessVertexCount + count;)
- assert(m_expectedTessVertexCountAtEndOfPath <= kMaxTessellationVertices);
+ assert(m_expectedTessVertexCountAtEndOfPath <= kMaxTessellationVertexCount);
pushTessellationSpans(kEmptyCubic, {0, 0}, count, 0, 0, 1, kInvalidContourID);
assert(m_tessVertexCount == m_expectedTessVertexCountAtEndOfPath);
}
@@ -783,15 +774,15 @@
int32_t x1 = x0 + totalVertexCount;
for (;;)
{
- m_tessSpanBuffer.set_back(pts,
- joinTangent,
- static_cast<float>(y),
- x0,
- x1,
- parametricSegmentCount,
- polarSegmentCount,
- joinSegmentCount,
- contourIDWithFlags);
+ m_tessSpanData.set_back(pts,
+ joinTangent,
+ static_cast<float>(y),
+ x0,
+ x1,
+ parametricSegmentCount,
+ polarSegmentCount,
+ joinSegmentCount,
+ contourIDWithFlags);
if (x1 > static_cast<int32_t>(kTessTextureWidth))
{
// The span was too long to fit on the current line. Wrap and draw it again, this
@@ -829,18 +820,18 @@
for (;;)
{
- m_tessSpanBuffer.set_back(pts,
- joinTangent,
- static_cast<float>(y),
- x0,
- x1,
- static_cast<float>(reflectionY),
- reflectionX0,
- reflectionX1,
- parametricSegmentCount,
- polarSegmentCount,
- joinSegmentCount,
- contourIDWithFlags);
+ m_tessSpanData.set_back(pts,
+ joinTangent,
+ static_cast<float>(y),
+ x0,
+ x1,
+ static_cast<float>(reflectionY),
+ reflectionX0,
+ reflectionX1,
+ parametricSegmentCount,
+ polarSegmentCount,
+ joinSegmentCount,
+ contourIDWithFlags);
if (x1 > static_cast<int32_t>(kTessTextureWidth) || reflectionX1 < 0)
{
// Either the span or its reflection was too long to fit on the current line. Wrap and
@@ -891,7 +882,6 @@
if (m_drawList.empty() || m_drawList.tail().drawType != drawType)
{
m_drawList.emplace_back(this, drawType, baseVertex);
- ++m_drawListCount;
}
ShaderFeatures* shaderFeatures = &m_drawList.tail().shaderFeatures;
if (blendMode > PLSBlendMode::srcOver)
@@ -934,7 +924,7 @@
// The final vertex of the final patch of each contour crosses over into the next contour. (This
// is how we wrap around back to the beginning.) Therefore, the final contour of the flush needs
// an out-of-contour vertex to cross into as well, so we emit a padding vertex here at the end.
- if (!m_tessSpanBuffer.empty())
+ if (m_tessSpanData.bytesWritten() > 0)
{
pushPaddingVertices(1);
}
@@ -943,14 +933,12 @@
// when we know exactly how large they need to be.
GPUResourceLimits newLimitsForFlushTimeResources{};
bool needsFlushTimeRealloc = false;
- assert(m_triangleBuffer.capacity() == m_currentResourceLimits.triangleVertexBufferSize);
- if (m_currentResourceLimits.triangleVertexBufferSize < m_maxTriangleVertexCount)
+ if (m_currentResourceLimits.triangleVertexBufferCount < m_maxTriangleVertexCount)
{
- newLimitsForFlushTimeResources.triangleVertexBufferSize = m_maxTriangleVertexCount;
+ newLimitsForFlushTimeResources.triangleVertexBufferCount = m_maxTriangleVertexCount;
needsFlushTimeRealloc = true;
}
- size_t requiredGradTextureHeight =
- m_reservedGradTextureRowsForSimpleRamps + m_complexGradients.size();
+ size_t requiredGradTextureHeight = m_reservedSimpleGradientRowCount + m_complexGradients.size();
if (m_currentResourceLimits.gradientTextureHeight < requiredGradTextureHeight)
{
newLimitsForFlushTimeResources.gradientTextureHeight = requiredGradTextureHeight;
@@ -969,11 +957,13 @@
}
if (m_maxTriangleVertexCount > 0)
{
- m_triangleBuffer.ensureMapped();
- assert(m_triangleBuffer.hasRoomFor(m_maxTriangleVertexCount));
+ assert(!m_triangleVertexData);
+ m_triangleVertexData.reset(m_impl->mapTriangleVertexBuffer(),
+ m_currentResourceLimits.triangleVertexBufferCount);
+ assert(m_triangleVertexData.hasRoomFor(m_maxTriangleVertexCount));
}
assert(m_complexGradients.size() <=
- m_currentResourceLimits.gradientTextureHeight - m_reservedGradTextureRowsForSimpleRamps);
+ m_currentResourceLimits.gradientTextureHeight - m_reservedSimpleGradientRowCount);
assert(m_tessVertexCount <=
m_currentResourceLimits.tessellationTextureHeight * kTessTextureWidth);
@@ -995,7 +985,7 @@
size_t actualVertexCount = maxVertexCount;
if (maxVertexCount > 0)
{
- actualVertexCount = draw.triangulator->polysToTriangles(&m_triangleBuffer);
+ actualVertexCount = draw.triangulator->polysToTriangles(&m_triangleVertexData);
}
assert(actualVertexCount <= maxVertexCount);
draw.baseVertexOrInstance = writtenTriangleVertexCount;
@@ -1007,21 +997,51 @@
needsClipBuffer = needsClipBuffer || draw.shaderFeatures.programFeatures.enablePathClipping;
RIVE_DEBUG_CODE(++drawIdx;)
}
- assert(drawIdx == m_drawListCount);
+ assert(drawIdx == m_drawList.count());
// Determine how much to draw.
- size_t simpleColorRampCount = m_simpleColorRampsBuffer.bytesWritten() / sizeof(TwoTexelRamp);
- size_t gradSpanCount = m_gradSpanBuffer.bytesWritten() / sizeof(GradientSpan);
- size_t tessVertexSpanCount = m_tessSpanBuffer.bytesWritten() / sizeof(TessVertexSpan);
+ size_t simpleColorRampCount = m_simpleColorRampsData.bytesWritten() / sizeof(TwoTexelRamp);
+ size_t gradSpanCount = m_gradSpanData.bytesWritten() / sizeof(GradientSpan);
+ size_t tessVertexSpanCount = m_tessSpanData.bytesWritten() / sizeof(TessVertexSpan);
size_t tessDataHeight = resource_texture_height<kTessTextureWidth>(m_tessVertexCount);
- // Upload all non-empty buffers before flushing.
- m_pathBuffer.submit();
- m_contourBuffer.submit();
- m_simpleColorRampsBuffer.submit();
- m_gradSpanBuffer.submit();
- m_tessSpanBuffer.submit();
- m_triangleBuffer.submit();
+ // Unmap all non-empty buffers before flushing.
+ if (m_pathData)
+ {
+ size_t texelsWritten = m_pathData.bytesWritten() / (sizeof(uint32_t) * 4);
+ size_t widthWritten = std::min(texelsWritten, kPathTextureWidthInTexels);
+ size_t heightWritten = resource_texture_height<kPathTextureWidthInTexels>(texelsWritten);
+ m_impl->unmapPathTexture(widthWritten, heightWritten);
+ m_pathData.reset();
+ }
+ if (m_contourData)
+ {
+ size_t texelsWritten = m_contourData.bytesWritten() / (sizeof(uint32_t) * 4);
+ size_t widthWritten = std::min(texelsWritten, kContourTextureWidthInTexels);
+ size_t heightWritten = resource_texture_height<kContourTextureWidthInTexels>(texelsWritten);
+ m_impl->unmapContourTexture(widthWritten, heightWritten);
+ m_contourData.reset();
+ }
+ if (m_simpleColorRampsData)
+ {
+ m_impl->unmapSimpleColorRampsBuffer(m_simpleColorRampsData.bytesWritten());
+ m_simpleColorRampsData.reset();
+ }
+ if (m_gradSpanData)
+ {
+ m_impl->unmapGradSpanBuffer(m_gradSpanData.bytesWritten());
+ m_gradSpanData.reset();
+ }
+ if (m_tessSpanData)
+ {
+ m_impl->unmapTessVertexSpanBuffer(m_tessSpanData.bytesWritten());
+ m_tessSpanData.reset();
+ }
+ if (m_triangleVertexData)
+ {
+ m_impl->unmapTriangleVertexBuffer(m_triangleVertexData.bytesWritten());
+ m_triangleVertexData.reset();
+ }
// Update the uniform buffer for drawing if needed.
FlushUniforms uniformData(m_complexGradients.size(),
@@ -1032,33 +1052,35 @@
m_platformFeatures);
if (!bits_equal(&m_cachedUniformData, &uniformData))
{
- m_uniformBuffer.ensureMapped();
- m_uniformBuffer.emplace_back(uniformData);
- m_uniformBuffer.submit();
+ m_impl->updateFlushUniforms(&uniformData);
m_cachedUniformData = uniformData;
}
FlushDescriptor flushDesc;
- flushDesc.flushType = flushType;
+ flushDesc.renderTarget = frameDescriptor().renderTarget.get();
flushDesc.loadAction =
m_isFirstFlushOfFrame ? frameDescriptor().loadAction : LoadAction::preserveRenderTarget;
+ flushDesc.clearColor = frameDescriptor().clearColor;
flushDesc.complexGradSpanCount = gradSpanCount;
flushDesc.tessVertexSpanCount = tessVertexSpanCount;
flushDesc.simpleGradTexelsWidth = std::min(simpleColorRampCount * 2, kGradTextureWidth);
flushDesc.simpleGradTexelsHeight =
resource_texture_height<kGradTextureWidthInSimpleRamps>(simpleColorRampCount);
- flushDesc.complexGradRowsTop = m_reservedGradTextureRowsForSimpleRamps;
+ flushDesc.complexGradRowsTop = m_reservedSimpleGradientRowCount;
flushDesc.complexGradRowsHeight = m_complexGradients.size();
flushDesc.tessDataHeight = tessDataHeight;
flushDesc.needsClipBuffer = needsClipBuffer;
- onFlush(flushDesc);
+ flushDesc.hasTriangleVertices = m_maxTriangleVertexCount > 0;
+ flushDesc.wireframe = frameDescriptor().wireframe;
+ flushDesc.drawList = &m_drawList;
+ m_impl->flush(flushDesc);
m_currentFrameResourceUsage.maxPathID += m_currentPathID;
m_currentFrameResourceUsage.maxContourID += m_currentContourID;
m_currentFrameResourceUsage.maxSimpleGradients += m_simpleGradients.size();
m_currentFrameResourceUsage.maxComplexGradientSpans += gradSpanCount;
m_currentFrameResourceUsage.maxTessellationSpans += tessVertexSpanCount;
- m_currentFrameResourceUsage.triangleVertexBufferSize += m_maxTriangleVertexCount;
+ m_currentFrameResourceUsage.triangleVertexBufferCount += m_maxTriangleVertexCount;
m_currentFrameResourceUsage.gradientTextureHeight +=
resource_texture_height<kGradTextureWidthInSimpleRamps>(m_simpleGradients.size()) +
m_complexGradients.size();
@@ -1105,9 +1127,15 @@
m_isFirstFlushOfFrame = false;
m_drawList.reset();
- m_drawListCount = 0;
// Delete all objects that were allocted for this flush using the TrivialBlockAllocator.
m_trivialPerFlushAllocator.reset();
+
+ if (flushType == FlushType::intermediate)
+ {
+ // The frame isn't complete yet. The caller will begin preparing a new flush immediately
+ // after this method returns, so lock buffers for the next flush now.
+ m_impl->prepareToMapBuffers();
+ }
}
} // namespace rive::pls
diff --git a/renderer/pls_render_context_buffer_ring_impl.cpp b/renderer/pls_render_context_buffer_ring_impl.cpp
new file mode 100644
index 0000000..64cfee4
--- /dev/null
+++ b/renderer/pls_render_context_buffer_ring_impl.cpp
@@ -0,0 +1,92 @@
+/*
+ * Copyright 2022 Rive
+ */
+
+#include "rive/pls/pls_render_context_buffer_ring_impl.hpp"
+
+namespace rive::pls
+{
+void PLSRenderContextBufferRingImpl::resizePathTexture(size_t width, size_t height)
+{
+ m_pathBuffer = makeTexelBufferRing(TexelBufferRing::Format::rgba32ui,
+ width / kPathTexelsPerItem,
+ height,
+ kPathTexelsPerItem,
+ kPathTextureIdx,
+ TexelBufferRing::Filter::nearest);
+}
+
+void PLSRenderContextBufferRingImpl::resizeContourTexture(size_t width, size_t height)
+{
+ m_contourBuffer = makeTexelBufferRing(TexelBufferRing::Format::rgba32ui,
+ width / kContourTexelsPerItem,
+ height,
+ kContourTexelsPerItem,
+ pls::kContourTextureIdx,
+ TexelBufferRing::Filter::nearest);
+}
+
+void PLSRenderContextBufferRingImpl::resizeSimpleColorRampsBuffer(size_t sizeInBytes)
+{
+ m_simpleColorRampsBuffer =
+ makePixelUnpackBufferRing(sizeInBytes / sizeof(TwoTexelRamp), sizeof(TwoTexelRamp));
+}
+
+void PLSRenderContextBufferRingImpl::resizeGradSpanBuffer(size_t sizeInBytes)
+{
+ m_gradSpanBuffer =
+ makeVertexBufferRing(sizeInBytes / sizeof(GradientSpan), sizeof(GradientSpan));
+}
+
+void PLSRenderContextBufferRingImpl::resizeTessVertexSpanBuffer(size_t sizeInBytes)
+{
+ m_tessSpanBuffer =
+ makeVertexBufferRing(sizeInBytes / sizeof(TessVertexSpan), sizeof(TessVertexSpan));
+}
+
+void PLSRenderContextBufferRingImpl::resizeTriangleVertexBuffer(size_t sizeInBytes)
+{
+ m_triangleBuffer =
+ makeVertexBufferRing(sizeInBytes / sizeof(TriangleVertex), sizeof(TriangleVertex));
+}
+
+void PLSRenderContextBufferRingImpl::unmapPathTexture(size_t widthWritten, size_t heightWritten)
+{
+ m_pathBuffer->unmapAndSubmitBuffer(heightWritten * widthWritten * 4 * 4);
+}
+
+void PLSRenderContextBufferRingImpl::unmapContourTexture(size_t widthWritten, size_t heightWritten)
+{
+ return m_contourBuffer->unmapAndSubmitBuffer(heightWritten * widthWritten * 4 * 4);
+}
+
+void PLSRenderContextBufferRingImpl::unmapSimpleColorRampsBuffer(size_t bytesWritten)
+{
+ m_simpleColorRampsBuffer->unmapAndSubmitBuffer(bytesWritten);
+}
+
+void PLSRenderContextBufferRingImpl::unmapGradSpanBuffer(size_t bytesWritten)
+{
+ m_gradSpanBuffer->unmapAndSubmitBuffer(bytesWritten);
+}
+
+void PLSRenderContextBufferRingImpl::unmapTessVertexSpanBuffer(size_t bytesWritten)
+{
+ m_tessSpanBuffer->unmapAndSubmitBuffer(bytesWritten);
+}
+
+void PLSRenderContextBufferRingImpl::unmapTriangleVertexBuffer(size_t bytesWritten)
+{
+ m_triangleBuffer->unmapAndSubmitBuffer(bytesWritten);
+}
+
+void PLSRenderContextBufferRingImpl::updateFlushUniforms(const FlushUniforms* uniformData)
+{
+ if (m_uniformBuffer == nullptr)
+ {
+ m_uniformBuffer = makeUniformBufferRing(sizeof(FlushUniforms));
+ }
+ memcpy(m_uniformBuffer->mapBuffer(), uniformData, sizeof(FlushUniforms));
+ m_uniformBuffer->unmapAndSubmitBuffer(sizeof(FlushUniforms));
+}
+} // namespace rive::pls
