如何在Python PyOpenGL中实现魔方切片旋转？

看起来你已经把魔方的视觉呈现做得很不错了！切片旋转的核心难点在于正确处理旋转中心和坐标系变换，直接旋转顶点容易出错，因为默认的旋转是绕原点进行的，而我们需要绕切片的轴旋转。下面我会一步步帮你实现切片旋转功能：

1. 重构立方体存储结构，方便筛选切片 #

你现在用count作为cubeDict的键，很难快速找到某一层的立方体。我们改成用每个小立方体的**三维索引(x,y,z)**作为键，这样可以直接筛选出指定层的所有立方体：

修改EntireCube类的createEntireCube方法：

def createEntireCube(self):
    '''for each dimension x,y,z make a dictionary containing the vertices to be displayed'''
    self.cubeDict = {}
    for x in range(self.typeOfCube):
        for y in range(self.typeOfCube):
            for z in range(self.typeOfCube):
                # 用(x,y,z)作为键，后续可以直接通过x/y/z值筛选切片
                self.cubeDict[(x,y,z)] = self.NewCube.setVertices(x*2.1, y*2.1, z*2.1)

2. 实现切片旋转的核心逻辑 #

切片旋转的正确流程是：

• 筛选出目标切片的所有立方体
• 将每个立方体的顶点平移到旋转轴的原点（这样旋转才会绕切片轴进行）
• 执行旋转计算
• 将顶点平移回原位置
• 更新立方体的索引位置（因为旋转后立方体在切片内的位置会互换）

我们先实现绕y轴旋转x层（比如3x3的右层x=2）的函数，记得先导入math模块：

import math

class EntireCube():
    # ... 其他代码 ...

    def rotate_x_slice(self, layer, angle):
        """旋转指定x层的切片，绕y轴旋转angle度"""
        theta = math.radians(angle)
        cos_theta = math.cos(theta)
        sin_theta = math.sin(theta)
        # 该层所有立方体的中心x坐标基准
        base_x = layer * 2.1

        # 先收集切片内的所有立方体数据，避免修改字典时迭代出错
        slice_data = list(self.cubeDict.items())
        updates = {}

        for pos, verts in slice_data:
            x_pos, y_pos, z_pos = pos
            if x_pos != layer:
                continue  # 只处理目标层的立方体

            # 旋转每个顶点
            new_verts = []
            for (x, y, z) in verts:
                # 1. 平移到旋转轴原点（x=base_x）
                tx = x - base_x
                ty = y
                tz = z

                # 2. 绕y轴旋转（右手坐标系旋转矩阵）
                rx = tx * cos_theta - tz * sin_theta
                ry = ty
                rz = tx * sin_theta + tz * cos_theta

                # 3. 平移回原位置
                fx = rx + base_x
                fy = ry
                fz = rz
                new_verts.append((fx, fy, fz))

            # 计算旋转后立方体的新索引位置
            # 基于立方体中心坐标反推新的x/y/z索引
            cx = x_pos * 2.1
            cy = y_pos * 2.1
            cz = z_pos * 2.1

            # 平移-旋转-平移回中心坐标
            tcx = cx - base_x
            tcy = cy
            tcz = cz
            rcx = tcx * cos_theta - tcz * sin_theta
            rcy = tcy
            rcz = tcx * sin_theta + tcz * cos_theta
            fcx = rcx + base_x
            fcy = rcy
            fcz = rcz

            # 转换为整数索引（因为间距是2.1，所以除以2.1取整）
            new_y = round(fcy / 2.1)
            new_z = round(fcz / 2.1)
            new_pos = (layer, new_y, new_z)
            updates[new_pos] = new_verts

        # 更新字典：删除旧位置的立方体，添加旋转后的新位置
        for pos, _ in slice_data:
            x_pos, _, _ = pos
            if x_pos == layer:
                del self.cubeDict[pos]
        self.cubeDict.update(updates)

3. 添加按键触发旋转 #

在mainloop的按键事件处理中，添加触发旋转的逻辑，比如按R键旋转3x3魔方的右层（x=2）顺时针90度：

def mainloop(self):
    '''key events, creates the matrix of cubes'''
    rotateUpKey, rotateDownKey, rotateLeftKey, rotateRightKey = False, False, False, False
    rotationalSensitivity = 2
    while True:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                quit()
            if event.type == KEYDOWN:
                # ... 原有方向键代码 ...
                # 添加切片旋转按键
                if event.key == K_r:
                    # 旋转右层（x=2）顺时针90度
                    self.rotate_x_slice(2, 90)
                if event.key == K_l:
                    # 旋转左层（x=0）逆时针90度（等价于顺时针270度）
                    self.rotate_x_slice(0, -90)
            # ... 原有按键抬起代码 ...
        # ... 原有渲染代码 ...

4. 扩展其他轴的切片旋转 #

用同样的逻辑，你可以实现绕x轴旋转y层（比如上层）的函数：

def rotate_y_slice(self, layer, angle):
    """旋转指定y层的切片，绕x轴旋转angle度"""
    theta = math.radians(angle)
    cos_theta = math.cos(theta)
    sin_theta = math.sin(theta)
    base_y = layer * 2.1

    slice_data = list(self.cubeDict.items())
    updates = {}

    for pos, verts in slice_data:
        x_pos, y_pos, z_pos = pos
        if y_pos != layer:
            continue

        new_verts = []
        for (x, y, z) in verts:
            # 平移到y轴原点
            tx = x
            ty = y - base_y
            tz = z

            # 绕x轴旋转
            rx = tx
            ry = ty * cos_theta - tz * sin_theta
            rz = ty * sin_theta + tz * cos_theta

            # 平移回原位置
            fx = rx
            fy = ry + base_y
            fz = rz
            new_verts.append((fx, fy, fz))

        # 计算新位置索引
        cx = x_pos * 2.1
        cy = base_y
        cz = z_pos * 2.1

        tcx = cx
        tcy = cy - base_y
        tcz = cz
        rcx = tcx
        rcy = tcy * cos_theta - tcz * sin_theta
        rcz = tcy * sin_theta + tcz * cos_theta
        fcx = rcx
        fcy = rcy + base_y
        fcz = rcz

        new_x = round(fcx / 2.1)
        new_z = round(fcz / 2.1)
        new_pos = (new_x, layer, new_z)
        updates[new_pos] = new_verts

    # 更新字典
    for pos, _ in slice_data:
        _, y_pos, _ = pos
        if y_pos == layer:
            del self.cubeDict[pos]
    self.cubeDict.update(updates)

然后在按键事件里添加：

if event.key == K_u:
    # 旋转上层（y=2）顺时针90度
    self.rotate_y_slice(2, 90)

关键注意点 #

• 坐标系方向：OpenGL使用右手坐标系，z轴向外为正，所以旋转角度的正负会影响旋转方向，你可以根据实际视觉效果调整角度（比如用-90代替90实现逆时针旋转）。
• 位置索引更新：旋转后必须更新立方体的(x,y,z)索引，否则后续筛选切片会基于旧位置，导致逻辑错误。
• 避免迭代时修改字典：一定要先把字典数据转成列表再迭代，否则在删除键的时候会引发迭代错误。

这样你就可以实现任意层的切片旋转了，后续还可以扩展z轴切片的旋转逻辑，方法和上面的类似。

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