如何在PyOpenGL中实现无父子关系的3D物体旋转？

你的核心问题是当前使用的glRotatef基于局部坐标系执行旋转，导致旋转顺序直接影响最终结果；而你需要的是世界坐标系下的固定轴旋转——无论物体当前朝向如何，X轴始终对应全局上下方向，Y轴始终对应全局左右方向。以下是两种可行的解决方案：

方案1：使用四元数维护旋转（推荐，避免万向锁） #

四元数能更优雅地处理世界轴旋转，规避矩阵乘法的顺序陷阱，还能避免万向锁问题。我们用四元数存储当前旋转状态，每次按键时基于世界轴添加增量旋转，再将四元数转换为矩阵应用到OpenGL中。

修改后的完整代码：

import pygame
from pygame.locals import *
from OpenGL.GL import *
from OpenGL.GLU import *
from random import uniform
import numpy as np

# 用四元数存储当前旋转，初始为单位四元数（w, x, y, z）
current_rot = np.array([1.0, 0.0, 0.0, 0.0])

stars = []
for a in range(500):
    stars.append([uniform(-5, 5), uniform(-5, 5)])

def quaternion_mult(q1, q2):
    """四元数乘法：q1 * q2"""
    w1, x1, y1, z1 = q1
    w2, x2, y2, z2 = q2
    return np.array([
        w1*w2 - x1*x2 - y1*y2 - z1*z2,
        w1*x2 + x1*w2 + y1*z2 - z1*y2,
        w1*y2 - x1*z2 + y1*w2 + z1*x2,
        w1*z2 + x1*y2 - y1*x2 + z1*w2
    ])

def quaternion_to_matrix(q):
    """将四元数转换为4x4旋转矩阵"""
    w, x, y, z = q
    x2, y2, z2 = x*2, y*2, z*2
    xx, xy, xz = x*x2, x*y2, x*z2
    yy, yz, zz = y*y2, y*z2, z*z2
    wx, wy, wz = w*x2, w*y2, w*z2
    return np.array([
        [1 - yy - zz, xy - wz, xz + wy, 0],
        [xy + wz, 1 - xx - zz, yz - wx, 0],
        [xz - wy, yz + wx, 1 - xx - yy, 0],
        [0, 0, 0, 1]
    ], dtype=np.float32)

def init():
    pygame.init()
    display = (900, 700)
    pygame.display.set_mode(display, DOUBLEBUF | OPENGL)
    gluPerspective(45, (display[0] / display[1]), 0.1, 50.0)
    glEnable(GL_DEPTH_TEST)
    glClearColor(0.0, 0.0, 0.0, 1.0)
    glTranslatef(0, 0, -2)
    glMatrixMode(GL_MODELVIEW)

def draw():
    global current_rot
    # 绘制立方体
    glPushMatrix()
    # 将四元数转换的旋转矩阵应用到立方体
    glMultMatrixf(quaternion_to_matrix(current_rot))

    vertices = (
        (.25, .25, .25),
        (.25, -.25, .25),
        (-.25, -.25, .25),
        (-.25, .25, .25),
        (.25, .25, -.25),
        (.25, -.25, -.25),
        (-.25, -.25, -.25),
        (-.25, .25, -.25)
    )
    edges = (
        (0, 1), (1, 2), (2, 3), (3, 0),
        (4, 5), (5, 6), (6, 7), (7, 4),
        (0, 4), (1, 5), (2, 6), (3, 7)
    )

    glColor3fv((0.0, 1.0, 0.0))
    glLineWidth(5)
    glBegin(GL_LINES)
    for edge in edges:
        for vertex in edge:
            glVertex3fv(vertices[vertex])
    glEnd()
    glPopMatrix()

    # 绘制背景星星（反向旋转模拟相机移动效果）
    glPushMatrix()
    # 应用反向旋转，让星星呈现背景移动的视觉效果
    inv_rot = np.array([current_rot[0], -current_rot[1], -current_rot[2], -current_rot[3]])
    glMultMatrixf(quaternion_to_matrix(inv_rot))

    glColor3fv((1.0, 1.0, 1.0))
    glPointSize(2.0)
    glBegin(GL_POINTS)
    for c in stars:
        glVertex3f(c[0], c[1], -5)
        glVertex3f(c[0], c[1], 5)
        glVertex3f(5, c[0], c[1])
        glVertex3f(-5, c[0], c[1])
        glVertex3f(c[0], 5, c[1])
        glVertex3f(c[0], -5, c[1])
    glEnd()
    glPopMatrix()

def main():
    global current_rot
    init()
    clock = pygame.time.Clock()

    rate_x = 0
    rate_y = 0
    while True:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                quit()
            elif event.type == pygame.KEYDOWN:
                if event.key == pygame.K_w:
                    rate_x = 0.5
                elif event.key == pygame.K_a:
                    rate_y = 0.5
                elif event.key == pygame.K_s:
                    rate_x = -0.5
                elif event.key == pygame.K_d:
                    rate_y = -0.5
            elif event.type == pygame.KEYUP:
                if event.key in (pygame.K_w, pygame.K_s):
                    rate_x = 0
                elif event.key in (pygame.K_a, pygame.K_d):
                    rate_y = 0

        # 生成增量旋转的四元数（基于世界轴）
        if rate_x != 0:
            angle = rate_x
            q_x = np.array([np.cos(np.radians(angle/2)), np.sin(np.radians(angle/2)), 0, 0])
            current_rot = quaternion_mult(q_x, current_rot)
        if rate_y != 0:
            angle = rate_y
            q_y = np.array([np.cos(np.radians(angle/2)), 0, np.sin(np.radians(angle/2)), 0])
            current_rot = quaternion_mult(q_y, current_rot)
        # 归一化四元数，避免数值漂移
        current_rot /= np.linalg.norm(current_rot)

        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
        draw()
        pygame.display.flip()
        clock.tick(60)

if __name__ == '__main__':
    main()

方案2：直接计算世界轴旋转矩阵 #

如果不想使用四元数，可以每次基于当前角度重新计算绕世界X、Y轴的旋转矩阵，注意矩阵乘法顺序——先应用绕世界Y轴的旋转，再应用绕世界X轴的旋转（OpenGL采用右乘矩阵的规则）。

修改后的核心绘制逻辑：

# 保留原有的angle_x、angle_y变量
def draw():
    global angle_x, angle_y
    # 绘制立方体
    glPushMatrix()
    # 先绕世界Y轴旋转，再绕世界X轴旋转，确保旋转基于全局坐标系
    glRotatef(angle_y, 0, 1, 0)
    glRotatef(angle_x, 1, 0, 0)

    # ... 立方体绘制代码不变 ...
    glPopMatrix()

    # 绘制背景星星
    glPushMatrix()
    # 反向旋转星星，模拟背景移动
    glRotatef(-angle_x, 1, 0, 0)
    glRotatef(-angle_y, 0, 1, 0)

    # ... 星星绘制代码不变 ...
    glPopMatrix()

注意：这种方式在旋转角度较大时可能出现万向锁问题，四元数方案的稳定性更强。

关键原理说明 #

• 局部坐标系旋转：glRotatef会实时修改当前矩阵，后续旋转都会基于修改后的局部坐标轴，这就是你遇到的"父子关系"问题。
• 世界坐标系旋转：每次旋转都基于固定的全局坐标轴，需要通过四元数或重新计算矩阵组合的方式，避免累积局部旋转带来的轴偏移。

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