基于Tkinter的简易3D引擎相机局部坐标系移动与旋转问题求助

Let's tackle the core problem here: your camera is currently operating in global XYZ space instead of its own local coordinate system. This happens because of incorrect transformation order in your view matrix, and direct manipulation of global position variables without accounting for camera rotation. Here's how to fix it step by step:

1. Understand the Correct View Matrix Transformation Order #

The view matrix represents the inverse of the camera's transformation (since we're moving the world relative to the camera, not the other way around). The correct order for building the view matrix is:

• First, translate the world by the negative of the camera's position (to move the camera to the origin)
• Then, apply the inverse of the camera's rotation (to rotate the world opposite to the camera's orientation)

Your original worldToView function had rotation before translation, which caused translation to happen in global space instead of camera-local space.

2. Fix the View Matrix Calculation #

Update your worldToView function to use the correct transformation order:

def worldToView(vertex):
    # Convert camera angles to radians
    camX_rad = math.radians(camXangle)
    camY_rad = math.radians(camYangle)
    
    # Camera rotation matrices (inverse = transpose for orthogonal matrices)
    CamxRotationMatrix = numpy.array(
        [[1, 0, 0, 0],
         [0, math.cos(camX_rad), math.sin(camX_rad), 0],
         [0, -math.sin(camX_rad), math.cos(camX_rad), 0],
         [0, 0, 0, 1]])
    CamyRotationMatrix = numpy.array(
        [[math.cos(camY_rad), 0, -math.sin(camY_rad), 0],
         [0, 1, 0, 0],
         [math.sin(camY_rad), 0, math.cos(camY_rad), 0],
         [0, 0, 0, 1]])
    
    # Translation matrix: move world by -camera position
    CamTranslationMatrix = numpy.array([[1, 0, 0, -xcam],
                                        [0, 1, 0, -ycam],
                                        [0, 0, 1, -zcam],
                                        [0, 0, 0, 1]])
    
    # Combine transformations: translate first, then rotate (matrix order is right-to-left)
    CamRotationMatrix = numpy.dot(CamyRotationMatrix, CamxRotationMatrix)
    ViewMatrix = numpy.dot(CamRotationMatrix, CamTranslationMatrix)
    
    return numpy.dot(ViewMatrix, vertex)

3. Make Camera Movement Use Local Coordinates #

Instead of directly modifying xcam, ycam, zcam with global axis values, we need to convert the local movement direction (e.g., E = forward along camera's -Z) into global coordinates using the camera's rotation matrix.

Update your move function:

def move(event):
    global xcam, ycam, zcam
    camX_rad = math.radians(camXangle)
    camY_rad = math.radians(camYangle)
    
    # Create camera rotation matrix to convert local directions to global
    rot_y = numpy.array([
        [math.cos(camY_rad), 0, math.sin(camY_rad)],
        [0, 1, 0],
        [-math.sin(camY_rad), 0, math.cos(camY_rad)]
    ])
    rot_x = numpy.array([
        [1, 0, 0],
        [0, math.cos(camX_rad), -math.sin(camX_rad)],
        [0, math.sin(camX_rad), math.cos(camX_rad)]
    ])
    cam_rot = numpy.dot(rot_y, rot_x)
    
    # Define local movement vectors (camera's own axes)
    forward = numpy.array([0, 0, -1])  # E key
    backward = numpy.array([0, 0, 1])   # Q key
    left = numpy.array([-1, 0, 0])      # A key
    right = numpy.array([1, 0, 0])      # D key
    up = numpy.array([0, 1, 0])         # W key
    down = numpy.array([0, -1, 0])      # S key
    
    speed = 0.2
    if event.char == 'q':
        global_dir = numpy.dot(cam_rot, backward)
        xcam += global_dir[0] * speed
        ycam += global_dir[1] * speed
        zcam += global_dir[2] * speed
    if event.char == 'e':
        global_dir = numpy.dot(cam_rot, forward)
        xcam += global_dir[0] * speed
        ycam += global_dir[1] * speed
        zcam += global_dir[2] * speed
    if event.char == 'a':
        global_dir = numpy.dot(cam_rot, left)
        xcam += global_dir[0] * speed
        ycam += global_dir[1] * speed
        zcam += global_dir[2] * speed
    if event.char == 'd':
        global_dir = numpy.dot(cam_rot, right)
        xcam += global_dir[0] * speed
        ycam += global_dir[1] * speed
        zcam += global_dir[2] * speed
    if event.char == 'w':
        global_dir = numpy.dot(cam_rot, up)
        xcam += global_dir[0] * speed
        ycam += global_dir[1] * speed
        zcam += global_dir[2] * speed
    if event.char == 's':
        global_dir = numpy.dot(cam_rot, down)
        xcam += global_dir[0] * speed
        ycam += global_dir[1] * speed
        zcam += global_dir[2] * speed

4. Fix Rotation Consistency #

Your rotation functions are mostly correct, but adding a clamp to camXangle (between -90 and 90 degrees) will prevent the camera from flipping upside down, which would break the local coordinate system:

def rotateUp(event):
    global camXangle
    camXangle = min(camXangle + 4, 90)

def rotateDown(event):
    global camXangle
    camXangle = max(camXangle - 4, -90)

Why This Works #

• View Matrix Order: By translating first (moving the world to the camera's origin) then rotating, we ensure that rotation is applied relative to the camera's position, not the global origin.
• Local to Global Conversion: Using the camera's rotation matrix to transform movement vectors turns the camera's local directions (forward, left, etc.) into global coordinates, so pressing E always moves you where the camera is looking.
• Rotation Clamping: Prevents the camera from doing a full flip, which would cause the coordinate system to invert unexpectedly.

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