xzy，xyz方向轉換

Question

我有一些代碼，但矩陣方向不吸引我的目的，有人可以教我如何轉換它的方向，它目前設置爲XZY，但我希望它反映XYZ，有人可以指出必須做什麼嗎？

當我做vertex3f（100，100，10）;例如，10值應該反映我網格上的Z值。

這裏是我的代碼：

#include <stdlib.h> 
#include <math.h> 
#include <stdio.h> 
#include <Windows.h> 
#include <glut.h> 
#include <iostream> 

using namespace std; 

const float sensitivity = 0.005; 
const float walk_speed = 0.5; 

float cam_pos[3] = { 100.5, 10.0f, 50 }; 
float cam_view[3] = { -1.0f, 0.0f, 1.0f }; 

static int old_x, old_y, half_width, half_height; 

int width = 1024, height = 768; 

void updateKeys() 
{ 
    if (GetAsyncKeyState('W')){ 
     cam_pos[0] += cam_view[0] * walk_speed; 
     cam_pos[1] += cam_view[1] * walk_speed; 
     cam_pos[2] += cam_view[2] * walk_speed; 
    } 
    if (GetAsyncKeyState('S')){ 
     cam_pos[0] -= cam_view[0] * walk_speed; 
     cam_pos[1] -= cam_view[1] * walk_speed; 
     cam_pos[2] -= cam_view[2] * walk_speed; 
    } 
    if (GetAsyncKeyState('A')){ 
     cam_pos[0] += cam_view[2] * walk_speed; 

     cam_pos[2] -= cam_view[0] * walk_speed; 
    } 
    if (GetAsyncKeyState('D')){ 
     cam_pos[0] -= cam_view[2] * walk_speed; 

     cam_pos[2] += cam_view[0] * walk_speed; 
    } 

    if (GetAsyncKeyState(VK_SPACE)){ 
     cam_pos[1] += walk_speed; 
    } 
} 


void renderScene(void) 
{ 
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 

    //3d camera 
    glMatrixMode(GL_MODELVIEW); 
    glLoadIdentity(); 

    gluLookAt(
     cam_pos[0], cam_pos[1], cam_pos[2], 
     cam_pos[0] + cam_view[0], cam_pos[1] + cam_view[1], cam_pos[2] + cam_view[2], 
     0.0f, 1.0f, 0.0f); 

    //render grid 
    glBegin(GL_LINES); 
    for (int i = 0; i <= 100; i++) { 
     if (i == 0) { glColor3f(.6, .3, .3); } 
     else { glColor3f(.25, .25, .25); }; 
     glVertex3f(i, 0, 0); 
     glVertex3f(i, 0, 100); 
     if (i == 0) { glColor3f(.3, .3, .6); } 
     else { glColor3f(.25, .25, .25); }; 
     glVertex3f(0, 0, i); 
     glVertex3f(100, 0, i); 
    }; 
    glEnd(); 

    glEnable(GL_POINT_SMOOTH); 
    glPointSize(50.0f); 
    glColor3f(1, 0, 0); 
    glBegin(GL_POINTS); 
    glVertex3f(0, 0, 0); 


    //X, Z, Y 
    glVertex3f(10, -10, 10); 
    glEnd(); 

    updateKeys(); 
    glutSwapBuffers(); 
} 

void normalize(float *v) 
{ 
    float magnitude = sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]); 
    v[0] /= magnitude; 
    v[1] /= magnitude; 
    v[2] /= magnitude; 
} 

void rotate_view(float *view, float angle, float x, float y, float z) 
{ 
    float new_x; 
    float new_y; 
    float new_z; 

    float c = cos(angle); 
    float s = sin(angle); 

    new_x = (x*x*(1 - c) + c)  * view[0]; 
    new_x += (x*y*(1 - c) - z*s) * view[1]; 
    new_x += (x*z*(1 - c) + y*s) * view[2]; 

    new_y = (y*x*(1 - c) + z*s)  * view[0]; 
    new_y += (y*y*(1 - c) + c)  * view[1]; 
    new_y += (y*z*(1 - c) - x*s) * view[2]; 

    new_z = (x*z*(1 - c) - y*s)  * view[0]; 
    new_z += (y*z*(1 - c) + x*s) * view[1]; 
    new_z += (z*z*(1 - c) + c)  * view[2]; 

    view[0] = new_x; 
    view[1] = new_y; 
    view[2] = new_z; 

    normalize(view); 
} 

void motion(int x, int y) 
{ 
    float rot_x, rot_y; 
    float rot_axis[3]; 

    x -= half_width; 
    y -= half_height; 

    rot_x = -(float)(x - old_x) * sensitivity; 
    rot_y = -(float)(y - old_y) * sensitivity; 

    old_x = x; 
    old_y = y; 

    rotate_view(cam_view, rot_x, 0.0f, 1.0f, 0.0f); 

    rot_axis[0] = -cam_view[2]; 
    rot_axis[1] = 0.0f; 
    rot_axis[2] = cam_view[0]; 

    normalize(rot_axis); 

    rotate_view(cam_view, rot_y, rot_axis[0], rot_axis[1], rot_axis[2]); 
} 

void mouse(int button, int state, int x, int y) 
{ 
    old_x = x - half_width; 
    old_y = y - half_height; 

    glutPostRedisplay(); 
} 

void idle() 
{ 
    glutPostRedisplay(); 
} 

void keys(unsigned char c, int x, int y) 
{ 
    glutPostRedisplay(); 


    cout << "camera view: :" << cam_view[0] << "," << cam_view[1] << "," << cam_view[2] << endl; 
} 

void reshape(int w, int h) 
{ 
    width = w; 
    height = h; 

    half_height = w/2; 
    half_width = h/2; 

    glMatrixMode(GL_PROJECTION); 
    glLoadIdentity(); 
    gluPerspective(45.0, (double)w/(double)h, 1.0, 10000.0); 

    glViewport(0, 0, w, h); 
} 


//---------------------------------------------------------------------- 
// Main program 
//---------------------------------------------------------------------- 
int main(int argc, char **argv) 
{ 
    glutInit(&argc, argv); 
    glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA); 
    glutInitWindowPosition(100, 100); 
    glutInitWindowSize(width, height); 
    glutCreateWindow("OpenGL"); 

    glutDisplayFunc(renderScene); 
    glutKeyboardFunc(keys); 
    glutReshapeFunc(reshape); 
    glutMouseFunc(mouse); 
    glutMotionFunc(motion); 
    glutIdleFunc(idle); 


    // OpenGL init 
    glEnable(GL_DEPTH_TEST); 

    // enter GLUT event processing cycle 
    glutMainLoop(); 

    return 0; // this is just to keep the compiler happy 
} 

Answer 1

使用一個轉換矩陣， 「重新映射」 的價值觀。像往常一樣，您可以在模型視圖上推送該矩陣。

單位矩陣是：

(1, 0, 0; 0, 1, 0; 0, 0, 1) 

你的矩陣是：

(1, 0, 0; 0, 0, 1; 0, 1, 0) 

我猜你可以看出其中的區別。相應地，您可以擴展到4D矩陣以獲得均勻座標。