如何优化Python中百万级2D点的渲染帧率（Pygame/OpenGL）

你的帧率低完全不是库的问题，也不是GPU性能不够——逐次调用绘制API的CPU开销才是元凶。不管是Pygame的draw.circle还是OpenGL的glVertex2f，每一次调用都会触发CPU与GPU的通信，百万次调用的话，光是通信延迟就能把帧率压到个位数，完全没利用到GPU的并行处理能力。

一、Pygame优化方案 #

Pygame 2.0+提供了gpu模块，支持批量GPU渲染，能直接利用GPU处理百万级顶点：

1. 准备顶点数据：把所有点的坐标转换成连续的浮点数组（用numpy数组效率更高）
2. 创建GPU顶点缓冲区，一次性上传所有数据
3. 绑定缓冲区后，单次调用完成批量渲染

示例代码：

import pygame
import pygame.gpu
import numpy as np

pygame.init()
screen = pygame.display.set_mode((1920, 1080), pygame.DOUBLEBUF | pygame.OPENGL)
gpu_surface = pygame.gpu.Surface((1920, 1080))

circle_radius = 3
# 生成百万个随机点坐标，转换为屏幕范围
positions = np.random.rand(1000000, 2).astype(np.float32)
positions[:, 0] *= 1920
positions[:, 1] *= 1080

# 创建顶点缓冲区并上传数据
vbo = pygame.gpu.VertexBuffer(positions.nbytes)
vbo.update(positions.tobytes())

# 定义顶点格式：2个float类型的位置属性
vertex_format = pygame.gpu.VertexFormat(pygame.gpu.VertexAttribute('pos', pygame.gpu.FLOAT, 2))
vertex_array = pygame.gpu.VertexArray(vertex_format, vbo)

# 设置点颜色
gpu_surface.set_color(pygame.Color(255,255,255))

clock = pygame.time.Clock()
running = True
while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    gpu_surface.fill((0,0,0))
    # 单次调用渲染所有点
    vertex_array.draw(pygame.gpu.PRIMITIVE_POINTS, 1000000, point_size=circle_radius)
    
    screen.blit(gpu_surface, (0,0))
    pygame.display.flip()
    clock.tick(60)
    print(f"FPS: {clock.get_fps():.1f}")

pygame.quit()

如果不需要圆形，也可以用pygame.surfarray直接操作像素缓冲区，性能同样可观：

import pygame
import numpy as np

pygame.init()
screen = pygame.display.set_mode((1920, 1080))
screen_array = pygame.surfarray.pixels3d(screen)

# 生成百万个随机像素位置
positions = np.random.randint(0, 1920, (1000000, 2))
# 批量设置像素为白色
screen_array[positions[:,1], positions[:,0]] = (255,255,255)

pygame.display.flip()
# 后续循环仅需更新像素数组即可

二、OpenGL优化方案 #

你用的是早已被废弃的立即模式（glBegin/glEnd），这种方式性能极差，正确的做法是用**VBO（顶点缓冲对象）**批量上传顶点数据，单次绘制所有点：

步骤说明： #

1. 把所有顶点数据打包成连续数组，一次性上传到GPU内存（VBO）
2. 使用VAO（顶点数组对象）管理顶点格式
3. 用glDrawArrays单次调用渲染所有点
4. 通过片段着色器的距离场，把默认方形点转为圆形

示例代码（Python + PyOpenGL）：

import pygame
from OpenGL.GL import *
from OpenGL.GL.shaders import compileProgram, compileShader
import numpy as np
import ctypes

pygame.init()
screen = pygame.display.set_mode((1920, 1080), pygame.DOUBLEBUF | pygame.OPENGL)

# 生成百万个点坐标，归一化到OpenGL的[-1,1]范围
positions = np.random.rand(1000000, 2).astype(np.float32) * 2 - 1

# 顶点着色器：处理点位置和大小
vertex_shader = """
#version 330 core
layout (location = 0) in vec2 aPos;
void main() {
    gl_Position = vec4(aPos, 0.0, 1.0);
    gl_PointSize = 6.0; // 对应圆形直径，可根据需求调整
}
"""

# 片段着色器：将方形点转为圆形
fragment_shader = """
#version 330 core
out vec4 FragColor;
void main() {
    vec2 coord = gl_PointCoord - 0.5;
    // 距离场判断，超出圆形范围的像素丢弃
    if (length(coord) > 0.5) discard;
    FragColor = vec4(1.0, 1.0, 1.0, 1.0);
}
"""

# 编译着色器程序
shader = compileProgram(compileShader(vertex_shader, GL_VERTEX_SHADER),
                        compileShader(fragment_shader, GL_FRAGMENT_SHADER))

# 创建VAO和VBO
VAO = glGenVertexArrays(1)
VBO = glGenBuffers(1)

glBindVertexArray(VAO)
glBindBuffer(GL_ARRAY_BUFFER, VBO)
# 一次性上传所有顶点数据到GPU
glBufferData(GL_ARRAY_BUFFER, positions.nbytes, positions, GL_STATIC_DRAW)

# 设置顶点属性指针
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 2 * 4, ctypes.c_void_p(0))
glEnableVertexAttribArray(0)

glBindBuffer(GL_ARRAY_BUFFER, 0)
glBindVertexArray(0)

clock = pygame.time.Clock()
running = True
while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    glClear(GL_COLOR_BUFFER_BIT)
    glUseProgram(shader)
    glBindVertexArray(VAO)
    # 单次调用渲染百万个点
    glDrawArrays(GL_POINTS, 0, 1000000)
    
    pygame.display.flip()
    clock.tick(60)
    print(f"FPS: {clock.get_fps():.1f}")

# 清理资源
glDeleteVertexArrays(1, [VAO])
glDeleteBuffers(1, [VBO])
glDeleteProgram(shader)
pygame.quit()

关键说明： #

• 顶点数据仅上传一次（GL_STATIC_DRAW标记），后续渲染直接读取GPU本地内存，彻底避免CPU-GPU频繁通信
• 片段着色器的距离场逻辑无需额外纹理，就能生成平滑圆形
• 这种方式能轻松把帧率拉到60FPS以上，完全发挥GPU的并行处理能力

内容的提问来源于stack exchange，提问作者user19013678