上一篇文章：

Python pygame(GUI编程)模块最完整教程（6）_Python-ZZY的博客-CSDN博客

总目录：

README.md · Python-ZZY/Python-Pygame最完整教程 - Gitee.com

21 OpenGL与Pygame

不会OpenGL的读者可以跳过本章节。

21.1 OpenGL简介

参考资料：https://baike.baidu.com/item/OpenGL/238984

OpenGL是一个用于2D和3D渲染的API，主要在C/C++中使用。Python第三方模块pyopengl提供了对OpenGL的支持。

在pygame中使用OpenGL可以用于渲染一些3D画面，或者提升渲染的速度（因为OpenGL使用GPU）。无OpenGL基础的读者可以自行搜索，此处不再赘述。

21.2 支持OpenGL的窗口

在pygame中使用OpenGL，只需要在调用set_mode方法设置窗口的时候传递两个flags：

pg.DOUBLEBUF | pg.OPENGL

OPENGL表示这个窗口会用于OpenGL的渲染。DOUBLEBUF表示使窗口设为双缓冲模式，便于OpenGL的绘制。之后可以正常使用OpenGL的其他功能。

pg.display.set_mode(display, DOUBLEBUF | OPENGL)

22 表面像素与内存

参考资料：

https://pyga.me/docs/ref/pixelarray.html

https://pyga.me/docs/ref/bufferproxy.html

https://pyga.me/docs/ref/surfarray.html

https://pyga.me/docs/ref/pixelcopy.html

22.1 设置与获取表面单个像素

Surface对象提供了set_at和get_at方法，用于设置和获取表面中单个像素的颜色值。

pg.Surface.set_at((x, y), Color) -> None
pg.Surface.get_at((x, y)) -> Color

通过操作表面的单个像素，我们可以对表面进行精细修改，如下：

