[TextureMapper] Polygon clipping performance is extremely slow

https://bugs.webkit.org/show_bug.cgi?id=284027

Reviewed by Fujii Hironori.

Rendering complex preserve-3D scenes might involve a lot of layer splitting.
These splits are handled using polygon clipping, but the current implementation
is inefficient. Each clip operation clears the full stencil buffer and masks
the clipped part using separate vertex buffer objects that are allocated on
demand. This places significant stress on the GPU and on hardware like rpi3 it
completely chokes the rendering pipeline.

To address this issue, polygon clip vertices for preserve-3d scenes should be
loaded to the GPU only once, leveraging cached VBOs. Additionally, stencil
buffer clearing should be optimized using scissors to restrict stencil clears to
relevant areas, avoiding full-buffer operations.

* Source/WebCore/platform/TextureMapper.cmake:
* Source/WebCore/platform/graphics/texmap/ClipPath.cpp: Added.
(WebCore::ClipPath::ClipPath):
(WebCore::ClipPath::data const):
* Source/WebCore/platform/graphics/texmap/ClipPath.h: Added.
* Source/WebCore/platform/graphics/texmap/TextureMapper.cpp:
(WebCore::nextPowerOf2):
(WebCore::TextureMapperGLData::initializeStencil):
(WebCore::TextureMapperGLData::getBufferFromPool):
(WebCore::TextureMapper::beginClip):
(WebCore::TextureMapper::updateProjectionMatrix):
(WebCore::TextureMapper::acquireBufferFromPool):
* Source/WebCore/platform/graphics/texmap/TextureMapper.h:
* Source/WebCore/platform/graphics/texmap/TextureMapperGPUBuffer.cpp: Added.
(WebCore::TextureMapperGPUBuffer::TextureMapperGPUBuffer):
(WebCore::TextureMapperGPUBuffer::~TextureMapperGPUBuffer):
(WebCore::TextureMapperGPUBuffer::updateData):
* Source/WebCore/platform/graphics/texmap/TextureMapperGPUBuffer.h: Added.
* Source/WebCore/platform/graphics/texmap/TextureMapperLayer.cpp:
(WebCore::TextureMapperLayer::paintWith3DRenderingContext):
* Source/WebCore/platform/graphics/texmap/TextureMapperLayer3DRenderingContext.cpp:
(WebCore::TextureMapperLayer3DRenderingContext::paint):
(WebCore::TextureMapperLayer3DRenderingContext::traverseTree):
(WebCore::TextureMapperLayer3DRenderingContext::traverseTreeAndPaint): Deleted.
* Source/WebCore/platform/graphics/texmap/TextureMapperLayer3DRenderingContext.h:

Canonical link: https://commits.webkit.org/287519@main

Author: zhani

Source/WebCore/platform/TextureMapper.cmake

