Delete the DrawParameters buffer Wrong direction. We can do better by packing the wedge size in the vertex data and using the built-in "base instance". Diffs= 80117d7b1 Delete the DrawParameters buffer (#5441) Co-authored-by: Chris Dalton <99840794+csmartdalton@users.noreply.github.com>
diff --git a/.rive_head b/.rive_head index ad87af4..0a13269 100644 --- a/.rive_head +++ b/.rive_head
@@ -1 +1 @@ -e00611f6c632a78a91baed56cfc063d4929e8b89 +80117d7b1c33b93f28d4a84cfa59b3d03115cda7
diff --git a/include/rive/pls/gl/pls_render_context_gl.hpp b/include/rive/pls/gl/pls_render_context_gl.hpp index 8905035..f91b627 100644 --- a/include/rive/pls/gl/pls_render_context_gl.hpp +++ b/include/rive/pls/gl/pls_render_context_gl.hpp
@@ -84,9 +84,6 @@ class DrawProgram { public: - constexpr static int kUniformsBlockIdx = 0; - constexpr static int kDrawParametersBlockIdx = 1; - DrawProgram(const DrawProgram&) = delete; DrawProgram& operator=(const DrawProgram&) = delete; DrawProgram(PLSRenderContextGL* context, const ShaderFeatures& shaderFeatures);
diff --git a/include/rive/pls/pls.hpp b/include/rive/pls/pls.hpp index 9bcbfd9..d0114d7 100644 --- a/include/rive/pls/pls.hpp +++ b/include/rive/pls/pls.hpp
@@ -126,9 +126,9 @@ constexpr static uint32_t kRadialGradient = 1u << 29; // Says which part of the wedge instance a vertex belongs to. -constexpr static float kStrokeVertex = 0; -constexpr static float kFanVertex = 1; -constexpr static float kFanMidpointVertex = 2; +constexpr static int32_t kStrokeVertex = 0; +constexpr static int32_t kFanVertex = 1; +constexpr static int32_t kFanMidpointVertex = 2; } // namespace flags // Index of each pixel local storage plane. @@ -187,19 +187,6 @@ }; static_assert(sizeof(DrawUniforms) == 8 * sizeof(uint32_t)); -// Per-draw uniforms that specify how to draw which tessellation vertices. -struct DrawParameters -{ - DrawParameters(int32_t wedgeSize_, int32_t baseTessellationVertex_) : - wedgeSize(wedgeSize_), baseTessellationVertex(baseTessellationVertex_) - {} - int32_t wedgeSize; - int32_t baseTessellationVertex; - uint32_t pad0 = 0; - uint32_t pad1 = 0; -}; -static_assert(sizeof(DrawParameters) == 4 * sizeof(int32_t)); - // Gradient color stops are implemented as a horizontal span of pixels in a global gradient texture. // They are rendered by "GradientSpan" instances. struct GradientSpan @@ -375,7 +362,9 @@ float outset; // Outset from the tessellated position, in the direction of the normal. float fillCoverage; // 0..1 for the stroke. 1 all around for the triangles. // (Coverage will be negated later for counterclockwise triangles.) - float vertexType; // flags::kStrokeVertex, flags::kFanVertex, or flags::kFanMidpointVertex. + int32_t params; // "(wedgeSize << 2) | [flags::kStrokeVertex, + // flags::kFanVertex, + // flags::kFanMidpointVertex]" }; constexpr static int kWedgeSize = 8; // # of tessellation segments spanned by the instance.
diff --git a/include/rive/pls/pls_render_context.hpp b/include/rive/pls/pls_render_context.hpp index dddbec4..2e58ec4 100644 --- a/include/rive/pls/pls_render_context.hpp +++ b/include/rive/pls/pls_render_context.hpp
@@ -244,10 +244,6 @@ { return static_cast<const BufferRingImpl*>(m_drawUniforms.impl()); } - const BufferRingImpl* drawParametersBufferRing() - { - return static_cast<const BufferRingImpl*>(m_drawParametersBuffer.impl()); - } const TexelBufferRing* pathBufferRing() { return static_cast<const TexelBufferRing*>(m_pathBuffer.impl()); @@ -338,7 +334,6 @@ size_t maxComplexGradientSpans; size_t maxTessellationSpans; size_t maxTessellationVertices; - size_t maxDrawParameters; // "*this = max(*this, other)" void accumulateMax(const GPUResourceLimits& other) @@ -352,8 +347,7 @@ maxTessellationSpans = std::max(maxTessellationSpans, other.maxTessellationSpans); maxTessellationVertices = std::max(maxTessellationVertices, other.maxTessellationVertices); - maxDrawParameters = std::max(maxDrawParameters, other.maxDrawParameters); - static_assert(sizeof(*this) == sizeof(size_t) * 8); // Make sure we got every field. + static_assert(sizeof(*this) == sizeof(size_t) * 7); // Make sure we got every field. } // Scale each limit > threshold by a factor of "scaleFactor". @@ -378,9 +372,7 @@ if (maxTessellationVertices > threshold.maxTessellationVertices) scaled.maxTessellationVertices = static_cast<double>(maxTessellationVertices) * scaleFactor; - if (maxDrawParameters > threshold.maxDrawParameters) - scaled.maxDrawParameters = static_cast<double>(maxDrawParameters) * scaleFactor; - static_assert(sizeof(*this) == sizeof(size_t) * 8); // Make sure we got every field. + static_assert(sizeof(*this) == sizeof(size_t) * 7); // Make sure we got every field. return scaled; } @@ -431,7 +423,6 @@ BufferRing<TwoTexelRamp> m_gradTexelBuffer; // Simple gradients get written by the CPU. BufferRing<GradientSpan> m_gradSpanBuffer; // Complex gradients get rendered by the GPU. BufferRing<TessVertexSpan> m_tessSpanBuffer; - BufferRing<DrawParameters> m_drawParametersBuffer; BufferRing<ColorRampUniforms> m_colorRampUniforms; BufferRing<TessellateUniforms> m_tessellateUniforms; BufferRing<DrawUniforms> m_drawUniforms;
diff --git a/renderer/gl/pls_render_context_gl.cpp b/renderer/gl/pls_render_context_gl.cpp index 8a1c49f..fbe1aeb 100644 --- a/renderer/gl/pls_render_context_gl.cpp +++ b/renderer/gl/pls_render_context_gl.cpp
@@ -290,10 +290,7 @@ glutils::LinkProgram(m_id); glUseProgram(m_id); - glUniformBlockBinding(m_id, glGetUniformBlockIndex(m_id, GLSL_Uniforms), kUniformsBlockIdx); - glUniformBlockBinding(m_id, - glGetUniformBlockIndex(m_id, GLSL_DrawParameters), - kDrawParametersBlockIdx); + glUniformBlockBinding(m_id, glGetUniformBlockIndex(m_id, GLSL_Uniforms), 0); glUniform1i(glGetUniformLocation(m_id, GLSL_tessVertexTexture), kGLTexIdxOffset + kTessVertexTextureIdx); glUniform1i(glGetUniformLocation(m_id, GLSL_pathTexture), kGLTexIdxOffset + kPathTextureIdx); @@ -317,9 +314,7 @@ void PLSRenderContextGL::bindDrawProgram(const DrawProgram& drawProgram) { glBindVertexArray(m_drawVAO); - glBindBufferBase(GL_UNIFORM_BUFFER, - DrawProgram::kUniformsBlockIdx, - gl_buffer_id(drawUniforms())); + glBindBufferBase(GL_UNIFORM_BUFFER, 0, gl_buffer_id(drawUniforms())); glUseProgram(drawProgram.id()); } @@ -399,11 +394,6 @@ if (wedgeInstanceCount > 0) { // Draw wedges connecting all tessellated vertices. - glBindBufferRange(GL_UNIFORM_BUFFER, - DrawProgram::kDrawParametersBlockIdx, - gl_buffer_id(drawParametersBufferRing()), - 0 * sizeof(DrawUniforms), - sizeof(DrawUniforms)); glDrawElementsInstanced(GL_TRIANGLES, kOuterStrokeWedgeIndexCount, GL_UNSIGNED_SHORT,
diff --git a/renderer/metal/pls_render_context_metal.mm b/renderer/metal/pls_render_context_metal.mm index e23091f..6855622 100644 --- a/renderer/metal/pls_render_context_metal.mm +++ b/renderer/metal/pls_render_context_metal.mm
@@ -411,8 +411,7 @@ 1.0}]; [encoder setRenderPipelineState:drawPipeline.pipelineState(renderTarget->pixelFormat())]; [encoder setVertexBuffer:mtl_buffer(drawUniforms()) offset:0 atIndex:0]; - [encoder setVertexBuffer:mtl_buffer(drawParametersBufferRing()) offset:0 atIndex:1]; - [encoder setVertexBuffer:m_pathWedgeVertexBuffer offset:0 atIndex:2]; + [encoder setVertexBuffer:m_pathWedgeVertexBuffer offset:0 atIndex:1]; [encoder setVertexTexture:m_tessVertexTexture atIndex:kTessVertexTextureIdx]; [encoder setVertexTexture:mtl_texture(pathBufferRing()) atIndex:kPathTextureIdx]; [encoder setVertexTexture:mtl_texture(contourBufferRing()) atIndex:kContourTextureIdx];
diff --git a/renderer/pls.cpp b/renderer/pls.cpp index 8faa2bd..798d23b 100644 --- a/renderer/pls.cpp +++ b/renderer/pls.cpp
@@ -6,6 +6,11 @@ namespace rive::pls { +constexpr static int32_t pack_params(int32_t wedgeSize, int32_t vertexType) +{ + return (wedgeSize << 2) | vertexType; +} + void GenerateWedgeTriangles(WedgeVertex vertices[], uint16_t indices[], WedgeType wedgeType) { // AA border vertices. @@ -14,14 +19,29 @@ { if (wedgeType == WedgeType::centerStroke) { - vertices[vertexCount++] = {static_cast<float>(i), 1, 0, flags::kStrokeVertex}; - vertices[vertexCount++] = {static_cast<float>(i), 0, .5f, flags::kStrokeVertex}; - vertices[vertexCount++] = {static_cast<float>(i), -1, 0, flags::kStrokeVertex}; + vertices[vertexCount++] = {static_cast<float>(i), + 1, + 0, + pack_params(kWedgeSize, flags::kStrokeVertex)}; + vertices[vertexCount++] = {static_cast<float>(i), + 0, + .5f, + pack_params(kWedgeSize, flags::kStrokeVertex)}; + vertices[vertexCount++] = {static_cast<float>(i), + -1, + 0, + pack_params(kWedgeSize, flags::kStrokeVertex)}; } else { - vertices[vertexCount++] = {static_cast<float>(i), -1, 1, flags::kStrokeVertex}; - vertices[vertexCount++] = {static_cast<float>(i), 1, 0, flags::kStrokeVertex}; + vertices[vertexCount++] = {static_cast<float>(i), + -1, + 1, + pack_params(kWedgeSize, flags::kStrokeVertex)}; + vertices[vertexCount++] = {static_cast<float>(i), + 1, + 0, + pack_params(kWedgeSize, flags::kStrokeVertex)}; } } @@ -32,12 +52,12 @@ vertices[vertexCount++] = {static_cast<float>(i), wedgeType == WedgeType::centerStroke ? 0.f : -1.f, 1, - flags::kFanVertex}; + pack_params(kWedgeSize, flags::kFanVertex)}; } // Midpoint vertex. size_t midpointIdx = vertexCount; - vertices[vertexCount++] = {0, 0, 1, flags::kFanMidpointVertex}; + vertices[vertexCount++] = {0, 0, 1, pack_params(kWedgeSize, flags::kFanMidpointVertex)}; assert(vertexCount == (wedgeType == WedgeType::centerStroke ? kCenterStrokeWedgeVertexCount : kOuterStrokeWedgeVertexCount));
diff --git a/renderer/pls_render_context.cpp b/renderer/pls_render_context.cpp index 18557ef..373ddd5 100644 --- a/renderer/pls_render_context.cpp +++ b/renderer/pls_render_context.cpp
@@ -355,24 +355,6 @@ } COUNT_RESOURCE_SIZE(targetTessTextureHeight * kTessTextureWidth * 4 * sizeof(uint32_t)); - // Draw parameters uniform buffer ring. - constexpr size_t kMinDrawParameters = 2048; // 96 KiB - size_t maxDrawParameters = m_maxPathID; // Can't have more draws than paths. - size_t targetDrawParameters = targets.maxDrawParameters; - targetDrawParameters = std::clamp(targetDrawParameters, kMinDrawParameters, maxDrawParameters); - if (shouldReallocate(targetDrawParameters, m_currentResourceLimits.maxDrawParameters)) - { - assert(!m_drawParametersBuffer.mapped()); - m_drawParametersBuffer.reset( - makeUniformBufferRing(targetDrawParameters, sizeof(DrawParameters))); - LOG_CHANGED_SIZE("draw uniform buffer count", - m_currentResourceLimits.maxDrawParameters, - targetDrawParameters, - m_drawParametersBuffer.totalSizeInBytes()); - m_currentResourceLimits.maxDrawParameters = targetDrawParameters; - } - COUNT_RESOURCE_SIZE(m_drawParametersBuffer.totalSizeInBytes()); - // One-time allocation of the gradient uniform buffer ring. if (m_colorRampUniforms.impl() == nullptr) { @@ -778,11 +760,6 @@ this->pushCubic(emptyLine, Vec2D{}, 0, 1, 1, 1); } - // For now, there is only one draw per flush. - assert(m_drawParametersBuffer.empty()); - m_drawParametersBuffer.ensureMapped(); - m_drawParametersBuffer.emplace_back(kWedgeSize, 0); - // Determine how much to draw. size_t gradSpanCount = m_gradSpanBuffer.bytesWritten() / sizeof(GradientSpan); size_t tessVertexSpanCount = m_tessSpanBuffer.bytesWritten() / sizeof(TessVertexSpan); @@ -792,7 +769,6 @@ // PLSRenderer should have padded the vertex count of each contour to a multiple of kWedgeSize. assert(tessVertexCountToDraw % kWedgeSize == 0); size_t wedgeInstanceCount = tessVertexCountToDraw / kWedgeSize; - size_t drawParametersCount = m_drawParametersBuffer.bytesWritten() / sizeof(DrawParameters); // Upload all non-empty buffers before flushing. m_pathBuffer.submit(); @@ -800,7 +776,6 @@ m_gradTexelBuffer.submit(); m_gradSpanBuffer.submit(); m_tessSpanBuffer.submit(); - m_drawParametersBuffer.submit(); if (gradSpanCount) { @@ -854,9 +829,8 @@ m_currentFrameResourceUsage.maxComplexGradientSpans += gradSpanCount; m_currentFrameResourceUsage.maxTessellationSpans += tessVertexSpanCount; m_currentFrameResourceUsage.maxTessellationVertices += m_tessVertexCount; - m_currentFrameResourceUsage.maxDrawParameters += drawParametersCount; static_assert(sizeof(m_currentFrameResourceUsage) == - sizeof(size_t) * 8); // Make sure we got every field. + sizeof(size_t) * 7); // Make sure we got every field. m_lastGeneratedClipID = 0; m_clipContentID = 0;
diff --git a/renderer/shaders/draw.glsl b/renderer/shaders/draw.glsl index ef7b421..65d6f2d 100644 --- a/renderer/shaders/draw.glsl +++ b/renderer/shaders/draw.glsl
@@ -4,9 +4,9 @@ #define AA_RADIUS .5 -#define STROKE_VERTEX .0 -#define FAN_VERTEX 1. -#define FAN_MIDPOINT_VERTEX 2. +#define STROKE_VERTEX 0 +#define FAN_VERTEX 1 +#define FAN_MIDPOINT_VERTEX 2 #define FIRST_VERTEX_OF_CONTOUR_FLAG (1u << 31) #define JOIN_TYPE_MASK (3u << 29) @@ -62,13 +62,6 @@ uint pad2; UNIFORM_BLOCK_END(uniforms) -UNIFORM_BLOCK_BEGIN(@DrawParameters) -int wedgeSize; -int baseTessellationVertex; -int pad0; -int pad1; -UNIFORM_BLOCK_END(drawParameters) - VERTEX_TEXTURE_BLOCK_BEGIN(VertexTextures) TEXTURE_RGBA32UI(0) @tessVertexTexture; TEXTURE_RGBA32UI(1) @pathTexture; @@ -100,8 +93,7 @@ uint GLSL_VERTEX_ID [[vertex_id]], uint GLSL_INSTANCE_ID [[instance_id]], constant @Uniforms& uniforms [[buffer(0)]], - constant @DrawParameters& drawParameters [[buffer(1)]], - constant Attrs* attrs [[buffer(2)]], + constant Attrs* attrs [[buffer(1)]], VertexTextures textures #endif ) @@ -111,16 +103,16 @@ int localVertexID = int(wedgeVertexData.x); float outset = wedgeVertexData.y; float fillCoverage = wedgeVertexData.z; - float vertexType = wedgeVertexData.w; + int wedgeSize = floatBitsToInt(wedgeVertexData.w) >> 2; + int vertexType = floatBitsToInt(wedgeVertexData.w) & 3; // Fetch the tessellation vertex we belong to. - int vertexIdx = GLSL_INSTANCE_ID * drawParameters.wedgeSize + - drawParameters.baseTessellationVertex + localVertexID; + int vertexIdx = GLSL_INSTANCE_ID * wedgeSize + localVertexID; int2 tessVertexTexelCoord = tessTexelCoord(vertexIdx); uint4 tessVertexData = TEXEL_FETCH(textures, @tessVertexTexture, tessVertexTexelCoord, 0); uint contourIDWithFlags = tessVertexData.w; - bool isClosingVertexOfContour = localVertexID == drawParameters.wedgeSize && - (contourIDWithFlags & FIRST_VERTEX_OF_CONTOUR_FLAG) != 0u; + bool isClosingVertexOfContour = + localVertexID == wedgeSize && (contourIDWithFlags & FIRST_VERTEX_OF_CONTOUR_FLAG) != 0u; if (isClosingVertexOfContour) { // The right vertex crossed over into a new contour. Fetch the previous vertex, which will
diff --git a/renderer/shaders/glsl.glsl b/renderer/shaders/glsl.glsl index f8a9b5b..7c37e07 100644 --- a/renderer/shaders/glsl.glsl +++ b/renderer/shaders/glsl.glsl
@@ -57,7 +57,7 @@ #define GLSL_INSTANCE_ID gl_InstanceID #define UNIFORM_BLOCK_BEGIN(N) \ - uniform N \ + layout(std140) uniform N \ { // clang-format barrier... Otherwise it tries to merge this #define into the above macro... #define UNIFORM_BLOCK_END(N) \
diff --git a/renderer/shaders/metal.glsl b/renderer/shaders/metal.glsl index b74098c..1c9cd40 100644 --- a/renderer/shaders/metal.glsl +++ b/renderer/shaders/metal.glsl
@@ -170,8 +170,15 @@ return as_type<vec<uint, N>>(x); } +template <int N> inline vec<int, N> floatBitsToInt(vec<float, N> x) +{ + return as_type<vec<int, N>>(x); +} + inline uint floatBitsToUint(float x) { return as_type<uint>(x); } +inline int floatBitsToInt(float x) { return as_type<int>(x); } + template <int N> inline vec<float, N> uintBitsToFloat(vec<uint, N> x) { return as_type<vec<float, N>>(x);