for x in range(image.get_width() // 2 + 1):
    for y in range(image.get_height() // 2 + 1):
        image.set_at((x * 2, y * 2), (0, 0, 0)) # 将偶数位置的点设为黑色

22.2 锁定表面内存

前文已经介绍过用pg.draw模块绘制图形。 但是这种绘制方式针对像素进行处理，速度可能较慢。在用pg.draw绘制很多的东西时，常常需要锁定表面内存，来提高绘制的速度。表面在锁定期间pg.draw会加快到原来的2倍左右，但是锁定期间的表面是无法被blit等方法处理的，也无法进行blit调用，这就需要在draw完成之后进行解锁。

Surface.lock() -> None
Surface.unlock() -> None

lock和unlock方法分别用于锁定与解锁表面。先锁定表面，绘制完成后再解锁表面

surf.lock() # 锁定表面以提高速度，锁定期间只能操作像素而不能被blit

...
pg.draw.rect(surf, ...) # do some drawing
surf.set_at(...)
...

surf.unlock() # 重新解锁表面，这样就可以绘制到屏幕上

下面是一个示例，显示了使用锁定后pg.draw的速度差异。（使用timeit模块测算代码运行时间）

import pygame as pg
from timeit import timeit

def estimate(*args):
    '''估算代码运行200次花费的时间'''
    return timeit(*args, number=200, globals=globals())

def draw(surf):
    '''在表面上进行绘制操作'''
    pg.draw.rect(surf, (255, 255, 255), (0, 0, 200, 200), width=20)
    pg.draw.polygon(surf, (255, 0, 0), ((20, 100), (100, 20), (180, 100), (100, 180)))
    pg.draw.circle(surf, (255, 255, 255), (100, 100), 80, width=5)
    surf.set_at((100, 100), (0, 0, 0))
    
def func():
    '''没有锁定时的pg.draw调用'''
    im = image.copy()
    draw(im)

def func2():
    '''加上锁定后的pg.draw调用'''
    im = image.copy()
    im.lock() # 锁定表面以提高速度，锁定期间只能操作像素而不能被blit
    draw(im)
    im.unlock() # 重新解锁表面，这样就可以绘制到屏幕上
            
pg.init()
screen = pg.display.set_mode((450, 300))

image = pg.Surface((200, 200))

print(estimate("func()"))
print(estimate("func2()"))

# 输出
0.020117499865591526
0.011690699961036444

22.3 像素数组

pg.PixelArray对象是一个数组，可以直接访问表面中的像素，更便捷。生成某个Surface对象的PixelArray对象后，会自动锁定表面，等PixelArray对象被删除（del）后，表面的锁定会自动解除。

pg.PixelArray(Surface) -> PixelArray

将表面作为参数传递给PixelArray即可创建该表面的像素数组。PixelArray可以通过索引和切片进行管理，与numpy.array类似。

将二元元组(x, y)作为PixelArray对象的索引可以设置在(x, y)位置的像素颜色值。相当于直接对表面进行set_at操作。颜色值可以是整数（十六进制颜色形式），也可以是pg.Color对象或直接的(R, G, B)元组；但是，不能使用颜色名称。

pxarray[x, y] = 0xFF0000
pxarray[x, y] = pg.Color(255, 0, 0, 255)
pxarray[x, y] = (255, 0, 0)
## pxarray[x, y] = "red" # ValueError: sequence size mismatch

 获取像素时略有不同。PixelArray将所有的像素颜色转换成了一个特殊的整数的形式，需要先用Surface.map_rgb或Surface.unmap_rgb进行转换才能获取或比较。这个像素整数与表面的位深度有一定关系，所以map_rgb或unmap_rgb必须要在与PixelArray绑定的表面上调用，否则可能出现问题。

Surface.map_rgb(Color) -> mapped_int
Surface.unmap_rgb(mapped_int) -> Color

unmap_rgb用于将像素整数转换为pg.Color对象，map_rgb用于将颜色转换为像素整数。map_rgb对象只能传递pg.Color对象或者(R, G, B)元组作为参数。

如果要判断像素点(100, 50)位置的颜色是否为红色，则可以这样：

image = ... # pg.Surface
pxarray = pg.PixelArray(image)

if pxarray[100, 50] == image.map_rgb((255, 0, 0)):
    ...

# 或者：

if image.unmap_rgb(pxarray[100, 50]) == (255, 0, 0):
    ...

PixelArray还支持下标切片，也就是把索引(x, y)元组中每个项都用冒号:分隔。比如[0:50, 0]就表示x坐标0-50范围，y坐标为0的一个数组。那么返回的将是一个一元的像素数组，包含原数组x坐标从0-50开始，y坐标0的部分。示例如下：

pxarray[0:50, 0] = (255, 0, 0)

修改后表面如下，红色的线即为修改过的部分 

 同样地，元组中表示y的部分也是可以修改的。例如：

pxarray[0:50, 0:100] = (255, 0, 0)

当然，如果颜色不是固定的，也可以这样：

pxarray[0:50, 0:100] = [(255, 0, 0), (255, 255, 0), (2, 2, 2), ...] # 省略了若干颜色

切片还可以有步长。

pxarray[0:50:2, 0:100] = (255, 0, 0)

切片时还可以省略其中的数字，效果和list切片的效果是一样的。于是，22.1节中的示例就可以这样表示：

pxarray[::2, ::2] = (0, 0, 0)

如果索引不是元组，而只是元组中单独的一个部分 ，则认为这个部分表示x坐标，y的值默认为::。下面两行代码是一样的意思：

pxarray[0:50] = (255, 0, 0)
# 或者：
pxarray[0:50, ::] = (255, 0, 0)
# 或者：
pxarray[0:50, ...] = (255, 0, 0)

切片时，省略的部分可以用::代替，也可以用...代替。

pxarray[..., 0:50] = (255, 0, 0)

同理，如果用以下代码，则表示将整个表面都填满红色，和fill方法效果相同。

pxarray[...] = (255, 0, 0)

在对表面的像素数组经过更改后，需要用del方法将该像素数组删除，否则表面会一直锁定，无法进行blit。如果更改专门写在一个函数中，那么就不用删除，python的垃圾回收机制会自动将它删除。下面是一个完整的使用示例：

import pygame as pg
            
pg.init()
screen = pg.display.set_mode((450, 300))
clock = pg.time.Clock()

image = pg.image.load("logo.png")
pxarray = pg.PixelArray(image)
pxarray[::2, ::2] = (0, 0, 0)
del pxarray

while True:
    screen.fill((0, 0, 0))
    screen.blit(image, (0, 0))

    for event in pg.event.get():
        if event == pg.QUIT:
            pg.quit()

    clock.tick(60)
    pg.display.flip()

运行效果仍和22.1节相同。

22.4 PixelArray对象方法索引

surface -> Surface

像素数组使用的表面

itemsize -> int

像素数组的字节数量。和像素数组Surface.get_bytesize()调用结果相同。

ndim -> int

像素数组的维度，是1或2。如果是1维，则该数组表示一行或一列的像素值。如果是2维，该数组表示一个表面（或表面某一部分）的像素值。

shape -> tuple of int's

像素数组的形状（或尺寸）。和像素数组Surface.get_size()调用结果相同。

strides -> tuple of int's

元组或长度ndim字节计数。当步幅乘以相应的索引时，它会给出该索引从数组开始的偏移量。如果数组的步长为负，则数组的步长为负。

make_surface() -> Surface

根据像素数组生成一个新的表面对象。

replace(color, repcolor, distance=0, weights=(0.299, 0.587, 0.114)) -> None

替换像素数组中的颜色。将数组中的color替换为repcolor。它还支持通过欧几里得加权距离公式将一些相似的颜色也进行替换。distance是0-1之间的浮点数，weights表示R, G, B色彩的权值。

这个方法将原地修改，而不会返回新的PixelArray对象。

extract(color, distance=0, weights=(0.299, 0.587, 0.114)) -> PixelArray

将匹配color的颜色全部替换为白色，不匹配的颜色替换为黑色。同样支持相似替换。

这个方法会返回新的PixelArray对象。

compare(array, distance=0, weights=(0.299, 0.587, 0.114)) -> PixelArray

与另一个像素数组进行比较，返回一个新的PixelArray对象表示二者的差异。如果在相同的位置颜色一样则设为白色，不相同则设为黑色。

transpose() -> PixelArray

将数组的x, y交换，返回新的PixelArray对象。（相当于先逆时针旋转90度，然后上下翻转）

close() -> PixelArray

将数组关闭，并解锁表面。

22.5 surfarray模块索引 - Surface与numpy数组

numpy是pygame的一个常用第三方库，提供了一系列数学运算。不了解numpy的读者可以自行跳过本节。

pg.surfarray模块用于转换Surface和numpy.array。因此，pg.surfarray依赖于numpy模块，如果没有安装numpy则不能使用surfarray。

surfarray大致效果与PixelArray类似，此处不进行赘述，下面列举pg.surfarray的属性与方法。

array2d(Surface) -> array

将Surface中的像素复制并生成二维numpy数组，其中每个像素表示为整数的map值，需要用Surface.unmap_rgb才能转换为(r, g, b)。

pixels2d(Surface) -> array

和array2d一样，但是不会复制Surface中的像素，而是直接返回数组，其中每个像素都与原来的Surface关联，和PixelArray类似。因此它会锁定Surface，等到数组被删除才解锁。

array3d(Surface) -> array

将Surface中的像素复制并生成三维numpy数组。这个数组其实和二维数组表示一个意思，但是每个像素用[r, g, b]列表表示，所以是三维的。

pixels3d(Surface) -> array

和array3d一样，但是不会复制Surface中的像素，而是直接返回数组，其中每个像素都与原来的Surface关联，和PixelArray类似。因此它会锁定Surface，等到数组被删除才解锁。

array_alpha(Surface) -> array

生成一个二维数组，每个像素点表示该像素的Alpha值，即(R, G, B, A)中的A。

pixels_alpha(Surface) -> array

和array_alpha一样，但是不会复制Surface中的像素，而是直接返回数组，其中每个像素都与原来的Surface关联，和PixelArray类似。因此它会锁定Surface，等到数组被删除才解锁。

array_red(Surface) -> array

生成一个二维数组，每个像素点表示该像素的Red值，即(R, G, B, A)中的R。

同理还有array_green, array_blue方法，为节省篇幅这里没有列举

pixels_red (Surface) -> array

同理还有pixels_green, pixels_blue方法，为节省篇幅这里没有列举

array_colorkey(Surface) -> array

生成一个二维数组，每个像素点表示该像素的colorkey。如果符合colorkey的颜色，那么它将显示为0（透明），否则是255（不透明）

make_surface(array) -> Surface

将2d或3d数组转换为表面

blit_array(Surface, array) -> None

将数组转换为表面后绘制到Surface上，表面和数组必须尺寸相同。它相当于Surface.blit(pg.surfarray.ake_surface(array), (0, 0))，但是速度会更快。

map_array(Surface, array3d) -> array2d

将3d数组转换为2d数组

22.6 BufferProxy对象方法索引

BufferProxy，直译就是缓冲代理，存储了表面最原始的信息，是pygame模块的关键。BufferProxy可以直接调用来实例化，但是更常用的是通过表面的get_view和get_buffer方法。

Surface.get_buffer() -> BufferProxy
Surface.get_view(<kind>='2') -> BufferProxy