虚拟机

Eigen::Matrix4f get_view_matrix(Eigen::Vector3f eye_pos)
{
    Eigen::Matrix4f view = Eigen::Matrix4f::Identity();

    Eigen::Matrix4f translate;
    translate << 1, 0, 0, -eye_pos[0], 0, 1, 0, -eye_pos[1], 0, 0, 1,
        -eye_pos[2], 0, 0, 0, 1;

    view = translate * view;

    return view;
}

// 包括绕Y,Z轴，自定义的K轴

Eigen::Matrix4f get_model_matrix(float rotation_angle)
{
    Eigen::Matrix4f model = Eigen::Matrix4f::Identity();
    float angle = rotation_angle * MY_PI / 180.0;
    Eigen::Matrix4f rotate_matrix;

    // rotate it aroun the Z axis
    //rotate_matrix<<
    // cos(angle), -sin(angle), 0.0, 0.0,
    // sin(angle),  cos(angle), 0.0, 0.0,
    //        0.0,         0.0, 1.0, 0.0,
    //        0.0,         0.0, 0.0, 1.0;

    // rotate it around the Y axis
//     rotate_matrix<<
//     cos(angle), 0.0, sin(angle), 0.0,
//    -sin(angle), 0.0, cos(angle), 0.0,
//         0.0,         0.0, 1.0, 0.0,
//         0.0,         0.0, 0.0, 1.0;

    // rotate it aound the any axis, using Rodrigues rotation formula
    Eigen::Vector3f k(3,4,5);
    Eigen::Matrix3f nom = Eigen::Matrix3f::Identity();
    Eigen::Matrix3f kk;
    Eigen::Matrix3f Rodrigues;
    kk<<0, -k[2], k[1],
     k[2],     0,-k[0],
    -k[1],  k[0],    0;
    k = k / sqrt(k[0]*k[0] + k[1]*k[1] + k[2]*k[2]);
    Rodrigues = nom * cos(angle) + (1 - cos(angle)) * k * k.transpose() + sin(angle)* kk;
    // transform 4 
    for(int i=0;i<4;i++){
        for(int j=0;j<4;j++){
            if(i==3||j==3){
                if(i!=j) rotate_matrix(i,j) = 0;
                else rotate_matrix(i,j)=1;
            }else{
                rotate_matrix(i, j) = Rodrigues(i, j);
            }
        }
    }

    return  rotate_matrix  * model;
}

Eigen::Matrix4f get_projection_matrix(float eye_fov, float aspect_ratio,
                                      float zNear, float zFar)
{
    Eigen::Matrix4f projection = Eigen::Matrix4f::Identity();
    float angle = eye_fov * MY_PI / 180.0; 
    auto t = tan(angle/2)*-zNear;
    auto r = aspect_ratio*t;
    auto l = -r;
    auto b = -t;
    // perspective->orth
    Eigen::Matrix4f PersToOrth;
    Eigen::Matrix4f Orth;
    Eigen::Matrix4f orthTranslation;
    Eigen::Matrix4f orthScale;
    PersToOrth << zNear,0,0,0,
                  0,zNear,0,0,
                  0,0,zNear+zFar,-zNear*zFar,
                  0,0,1,0;
  
    orthTranslation<<1,0,0,-(l+r)/2.0,
                     0,1,0,-(t+b)/2.0,
                     0,0,1,-(zNear+zFar)/2.0,
                     0,0,0,1;

    orthScale<< 2.0/(r-l),0,0,0,
                0,2.0/(t-b),0,0,
                0,0,2.0/(zNear-zFar),0,
                0,0,0,1;
    Orth = orthScale*orthTranslation;
    projection = Orth*PersToOrth*projection;
    return projection;
}

参考链接：
提高参考 百度百科：罗德里格旋转公式
透视矩阵的推导及几大矩阵的理论