Hacktoberfest 2026: những issue maintainer đã đánh dấu cho tháng Mười, đang mở và phù hợp người mới. Xem issue Hacktoberfest

Shader.preDestroy leaks its ShaderQuad's vertex buffer and VAO on every create/destroy cycle (4.2.1)

Đang mở Phù hợp với người mới
#7,394 0 bình luận 0 reaction 0 người được giao Xem trên GitHub

Maintainer thường phản hồi trong vòng 2 ngày

@k1epg01ng129-eng đang làm issue này rồi.

Từ ngày 14/10/2026.

  • #7399 của @k1epg01ng129-eng — đang mở

Đánh giá

Độ khó
2/5
Thời gian dự kiến
1-3 giờ
Mức phù hợp với người mới
86/100
Loại issue
Lỗi
Độ rõ ràng
Đặc tả rõ ràng
Mức độ hoạt động
Sôi nổi
Công nghệ
javascript
Lĩnh vực
game-dev

Hướng nghiên cứu

Bắt đầu tại preDestroy trong mã nguồn đối tượng game Shader (src/gameobjects/Shader/Shader.js) và lần theo renderNode đến ShaderQuad, WebGLVertexBufferLayoutWrapper và ProgramManager của nó. Đọc cách WebGLRenderer đăng ký và giải phóng các wrapper (glBufferWrappers, glVAOWrappers, deleteBuffer) để phản chiếu khuôn mẫu đó cho VAO, có thể thêm một deleteVAO. Xong khi HTML probe của issue in ra 0, 0, 0, 0 cho cả hai bộ đếm, bao gồm trường hợp bị hủy trước lần vẽ đầu tiên, mà không giải phóng chương trình dùng chung hay genericQuadIndexBuffer.

Do mô hình lập chỉ mục viết ra từ nội dung của issue.

Mô tả

In WebGL mode, every Shader game object builds its own ShaderQuad render node. The node allocates a vertex buffer

(WebGLVertexBufferLayoutWrapper → renderer.createVertexBuffer, registered in renderer.glBufferWrappers).

On first draw, its ProgramManager creates a VAO per linked program

(renderer.createVAO, registered in renderer.glVAOWrappers).

Shader.preDestroy only nulls this.renderNode. Neither the vertex buffer nor the VAO is released, so both stay registered with the renderer, and their GL objects stay allocated, for the life of the game.

This adds up quickly when shaders are created and destroyed repeatedly. For example, a UI button that draws its background with a Shader and lives in an overlay that is rebuilt on every show leaks one buffer and one VAO per button per show.

Expected: after each create/draw/destroy cycle, the buffer and VAO wrapper counts return to their baseline.

Actual: both counts grow by one per cycle. A shader destroyed before its first draw still leaks its vertex buffer.

Example Test Code

Run against unpatched Phaser 4.2.1:

<!doctype html>
<html>
<body>
<script src="https://cdn.jsdelivr.net/npm/[email protected]/dist/phaser.js"></script>
<script>
const config = {
    name: 'LeakProbe',
    fragmentSource: `
        precision mediump float;
        varying vec2 outTexCoord;
        void main() { gl_FragColor = vec4(outTexCoord, 0.0, 1.0); }
    `
};

new Phaser.Game({
    type: Phaser.WEBGL,
    width: 128,
    height: 128,
    audio: { noAudio: true },
    scene: {
        create: function () {
            const renderer = this.game.renderer;
            let baseBuffers = null;
            let baseVAOs = null;
            let shader = null;
            let cycle = 0;

            // Each cycle: create a Shader, let it draw once (which creates its VAO), then destroy it.
            this.game.events.on('postrender', () => {
                if (baseBuffers === null) {
                    baseBuffers = renderer.glBufferWrappers.length;
                    baseVAOs = renderer.glVAOWrappers.length;
                } else if (shader) {
                    shader.destroy();
                    shader = null;
                    cycle++;
                    console.log(
                        `Cycle ${cycle}: retained buffers = ${renderer.glBufferWrappers.length - baseBuffers},`,
                        `retained VAOs = ${renderer.glVAOWrappers.length - baseVAOs}`
                    );
                }

                if (cycle < 4) {
                    shader = this.add.existing(new Phaser.GameObjects.Shader(this, config, 64, 64, 64, 64));
                }
            });
        }
    }
});
</script>
</body>
</html>

Expected counts: 0, 0, 0, 0 for both.
Actual counts: 1, 2, 3, 4 for both.

Additional Information

Releasing the render node's own resources in Shader.preDestroy eliminates the growth:

preDestroy: function ()
{
    var renderNode = this.renderNode;

    if (renderNode)
    {
        //  Release this Shader's own GL resources. The program and the
        //  index buffer are shared, so they stay.
        var renderer = renderNode.renderer;
        var programs = renderNode.programManager.programs;

        for (var key in programs)
        {
            var vao = programs[key].vao;
            var vaoIndex = renderer.glVAOWrappers.indexOf(vao);

            if (vaoIndex !== -1)
            {
                renderer.glVAOWrappers.splice(vaoIndex, 1);
            }

            vao.destroy();
        }

        renderer.deleteBuffer(renderNode.vertexBufferLayout.buffer);
    }

    this.renderNode = null;

    // ... existing preDestroy body unchanged
}

The shader program is shared through ShaderProgramFactory's key cache, and the index buffer is the renderer's shared genericQuadIndexBuffer, so neither should be deleted here. WebGLRenderer has no VAO counterpart to deleteBuffer, which is why the fix removes the VAO from glVAOWrappers directly. A deleteVAO method on the renderer might be the cleaner upstream shape.

The same leak affects any ShaderQuad-based object that is destroyed; Shader is just the most direct way to reproduce it. The master branch's Shader.preDestroy is unchanged from 4.2.1.

Ngôn ngữ chính
JavaScript
Star
40.5k
Fork
7.2k
Chỉ số merge pull request
Không có pull request nào được merge trong 30 ngày

Chuẩn bị môi trường

Bắt đầu từ đâu

  1. Đọc hết issue, rồi đọc hướng dẫn đóng góp của dự án.
  2. Bình luận trên issue rằng bạn sẽ nhận — tránh hai người làm cùng một việc.
  3. Fork repository và làm thay đổi trên một nhánh.
  4. Mở pull request có tham chiếu số hiệu của issue.

Issue khác của phaserjs/phaser

Tất cả issue của phaserjs/phaser

Issue tương tự

Thêm issue về JavaScript

Nhận issue mới trong hộp thư của bạn

Bản tóm tắt ngắn những issue GitHub phù hợp với người mới.