C++实现旋转立方体正投影视图：如何仅检测左侧面？

你现在遇到的问题核心是：直接把所有边投影到y-z平面，自然会把立方体所有面的边都画出来，而我们需要只筛选出属于左侧面的边来绘制。下面分两种场景给你具体的解决思路和代码示例：

场景1：固定原始左侧面（比如x坐标最小的面） #

如果你的需求是不管立方体怎么旋转，都只显示原始的左侧面（比如初始状态下x=-1的那个面），那最简单的方法是提前定义好这个面的所有顶点和边，旋转后只绘制这些边的投影：

步骤1：定义立方体顶点和左侧面边 #

// 原始立方体顶点，采用归一化坐标（x/y/z ∈ {-1,1}）
float vertices[8][3] = {
    {-1, -1, -1}, {-1, -1, 1}, {-1, 1, -1}, {-1, 1, 1}, // 左侧面（x=-1）的4个顶点
    {1, -1, -1}, {1, -1, 1}, {1, 1, -1}, {1, 1, 1}      // 右侧面及其他顶点
};

// 左侧面的4条边，每条边对应两个顶点的索引
int leftFaceEdges[4][2] = {
    {0, 1}, {1, 3}, {3, 2}, {2, 0}
};

步骤2：实现旋转变换（以绕Y轴为例） #

用齐次坐标的思路实现旋转，这里简化为直接计算旋转后的坐标：

#include <cmath>

// 绕Y轴旋转θ角度，输出旋转后的坐标rx/ry/rz
void rotateY(float x, float y, float z, float theta, float &rx, float &ry, float &rz) {
    float rad = theta * M_PI / 180.0; // 角度转弧度
    rx = x * cos(rad) + z * sin(rad);
    ry = y;
    rz = -x * sin(rad) + z * cos(rad);
}

步骤3：仅绘制左侧面的投影 #

旋转所有顶点后，只遍历左侧面的边，转换为屏幕坐标后绘制：

void drawLeftSideView(float theta) {
    float rotVertices[8][3];
    // 先旋转所有顶点
    for (int i = 0; i < 8; i++) {
        rotateY(vertices[i][0], vertices[i][1], vertices[i][2], theta, 
                rotVertices[i][0], rotVertices[i][1], rotVertices[i][2]);
    }

    // 遍历左侧面的边，投影到Y-Z平面（忽略X分量）并绘制
    for (int i = 0; i < 4; i++) {
        int v1Idx = leftFaceEdges[i][0];
        int v2Idx = leftFaceEdges[i][1];
        // 转换为屏幕坐标（这里假设屏幕中心在(200,200)，缩放因子50）
        int screenX1 = 200 + rotVertices[v1Idx][2] * 50; // Z分量对应屏幕X轴
        int screenY1 = 200 - rotVertices[v1Idx][1] * 50; // Y分量对应屏幕Y轴（翻转方向）
        int screenX2 = 200 + rotVertices[v2Idx][2] * 50;
        int screenY2 = 200 - rotVertices[v2Idx][1] * 50;
        
        line(screenX1, screenY1, screenX2, screenY2); // 调用你的绘图库函数
    }
}

场景2：动态判断旋转后的左侧面（观察者视角的左侧） #

如果需要根据立方体的旋转角度，动态显示从观察者视角（侧视图是沿X轴正方向看）的左侧可见面，就需要通过面的法向量来判断：

步骤1：定义所有面的顶点索引 #

// 立方体的6个面，每个面包含4个顶点的索引
int cubeFaces[6][4] = {
    {0,1,3,2}, // 左侧面（原始x=-1）
    {4,5,7,6}, // 右侧面（原始x=1）
    {0,4,6,2}, // 前面（原始z=-1）
    {1,5,7,3}, // 后面（原始z=1）
    {0,1,5,4}, // 底面（原始y=-1）
    {2,3,7,6}  // 顶面（原始y=1）
};

步骤2：计算面的法向量并判断是否为左侧面 #

// 计算面的法向量（通过三个顶点的叉积）
void calculateFaceNormal(float v0[3], float v1[3], float v2[3], float normal[3]) {
    float vec1[3] = {v1[0]-v0[0], v1[1]-v0[1], v1[2]-v0[2]};
    float vec2[3] = {v2[0]-v0[0], v2[1]-v0[1], v2[2]-v0[2]};
    // 叉积计算法向量
    normal[0] = vec1[1]*vec2[2] - vec1[2]*vec2[1];
    normal[1] = vec1[2]*vec2[0] - vec1[0]*vec2[2];
    normal[2] = vec1[0]*vec2[1] - vec1[1]*vec2[0];
}

// 判断该面是否为观察者视角的左侧面（沿X轴正方向看）
bool isLeftVisibleFace(float rotVertices[8][3], int faceVertices[4]) {
    float normal[3];
    // 取面的前三个顶点计算法向量
    calculateFaceNormal(rotVertices[faceVertices[0]], 
                        rotVertices[faceVertices[1]], 
                        rotVertices[faceVertices[2]], normal);
    // 法向量与X轴正方向(1,0,0)的点积：如果小于0，说明面朝向X负方向，是左侧可见面
    float dotProduct = normal[0] * 1 + normal[1] * 0 + normal[2] * 0;
    return dotProduct < 0;
}

步骤3：动态绘制左侧面 #

遍历所有面，找到符合条件的左侧面后绘制它的边：

void drawDynamicLeftSideView(float theta) {
    float rotVertices[8][3];
    // 旋转所有顶点
    for (int i = 0; i < 8; i++) {
        rotateY(vertices[i][0], vertices[i][1], vertices[i][2], theta, 
                rotVertices[i][0], rotVertices[i][1], rotVertices[i][2]);
    }

    // 遍历所有面，找到左侧可见面并绘制
    for (int f = 0; f < 6; f++) {
        if (isLeftVisibleFace(rotVertices, cubeFaces[f])) {
            int v0 = cubeFaces[f][0];
            int v1 = cubeFaces[f][1];
            int v2 = cubeFaces[f][2];
            int v3 = cubeFaces[f][3];

            // 坐标转换工具函数
            auto toScreen = [](float y, float z) -> pair<int, int> {
                return {200 + z*50, 200 - y*50};
            };
            // 获取四个顶点的屏幕坐标
            auto p0 = toScreen(rotVertices[v0][1], rotVertices[v0][2]);
            auto p1 = toScreen(rotVertices[v1][1], rotVertices[v1][2]);
            auto p2 = toScreen(rotVertices[v2][1], rotVertices[v2][2]);
            auto p3 = toScreen(rotVertices[v3][1], rotVertices[v3][2]);

            // 绘制四条边
            line(p0.first, p0.second, p1.first, p1.second);
            line(p1.first, p1.second, p2.first, p2.second);
            line(p2.first, p2.second, p3.first, p3.second);
            line(p3.first, p3.second, p0.first, p0.second);
            break; // 只绘制一个左侧面
        }
    }
}

核心原理总结 #

你之前的代码会显示所有侧面，是因为没有对边做筛选——所有边都被投影绘制了。而我们需要：

1. 明确“左侧面”的定义：要么是原始立方体的固定面，要么是旋转后从观察者视角可见的左侧面。
2. 只绘制属于这个面的四条边，而不是所有边的投影。

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