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