fix(2d): allocate Graphics GPU buffers on demand (#373)

Every Graphics sub-model pre-allocated a 65536-vertex / 131072-index buffer, which is about 2.25 MiB with the 32-byte graphics vertex, while a rect or ellipse mask only needs a few hundred bytes. The cost accumulates with every mask that draws its own geometry.

Allocate the buffers from the chunk data when the sub-model is created, grow them by powers of two when the geometry outgrows them, and never shrink, so a dynamic graphic no longer re-creates its GPU buffer every frame.

Keep the ceiling at the uint16 addressable limit of 65536 vertices. The assembler does not split a single fill()/stroke() batch, so a batch of exactly 65536 vertices has to fit; capping the buffer at 65535 would upload 32 bytes past its end.

UIModelProxy used to resize the buffers to the exact data size on every upload, which re-created them whenever the geometry changed, and on Metal/Vulkan the old buffer stays alive until the GPU is done with it. It now follows the same grow-only policy and passes the valid size to update() explicitly.

Refs: cocos/cocos4#371

Co-authored-by: Engineer <engineer@cocos.com>
This commit is contained in:
Tianze-Chen
2026-10-23 11:23:29 +08:00
committed by GitHub
parent f570c1f02d
commit a803406ef1
4 changed files with 122 additions and 24 deletions
+32
View File
@@ -0,0 +1,32 @@
/*
Copyright (c) 2017-2023 Xiamen Yaji Software Co., Ltd.
http://www.cocos.com
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do so,
subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
// Vertex/index capacity limits of the graphics geometry.
// Uint16 can address 65536 vertices (indices 0-65535), and a single fill()/stroke() batch is not
// split, so the buffers have to cover this count.
export const MAX_VERTEX_COUNT = 65536;
// Fill and stroke both emit at most 3 indices per vertex, see GraphicsAssembler.
export const INDICES_PER_VERTEX = 3;
export const MAX_INDEX_COUNT = MAX_VERTEX_COUNT * INDICES_PER_VERTEX;
@@ -28,12 +28,10 @@ import { MeshRenderData } from '../../../renderer/render-data';
import { IBatcher } from '../../../renderer/i-batcher';
import { Graphics } from '../../../components/graphics';
import { LineCap, LineJoin, PointFlags } from '../types';
import { MAX_VERTEX_COUNT, INDICES_PER_VERTEX } from '../constants';
import { earcut as Earcut } from './earcut';
import { Impl, Point } from './impl';
const MAX_VERTEX = 65535;
const MAX_INDICES = MAX_VERTEX * 2;
const PI = Math.PI;
const min = Math.min;
const max = Math.max;
@@ -95,7 +93,7 @@ export class GraphicsAssembler implements IAssembler {
let meshBuffer = renderData;
const maxVertexCount = meshBuffer ? meshBuffer.vertexStart + vertexCount : 0;
if (maxVertexCount > MAX_VERTEX || maxVertexCount * 3 > MAX_INDICES) {
if (maxVertexCount > MAX_VERTEX_COUNT) {
++_impl.dataOffset;
if (_impl.dataOffset < renderDataList.length) {
@@ -109,7 +107,7 @@ export class GraphicsAssembler implements IAssembler {
}
if (meshBuffer && meshBuffer.vertexCount < maxVertexCount) {
meshBuffer.request(vertexCount, vertexCount * 3);
meshBuffer.request(vertexCount, vertexCount * INDICES_PER_VERTEX);
}
return renderData;
+41 -4
View File
@@ -32,6 +32,7 @@ import { Color, warnID, cclegacy } from '../../core';
import { scene } from '../../render-scene';
import type { IBatcher } from '../renderer/i-batcher';
import { LineCap, LineJoin } from '../assembler/graphics/types';
import { MAX_VERTEX_COUNT, MAX_INDEX_COUNT } from '../assembler/graphics/constants';
import { Impl } from '../assembler/graphics/webgl/impl';
import { Material, RenderingSubMesh } from '../../asset/assets';
import { Format, PrimitiveMode, Attribute, Device, BufferUsageBit, BufferInfo, MemoryUsageBit, deviceManager } from '../../gfx';
@@ -39,6 +40,8 @@ import { vfmtPosColor, getAttributeStride, getComponentPerVertex } from '../rend
import { NativeUIModelProxy } from '../renderer/native-2d';
import { RenderEntity, RenderEntityType } from '../renderer/render-entity';
import type { GraphicsAssembler } from '../assembler/graphics/webgl/graphics-assembler';
import type { MeshRenderData } from '../renderer/render-data';
import type { InputAssembler } from '../../gfx';
const attributes = vfmtPosColor.concat([
new Attribute('a_dist', Format.R32F),
@@ -48,6 +51,15 @@ const componentPerVertex = getComponentPerVertex(attributes);
const stride = getAttributeStride(attributes);
// Grow only, by powers of two, so a changing geometry does not re-create the GPU buffer every frame.
function growCapacity (needed: number, current: number, max: number): number {
let cap = Math.max(current, 1);
while (cap < needed) {
cap *= 2;
}
return Math.min(cap, max);
}
/**
* @en
* Graphics component.
@@ -635,7 +647,7 @@ export class Graphics extends UIRenderer {
/**
* @deprecated since v3.7.0, this is an engine private interface that will be removed in the future.
*/
public activeSubModel (idx: number): void {
public activeSubModel (idx: number, vertexCount = 1, indexCount = 1): void {
if (!this.model) {
warnID(4500, this.node.name);
return;
@@ -646,13 +658,13 @@ export class Graphics extends UIRenderer {
const vertexBuffer = gfxDevice.createBuffer(new BufferInfo(
BufferUsageBit.VERTEX | BufferUsageBit.TRANSFER_DST,
MemoryUsageBit.DEVICE,
65536 * stride, // Uint16 can address 65536 vertices (indices 0–65535)
growCapacity(vertexCount, 0, MAX_VERTEX_COUNT) * stride,
stride,
));
const indexBuffer = gfxDevice.createBuffer(new BufferInfo(
BufferUsageBit.INDEX | BufferUsageBit.TRANSFER_DST,
MemoryUsageBit.DEVICE,
65536 * Uint16Array.BYTES_PER_ELEMENT * 2, // Uint16 can address 65536 vertices (indices 0–65535)
growCapacity(indexCount, 0, MAX_INDEX_COUNT) * Uint16Array.BYTES_PER_ELEMENT,
Uint16Array.BYTES_PER_ELEMENT,
));
@@ -683,6 +695,9 @@ export class Graphics extends UIRenderer {
continue;
}
// Buffer.update() does not grow the buffer on WebGL, reserve the capacity first.
this._ensureCapacity(renderData, ia);
const vb = new Float32Array(renderData.vData.buffer, 0, renderData.vertexStart * componentPerVertex);
ia.vertexBuffers[0].update(vb);
ia.vertexCount = renderData.vertexStart;
@@ -696,6 +711,27 @@ export class Graphics extends UIRenderer {
this._isNeedUploadData = false;
}
/**
* Grow only, never shrink: the capacity is reused after clear().
*/
private _ensureCapacity (renderData: MeshRenderData, ia: InputAssembler): void {
const vb = ia.vertexBuffers[0];
const vbStride = vb.stride;
if (renderData.vertexStart * vbStride > vb.size) {
const count = growCapacity(renderData.vertexStart, vb.size / vbStride, MAX_VERTEX_COUNT);
vb.resize(count * vbStride);
}
const ib = ia.indexBuffer;
if (!ib) {
return;
}
if (renderData.indexStart * Uint16Array.BYTES_PER_ELEMENT > ib.size) {
const count = growCapacity(renderData.indexStart, ib.size / Uint16Array.BYTES_PER_ELEMENT, MAX_INDEX_COUNT);
ib.resize(count * Uint16Array.BYTES_PER_ELEMENT);
}
}
protected _render (render: IBatcher): void {
if (this._isNeedUploadData) {
if (this.impl) {
@@ -703,7 +739,8 @@ export class Graphics extends UIRenderer {
const len = this.model!.subModels.length;
if (renderDataList.length > len) {
for (let i = len; i < renderDataList.length; i++) {
this.activeSubModel(i);
const renderData = renderDataList[i];
this.activeSubModel(i, renderData.vertexStart, renderData.indexStart);
}
}
}
+46 -15
View File
@@ -27,6 +27,25 @@
#include "core/assets/RenderingSubMesh.h"
namespace cc {
namespace {
// GPU buffers are allocated on demand, in vertex/index counts, keep in sync with
// cocos/2d/assembler/graphics/constants.ts. Grow only: doResize re-creates the GPU buffer.
constexpr uint32_t MAX_VERTEX_COUNT = 65536;
constexpr uint32_t INDICES_PER_VERTEX = 3;
constexpr uint32_t MAX_INDEX_COUNT = MAX_VERTEX_COUNT * INDICES_PER_VERTEX;
inline uint32_t growCapacity(uint32_t needed, uint32_t current, uint32_t maxCap) {
uint32_t cap = current > 1U ? current : 1U;
while (cap < needed) {
cap *= 2;
}
return cap < maxCap ? cap : maxCap;
}
} // namespace
UIModelProxy::UIModelProxy() {
_device = Root::getInstance()->getDevice();
}
@@ -55,16 +74,20 @@ void UIModelProxy::activeSubModels() {
return;
}
// Allocate exactly for the data of this chunk, rounded up to a power of two.
const uint32_t vertexCapacity = growCapacity(drawInfo->getVertexOffset(), 0, MAX_VERTEX_COUNT);
const uint32_t indexCapacity = growCapacity(drawInfo->getIndexOffset(), 0, MAX_INDEX_COUNT);
auto* vertexBuffer = _device->createBuffer({
gfx::BufferUsageBit::VERTEX | gfx::BufferUsageBit::TRANSFER_DST,
gfx::MemoryUsageBit::DEVICE,
65536 * _stride, // Uint16 can address 65536 vertices (indices 0–65535)
vertexCapacity * _stride,
_stride,
});
auto* indexBuffer = _device->createBuffer({
gfx::BufferUsageBit::INDEX | gfx::BufferUsageBit::TRANSFER_DST,
gfx::MemoryUsageBit::DEVICE,
65536 * sizeof(uint16_t) * 2, // Uint16 can address 65536 vertices (indices 0–65535)
static_cast<uint32_t>(indexCapacity * sizeof(uint16_t)),
sizeof(uint16_t),
});
gfx::BufferList vbReference;
@@ -87,24 +110,32 @@ void UIModelProxy::uploadData() {
for (size_t i = 0; i < drawInfos.size(); i++) {
auto* drawInfo = drawInfos[i];
auto* ia = subModelList.at(i)->getInputAssembler();
if (drawInfo->getVertexOffset() <= 0 || drawInfo->getIndexOffset() <= 0) continue;
const uint32_t vertexCount = drawInfo->getVertexOffset();
const uint32_t indexCount = drawInfo->getIndexOffset();
if (vertexCount == 0 || indexCount == 0) continue;
gfx::BufferList vBuffers = ia->getVertexBuffers();
if (!vBuffers.empty()) {
auto size = drawInfo->getVertexOffset() * _stride;
// if (size > vBuffers[0]->getSize()) {
vBuffers[0]->resize(size);
// }
vBuffers[0]->update(drawInfo->getVDataBuffer()); // vdata
gfx::Buffer* vBuffer = vBuffers[0];
const uint32_t neededVBytes = vertexCount * _stride;
if (neededVBytes > vBuffer->getSize()) {
const uint32_t capacity = growCapacity(vertexCount, vBuffer->getSize() / _stride, MAX_VERTEX_COUNT);
vBuffer->resize(capacity * _stride);
}
// pass the valid size explicitly, update(ptr) uploads the whole capacity
vBuffer->update(drawInfo->getVDataBuffer(), neededVBytes); // vdata
}
ia->setVertexCount(drawInfo->getVertexOffset()); // count
ia->setVertexCount(vertexCount); // count
gfx::Buffer* iBuffer = ia->getIndexBuffer();
auto size = drawInfo->getIndexOffset() * 2;
// if (size > iBuffer->getSize()) {
iBuffer->resize(size);
// }
iBuffer->update(drawInfo->getIDataBuffer()); // idata
ia->setIndexCount(drawInfo->getIndexOffset()); // indexCount
const auto neededIBytes = static_cast<uint32_t>(indexCount * sizeof(uint16_t));
if (neededIBytes > iBuffer->getSize()) {
const uint32_t capacity = growCapacity(indexCount, static_cast<uint32_t>(iBuffer->getSize() / sizeof(uint16_t)),
MAX_INDEX_COUNT);
iBuffer->resize(static_cast<uint32_t>(capacity * sizeof(uint16_t)));
}
iBuffer->update(drawInfo->getIDataBuffer(), neededIBytes); // idata
ia->setIndexCount(indexCount); // indexCount
// drawInfo->setModel(_model); // hack, render by model
}