@@ -5,6 +5,7 @@ list(APPEND WebCore_PRIVATE_INCLUDE_DIRECTORIES
 list(APPEND WebCore_SOURCES
     platform/graphics/texmap/BitmapTexture.cpp
     platform/graphics/texmap/BitmapTexturePool.cpp
+    platform/graphics/texmap/ClipPath.cpp
     platform/graphics/texmap/ClipStack.cpp
     platform/graphics/texmap/FloatPlane3D.cpp
     platform/graphics/texmap/FloatPolygon3D.cpp
@@ -14,6 +15,7 @@ list(APPEND WebCore_SOURCES
     platform/graphics/texmap/TextureMapperBackingStore.cpp
     platform/graphics/texmap/TextureMapperFPSCounter.cpp
     platform/graphics/texmap/TextureMapperGCGLPlatformLayer.cpp
+    platform/graphics/texmap/TextureMapperGPUBuffer.cpp
     platform/graphics/texmap/TextureMapperLayer.cpp
     platform/graphics/texmap/TextureMapperLayer3DRenderingContext.cpp
     platform/graphics/texmap/TextureMapperPlatformLayer.cpp
@@ -23,6 +25,7 @@ list(APPEND WebCore_SOURCES
 list(APPEND WebCore_PRIVATE_FRAMEWORK_HEADERS
     platform/graphics/texmap/BitmapTexture.h
     platform/graphics/texmap/BitmapTexturePool.h
+    platform/graphics/texmap/ClipPath.h
     platform/graphics/texmap/ClipStack.h
     platform/graphics/texmap/FloatPlane3D.h
     platform/graphics/texmap/FloatPolygon3D.h
@@ -35,6 +38,7 @@ list(APPEND WebCore_PRIVATE_FRAMEWORK_HEADERS
     platform/graphics/texmap/TextureMapperFlags.h
     platform/graphics/texmap/TextureMapperFPSCounter.h
     platform/graphics/texmap/TextureMapperGLHeaders.h
+    platform/graphics/texmap/TextureMapperGPUBuffer.h
     platform/graphics/texmap/TextureMapperLayer.h
     platform/graphics/texmap/TextureMapperLayer3DRenderingContext.h
     platform/graphics/texmap/TextureMapperPlatformLayer.h

Source/WebCore/platform/graphics/texmap/ClipPath.cpp

@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2024 Jani Hautakangas <[email protected]>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above
+ *    copyright notice, this list of conditions and the following
+ *    disclaimer in the documentation and/or other materials provided
+ *    with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "ClipPath.h"
+
+#include <wtf/TZoneMallocInlines.h>
+
+namespace WebCore {
+
+WTF_MAKE_TZONE_ALLOCATED_IMPL(ClipPath);
+
+ClipPath::ClipPath(Vector<FloatPoint>&& vertices, unsigned bufferID, unsigned bufferOffsetInBytes)
+    : m_vertices(WTFMove(vertices))
+    , m_bufferID(bufferID)
+    , m_bufferOffsetInBytes(bufferOffsetInBytes)
+{
+    unsigned vertexCount = numberOfVertices();
+    if (vertexCount) {
+        m_bounds.setLocation(m_vertices.at(0));
+        for (size_t i = 1; i < vertexCount; i++)
+            m_bounds.extend(m_vertices.at(i));
+    }
+}
+
+const void* ClipPath::bufferDataOffsetAsPtr() const
+{
+    if (m_bufferID)
+        return reinterpret_cast<const void*>(m_bufferOffsetInBytes);
+
+    return nullptr;
+}
+
+} // namespace WebCore

Source/WebCore/platform/graphics/texmap/ClipPath.h

@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2024 Jani Hautakangas <[email protected]>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above
+ *    copyright notice, this list of conditions and the following
+ *    disclaimer in the documentation and/or other materials provided
+ *    with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include "FloatPoint.h"
+#include "FloatRect.h"
+#include <wtf/TZoneMalloc.h>
+#include <wtf/Vector.h>
+
+namespace WebCore {
+
+class ClipPath final {
+    WTF_MAKE_TZONE_ALLOCATED(ClipPath);
+public:
+    ClipPath(Vector<FloatPoint>&& vertices, unsigned bufferID, unsigned bufferOffsetInBytes);
+
+    bool isEmpty() const { return m_vertices.isEmpty(); }
+    unsigned bufferID() const { return m_bufferID; }
+    const void* bufferDataOffsetAsPtr() const;
+    unsigned numberOfVertices() const { return m_vertices.size(); }
+
+    FloatRect bounds() const { return m_bounds; }
+
+private:
+
+    const Vector<FloatPoint> m_vertices;
+    unsigned m_bufferID;
+    unsigned m_bufferOffsetInBytes;
+
+    FloatRect m_bounds;
+};
+
+} // namespace WebCore

Source/WebCore/platform/graphics/texmap/TextureMapper.cpp

@@ -25,6 +25,7 @@
 #if USE(TEXTURE_MAPPER)
 
 #include "BitmapTexture.h"
+#include "ClipPath.h"
 #include "FilterOperations.h"
 #include "FloatPolygon.h"
 #include "FloatQuad.h"
@@ -54,6 +55,15 @@ namespace WebCore {
 
 WTF_MAKE_TZONE_ALLOCATED_IMPL(TextureMapper);
 
+static size_t nextPowerOf2(size_t n)
+{
+    if (!n)
+        return 1;
+
+    const int totalBits = static_cast<int>(sizeof(size_t) * CHAR_BIT);
+    return static_cast<size_t>(1) << (totalBits - std::countl_zero(n - 1));
+}
+
 class TextureMapperGLData {
     WTF_MAKE_TZONE_ALLOCATED_INLINE(TextureMapperGLData);
 public:
@@ -63,6 +73,7 @@ class TextureMapperGLData {
     void initializeStencil();
     GLuint getStaticVBO(GLenum target, GLsizeiptr, const void* data);
     Ref<TextureMapperShaderProgram> getShaderProgram(TextureMapperShaderProgram::Options);
+    Ref<TextureMapperGPUBuffer> getBufferFromPool(size_t, TextureMapperGPUBuffer::Type);
 
     TransformationMatrix projectionMatrix;
     TextureMapper::FlipY flipY { TextureMapper::FlipY::No };
@@ -119,6 +130,7 @@ class TextureMapperGLData {
 
     Ref<SharedGLData> m_sharedGLData;
     UncheckedKeyHashMap<const void*, GLuint> m_vbos;
+    UncheckedKeyHashMap<uint64_t, Vector<Ref<TextureMapperGPUBuffer>>> m_buffers;
 };
 
 TextureMapperGLData::TextureMapperGLData(void* platformContext)
@@ -130,6 +142,9 @@ TextureMapperGLData::~TextureMapperGLData()
 {
     for (auto& entry : m_vbos)
         glDeleteBuffers(1, &entry.value);
+
+    for (auto& entry : m_buffers)
+        entry.value.clear();
 }
 
 void TextureMapperGLData::initializeStencil()
@@ -141,7 +156,6 @@ void TextureMapperGLData::initializeStencil()
 
     if (didModifyStencil)
         return;
-
     glClearStencil(0);
     glClear(GL_STENCIL_BUFFER_BIT);
     didModifyStencil = true;
@@ -169,6 +183,29 @@ Ref<TextureMapperShaderProgram> TextureMapperGLData::getShaderProgram(TextureMap
     return *addResult.iterator->value;
 }
 
+Ref<TextureMapperGPUBuffer> TextureMapperGLData::getBufferFromPool(size_t size, TextureMapperGPUBuffer::Type type)
+{
+    if (!size) {
+        // Use static zero buffer
+        static auto zeroBuffer = TextureMapperGPUBuffer::create(size, type, TextureMapperGPUBuffer::Usage::Dynamic);
+        return zeroBuffer;
+    }
+
+    RELEASE_ASSERT(size < std::numeric_limits<uint32_t>::max());
+    uint64_t key = (static_cast<uint64_t>(type) << 32) | static_cast<uint32_t>(size);
+    auto& buffers = m_buffers.ensure(key, [] {
+        return Vector<Ref<TextureMapperGPUBuffer>> { };
+    }).iterator->value;
+
+    for (auto& buffer : buffers) {
+        if (buffer->refCount() == 1)
+            return buffer;
+    }
+
+    buffers.append(TextureMapperGPUBuffer::create(size, type, TextureMapperGPUBuffer::Usage::Dynamic));
+    return buffers.last();
+}
+
 std::unique_ptr<TextureMapper> TextureMapper::create()
 {
     return makeUnique<TextureMapper>();
@@ -1319,7 +1356,7 @@ void TextureMapper::beginClip(const TransformationMatrix& modelViewMatrix, const
     clipStack().applyIfNeeded();
 }
 
-void TextureMapper::beginClip(const TransformationMatrix& modelViewMatrix, const FloatPolygon& polygon)
+void TextureMapper::beginClip(const TransformationMatrix& modelViewMatrix, const ClipPath& clipPath)
 {
     clipStack().push();
     data().initializeStencil();
@@ -1329,14 +1366,14 @@ void TextureMapper::beginClip(const TransformationMatrix& modelViewMatrix, const
     glUseProgram(program->programID());
     glEnableVertexAttribArray(program->vertexLocation());
 
-    unsigned numberOfVertices = polygon.numberOfVertices();
-    Vector<GLfloat> polygonVertices;
-    polygonVertices.reserveCapacity(numberOfVertices * 2);
-    for (unsigned i = 0; i < numberOfVertices; i++) {
-        auto v = polygon.vertexAt(i);
-        polygonVertices.append(v.x());
-        polygonVertices.append(v.y());
-    }
+    // Compute the scissor rectangle from the clip path bounding box.
+    IntRect scissorRect = modelViewMatrix.mapQuad(clipPath.bounds()).enclosingBoundingBox();
+    IntRect viewport(data().viewport[0], data().viewport[1], data().viewport[2], data().viewport[3]);
+    scissorRect.intersect(viewport);
+
+    // Set up the scissor rectangle to limit stencil operations to the clip bounds.
+    glScissor(scissorRect.x(), (data().flipY == FlipY::Yes) ? scissorRect.y() : viewport.height() - scissorRect.maxY(),
+        scissorRect.width(), scissorRect.height());
 
     int stencilIndex = clipStack().getStencilIndex();
 
@@ -1348,9 +1385,9 @@ void TextureMapper::beginClip(const TransformationMatrix& modelViewMatrix, const
     // Operate only on the stencilIndex and above.
     glStencilMask(0xff & ~(stencilIndex - 1));
 
-    // First clear the entire buffer at the current index.
+    // Clear the stencil buffer at the current index.
     static const TransformationMatrix fullProjectionMatrix = TransformationMatrix::rectToRect(FloatRect(0, 0, 1, 1), FloatRect(-1, -1, 2, 2));
-    const GLfloat unitRect[] = { 0, 0, 1, 0, 1, 1, 0, 1 };
+    static const GLfloat unitRect[] = { 0, 0, 1, 0, 1, 1, 0, 1 };
     GLuint vbo = data().getStaticVBO(GL_ARRAY_BUFFER, sizeof(GLfloat) * 8, unitRect);
     glBindBuffer(GL_ARRAY_BUFFER, vbo);
     glVertexAttribPointer(program->vertexLocation(), 2, GL_FLOAT, false, 0, 0);
@@ -1360,22 +1397,21 @@ void TextureMapper::beginClip(const TransformationMatrix& modelViewMatrix, const
     glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 
     // Now apply the current index to the new polygon.
-    GLuint polygonVBO;
-    glGenBuffers(1, &polygonVBO);
-    glBindBuffer(GL_ARRAY_BUFFER, polygonVBO);
-    glBufferData(GL_ARRAY_BUFFER, polygonVertices.size() * sizeof(GLfloat), polygonVertices.data(), GL_STATIC_DRAW);
-    glVertexAttribPointer(program->vertexLocation(), 2, GL_FLOAT, false, 0, 0);
-    glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
+    glBindBuffer(GL_ARRAY_BUFFER, clipPath.bufferID());
+    glVertexAttribPointer(program->vertexLocation(), 2, GL_FLOAT, false, 0, clipPath.bufferDataOffsetAsPtr());
     program->setMatrix(program->projectionMatrixLocation(), data().projectionMatrix);
     program->setMatrix(program->modelViewMatrixLocation(), modelViewMatrix);
-    glDrawArrays(GL_TRIANGLE_FAN, 0, polygonVertices.size() / 2);
-    glDeleteBuffers(1, &polygonVBO);
+    glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
+    glDrawArrays(GL_TRIANGLE_FAN, 0, clipPath.numberOfVertices());
 
     // Clear the state.
     glBindBuffer(GL_ARRAY_BUFFER, 0);
     glDisableVertexAttribArray(program->vertexLocation());
     glStencilMask(0);
 
+    // Store the scissor box in the clip stack to prevent it from being reset.
+    clipStack().intersect(scissorRect);
+
     // Increase stencilIndex and apply stencil testing.
     clipStack().setStencilIndex(stencilIndex * 2);
     clipStack().applyIfNeeded();
@@ -1417,6 +1453,7 @@ void TextureMapper::updateProjectionMatrix()
         WTF_ALLOW_UNSAFE_BUFFER_USAGE_END
         flipY = data().flipY == FlipY::Yes;
     }
+
     data().projectionMatrix = createProjectionMatrix(size, flipY, data().zNear, data().zFar);
 }
 
@@ -1427,6 +1464,16 @@ void TextureMapper::drawTextureExternalOES(GLuint texture, OptionSet<TextureMapp
     drawTexturedQuadWithProgram(program.get(), { { texture, program->externalOESTextureLocation() } }, flags, targetRect, modelViewMatrix, opacity);
 }
 
+Ref<TextureMapperGPUBuffer> TextureMapper::acquireBufferFromPool(size_t size, TextureMapperGPUBuffer::Type type)
+{
+    size_t ceil = nextPowerOf2(size);
+    size_t floor = ceil >> 1; // half of ceil
+    size_t mid = floor + (floor >> 1); // (1.5 times floor)
+    size_t requestSize = (size <= mid) ? mid : ceil;
+
+    return data().getBufferFromPool(requestSize, type);
+}
+
 } // namespace WebCore
 
 #endif // USE(TEXTURE_MAPPER)

Source/WebCore/platform/graphics/texmap/TextureMapper.h

@@ -28,6 +28,7 @@
 #include "IntRect.h"
 #include "IntSize.h"
 #include "TextureMapperGLHeaders.h"
+#include "TextureMapperGPUBuffer.h"
 #include "TransformationMatrix.h"
 #include <array>
 #include <wtf/OptionSet.h>
@@ -39,10 +40,11 @@
 
 namespace WebCore {
 
+class ClipPath;
 class TextureMapperGLData;
+class TextureMapperGPUBuffer;
 class TextureMapperShaderProgram;
 class FilterOperations;
-class FloatPolygon;
 class FloatRoundedRect;
 enum class TextureMapperFlags : uint16_t;
 
@@ -78,7 +80,7 @@ class TextureMapper {
     void bindSurface(BitmapTexture* surface);
     BitmapTexture* currentSurface();
     void beginClip(const TransformationMatrix&, const FloatRoundedRect&);
-    void beginClip(const TransformationMatrix&, const FloatPolygon&);
+    void beginClip(const TransformationMatrix&, const ClipPath&);
     WEBCORE_EXPORT void beginPainting(FlipY = FlipY::No, BitmapTexture* = nullptr);
     WEBCORE_EXPORT void endPainting();
     void endClip();
@@ -98,6 +100,8 @@ class TextureMapper {
     WEBCORE_EXPORT void releaseUnusedTexturesNow();
 #endif
 
+    Ref<TextureMapperGPUBuffer> acquireBufferFromPool(size_t, TextureMapperGPUBuffer::Type);
+
 private:
     bool isInMaskMode() const { return m_isMaskMode; }
     const TransformationMatrix& patternTransform() const { return m_patternTransform; }