如何在openGL中编写FPS相机代码

Question

我一直在尝试使用C ++在openGL中开发一个可用的FPS相机。

使用欧拉角并查看来自openGL superBible v.5的示例代码，我能够获得良好的翻译工作，并且如果我将旋转限制为单个维度（例如，只是俯仰，或者只是偏航） ，这也很好。但是当我组合俯仰和偏航时，我最终会产生奇怪的结果旋转以及滚动的变化（即地平线不会保持水平）。这是迄今为止我所拥有的最好的系统，如果不是滚动，那将是完美的。但是，我对这方面的情况并不是很了解，因为我正在做的就是调用方法来翻译和旋转GLFrame。

我读到了欧拉角，发现它们遇到了一个叫做万向节锁的问题，所以我尝试转而使用四元数。我存储俯仰和偏航变量并从中导出四元数，然后从四元数构建矩阵并将其推送到MODELVIEW堆栈。发生的事情是它似乎旋转整个世界而不是相机的POV，并且非常奇怪地拉伸出形状。

这是源代码：

#include <GLTools.h>
#include <GLShaderManager.h> 
#include <GL/glut.h>
#include <GLBatch.h>
#include <GLFrustum.h>
#include <GLFrame.h>
#include <GLMatrixStack.h>
#include <GLGeometryTransform.h>
#include <math.h>
#include <stdio.h>
#include <iostream>
using namespace std;

#define CUBE_COUNT 400
#define WINDOW_WIDTH 800
#define WINDOW_HEIGHT 600
#define ESCAPE_KEY 27

//CLASSES
GLShaderManager     shaderManager;
GLMatrixStack       modelViewMatrix;
GLMatrixStack       projectionMatrix;
GLFrame             cameraFrame;
GLFrame             objectFrame;
GLFrame             cubes[CUBE_COUNT];
GLFrustum           viewFrustum;

GLBatch             triangleBatch;
GLBatch             cubeBatch;

GLGeometryTransform transformPipeline;
M3DMatrix44f        shadowMatrix;
M3DMatrix44f        camMatrix;

GLfloat vGreen[] = {0.0f, 1.0f, 0.0f, 1.0f};
GLfloat vBlack[] = {0.0f, 0.0f, 0.0f, 1.0f};

float pitch;
float yaw;
float roll;

float mouse_x;
float mouse_y;

bool w_pressed = false;
bool a_pressed = false;
bool s_pressed = false;
bool d_pressed = false;

float cam_x = 0.0f;
float cam_y = 0.0f;
float cam_z = 0.0f;

///////////////////////////////////////////////////////////////////////////////
// This function does any needed initialization on the rendering context. 
// This is the first opportunity to do any OpenGL related tasks.

typedef struct {
    GLfloat x;
    GLfloat y;
    GLfloat z;
    GLfloat w;
} Quaternion3D;

static inline void Quaternion3DNormalise(Quaternion3D *quaternion) {
    GLfloat magnitude;

    magnitude = sqrtf((quaternion->x * quaternion->x) +
                      (quaternion->y * quaternion->y) +
                      (quaternion->z * quaternion->z) +
                      (quaternion->w * quaternion->w));

    quaternion->x /= magnitude;
    quaternion->y /= magnitude;
    quaternion->z /= magnitude;
    quaternion->w /= magnitude;
}

static inline void Quaternion3DMultiplication(Quaternion3D *newQ, Quaternion3D *q1, Quaternion3D *q2) {
    newQ->w = q1->w * q2->w - q1->x * q2->x - q1->y * q2->y - q1->z * q2->z;
    newQ->x = q1->w * q2->x + q1->x * q2->w + q1->y * q2->z - q1->z * q2->y;
    newQ->y = q1->w * q2->y - q1->x * q2->z + q1->y * q2->w + q1->z * q2->x;
    newQ->z = q1->w * q2->z + q1->x * q2->y - q1->y * q2->x + q1->z * q2->w;
}

static inline void Quaternion3DMultIdentity(Quaternion3D *q) {
    q->x = 0;
    q->y = 0;
    q->z = 0;
    q->w = 1;
}

static inline void Quaternion3DInverse(Quaternion3D *q) {
    q->x *= -1;
    q->y *= -1;
    q->z *= -1;
}

static inline void EulerToQuaternion3D(Quaternion3D *q, float pitch, float yaw, float roll) {
    float radiansPitch = m3dDegToRad(pitch);
    float radiansYaw   = m3dDegToRad(yaw);
    float radiansRoll  = m3dDegToRad(roll);

    float sinPitch = sin(radiansPitch * 0.5);
    float cosPitch = cos(radiansPitch * 0.5);
    float sinYaw = sin(radiansYaw * 0.5);
    float cosYaw = cos(radiansYaw * 0.5);
    float sinRoll = sin(radiansRoll * 0.5);
    float cosRoll = cos(radiansRoll * 0.5);

    q->w = cosYaw * cosRoll * cosPitch - sinYaw * sinRoll * sinPitch;
    q->x = sinYaw * sinRoll * cosPitch + cosYaw * cosRoll * sinPitch;
    q->y = sinYaw * cosRoll * cosPitch + cosYaw * sinRoll * sinPitch;
    q->z = cosYaw * sinRoll * cosPitch - sinYaw * cosRoll * sinPitch;

    Quaternion3DNormalise(q);
}

static inline void QuatToMatrix(M3DMatrix44f matrix, Quaternion3D *q) {

    //first column
    matrix[0] = 1 - 2 * (q->y * q->y + q->z + q->z);
    matrix[1] = 2 * (q->x * q->y * q->z * q->w);
    matrix[2] = 2 * (q->x * q->z * q->y * q->w);
    matrix[3] = 0;

    //second column
    matrix[4] = 2 * (q->x * q->y - q->z * q->w);
    matrix[5] = 1 - 2 * (q->x * q->x + q->z * q->z);
    matrix[6] = 2 * (q->y * q->z + q->x * q->w);
    matrix[7] = 0;

    //third column
    matrix[8] = 2 * (q->x * q->z + q->y * q->w);
    matrix[9] = 2 * (q->y * q->z - q->x * q->w);
    matrix[10] = 1 - 2 * (q->x * q->x - q->y * q->y);
    matrix[11] = 0;

    //fourth column
    matrix[12] = 0;
    matrix[13] = 0;
    matrix[14] = 0;
    matrix[15] = 1;
}

void setupRC()
    {
    // Black background
    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);

    shaderManager.InitializeStockShaders();

    glEnable(GL_DEPTH_TEST);

    transformPipeline.SetMatrixStacks(modelViewMatrix, projectionMatrix);

    cameraFrame.MoveForward(-15.0f);
    cam_x -= 15.0f;
    cameraFrame.TranslateWorld(0.0f, 5.0f, 0.0f);
    cam_y += 5.0f;

    GLfloat cVerts[] = {

        //FRONT FACE
        0.0f, 0.0f, 0.0f, 
        1.0f, 0.0f, 0.0f,
        1.0f, 1.0f, 0.0f,
        0.0f, 1.0f, 0.0f,

        //BACK FACE
        0.0f, 0.0f, 1.0f, 
        0.0f, 1.0f, 1.0f,
        1.0f, 1.0f, 1.0f,
        1.0f, 0.0f, 1.0f,

        //LEFT FACE
        0.0f, 0.0f, 1.0f,
        0.0f, 0.0f, 0.0f,
        0.0f, 1.0f, 0.0f,
        0.0f, 1.0f, 1.0f,

        //RIGHT FACE
        1.0f, 0.0f, 0.0f,
        1.0f, 0.0f, 1.0f,
        1.0f, 1.0f, 1.0f,
        1.0f, 1.0f, 0.0f,

        //TOP FACE
        0.0f, 1.0f, 0.0f,
        1.0f, 1.0f, 0.0f,
        1.0f, 1.0f, 1.0f,
        0.0f, 1.0f, 1.0f,

        //BOTTOM FACE
        0.0f, 0.0f, 0.0f,
        0.0f, 0.0f, 1.0f,
        1.0f, 0.0f, 1.0f,
        1.0f, 0.0f, 0.0f
        };

    cubeBatch.Begin(GL_QUADS, 24);
    cubeBatch.CopyVertexData3f(cVerts);
    cubeBatch.End();

    for(int i=0; i < CUBE_COUNT; i++) {
        GLfloat x = (GLfloat)(i / int(sqrt(double(CUBE_COUNT))));
        GLfloat z = (GLfloat)(i % int(sqrt(double(CUBE_COUNT))));
        cubes[i].SetOrigin(x, 0.0f, z);
    }
}

void drawWireFramedBatch(GLBatch* pBatch) {
    //Draws the batch solid green
    shaderManager.UseStockShader(GLT_SHADER_FLAT, transformPipeline.GetModelViewProjectionMatrix(), vGreen);
    pBatch->Draw();

    //Draws the outline black
    glPolygonOffset(-1.0f, -1.0f);
    glEnable(GL_POLYGON_OFFSET_LINE);

    //Draws the lines antialiased
    glEnable(GL_LINE_SMOOTH);
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

    //Draws black wireframe version of geometry
    glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
    glLineWidth(1.0f);
    shaderManager.UseStockShader(GLT_SHADER_FLAT, transformPipeline.GetModelViewProjectionMatrix(), vBlack);
    pBatch->Draw();

    //Reset everything
    glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
    glDisable(GL_POLYGON_OFFSET_LINE);
    glLineWidth(1.0f);
    glDisable(GL_BLEND);
    glDisable(GL_LINE_SMOOTH);
}

///////////////////////////////////////////////////////////////////////////////
// Called to draw scene
void renderScene(void) {
    //Cubes are green
    static GLfloat vCubeColour[] = {0.0f, 1.0f, 0.0f, 1.0f};

    // Clear the window with current clearing color
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);

    //This pushes the identity matrix onto the matrix stack
    modelViewMatrix.PushMatrix();
    //printf("%i, %i, %i\n", cam_x, cam_y, cam_z);
    //cout << "PITCH: " << pitch << " YAW: " << yaw << " ROLL: " << roll << endl;

    float forwards = cam_x * cos(m3dDegToRad(yaw)) + cam_z * -sin(m3dDegToRad(yaw));
    float sideways = cam_x * sin(m3dDegToRad(yaw)) + cam_z * cos(m3dDegToRad(yaw));
    float upwards  = cam_x * sin(m3dDegToRad(pitch));

    //cameraFrame.MoveForward(forwards);
    //cameraFrame.MoveUp(upwards);
    //cameraFrame.MoveRight(sideways);

    //cameraFrame.RotateLocal(m3dDegToRad(yaw), 0.0f, 1.0f, 0.0f);
    //cameraFrame.RotateLocal(m3dDegToRad(-pitch), 1.0f, 0.0f, 0.0f);
    //cameraFrame.RotateLocal(m3dDegToRad(roll), 0.0f, 0.0f, 1.0f);

    //create matrix for camera
    M3DMatrix44f mCamera;
    cameraFrame.GetCameraMatrix(mCamera);

    modelViewMatrix.MultMatrix(mCamera);
    modelViewMatrix.MultMatrix(camMatrix);

    M3DVector4f vLightPos = {0.0f, 10.0f, 5.0f, 1.0f };
    M3DVector4f vLightEyePos;
    m3dTransformVector4(vLightEyePos, vLightPos, mCamera);

    //create matrix for object handling
    M3DMatrix44f mObjectFrame;
    objectFrame.GetMatrix(mObjectFrame);
    modelViewMatrix.MultMatrix(mObjectFrame);
    //use a basic stock shader - pass in modelview projection matrix
    //shaderManager.UseStockShader(GLT_SHADER_FLAT, transformPipeline.GetModelViewProjectionMatrix(), vBlack);

    for(int i=0; i < CUBE_COUNT; i++) {
        modelViewMatrix.PushMatrix();
        modelViewMatrix.MultMatrix(cubes[i]);
        drawWireFramedBatch(&cubeBatch);
        modelViewMatrix.PopMatrix();
    }

    modelViewMatrix.PopMatrix();
    // Perform the buffer swap to display back buffer
    glutSwapBuffers();
}

void resetCameraFrame() {
    cameraFrame = GLFrame();
    cameraFrame.MoveForward(-15.0f);
    cameraFrame.TranslateWorld(0.0f, 5.0f, 0.0f);
}

void getMouseCoords(int x, int y) {
    mouse_x = x;
    mouse_y = y;
}

void update(void) {
    float turn_angle = 0.005f;
    float move_speed = 0.5f;
    bool rotate = false;
    float rotation;

    //HANDLE CAMERA ROTATION

    yaw   += turn_angle * (WINDOW_WIDTH / 2 - mouse_x);
    pitch += turn_angle * (WINDOW_HEIGHT / 2 - mouse_y);

    pitch = pitch > 360 ? pitch - 360.0f : pitch;
    pitch = pitch < -360 ? pitch + 360.0f : pitch;
    yaw   = yaw > 360 ? yaw - 360.0f : yaw;
    yaw   = yaw < -360 ? yaw + 360.0f : yaw;
    roll  = roll > 360 ? roll - 360.0f : roll;
    roll  = roll < -360 ? roll + 360.0f : roll;

    Quaternion3D q = Quaternion3D();
    EulerToQuaternion3D(&q, pitch, yaw, roll);
    QuatToMatrix(camMatrix, &q);


    //cameraFrame.RotateWorld(m3dDegToRad(yaw), 0.0f, 1.0f, 0.0f);
    //cameraFrame.RotateWorld(m3dDegToRad(pitch), 1.0f, 0.0f, 0.0f);
    //cameraFrame.RotateWorld(m3dDegToRad(roll), 0.0f, 0.0f, 1.0f);

    //cout << "PITCH: " << pitch << " YAW: " << yaw << " ROLL: " << roll << endl;

    //resetCameraFrame();

    //HANDLE CAMERA POSITION
    if (w_pressed) { cameraFrame.MoveForward(move_speed);  cout << "FORWARD" << endl;  }
    if (a_pressed) { cameraFrame.MoveRight(move_speed);    cout << "LEFT" << endl;     }
    if (s_pressed) { cameraFrame.MoveForward(-move_speed); cout << "RIGHT" << endl;    }
    if (d_pressed) { cameraFrame.MoveRight(-move_speed);   cout << "BACKWARD" << endl; }
    /*
    if (w_pressed) { cam_x += move_speed; cout << "FORWARD" << endl;  }
    if (a_pressed) { cam_z += move_speed; cout << "LEFT" << endl;     }
    if (s_pressed) { cam_x -= move_speed; cout << "BACKWARD" << endl;    }
    if (d_pressed) { cam_z -= move_speed; cout << "RIGHT" << endl; }

    */
    glutPostRedisplay();
}

void specialKeyPress(int key, int x, int y) {
    float linear = 0.1f;
    float angular = float(m3dDegToRad(5.0f));

    if(key == GLUT_KEY_UP)
        cameraFrame.MoveForward(linear);

    if(key == GLUT_KEY_DOWN)
        cameraFrame.MoveForward(-linear);

    if(key == GLUT_KEY_LEFT)
        cameraFrame.RotateWorld(angular, 0.0f, 1.0f, 0.0f);

    if(key == GLUT_KEY_RIGHT)
        cameraFrame.RotateWorld(-angular, 0.0f, 1.0f, 0.0f);        
    }

void specialKeyRelease(int key, int x, int y) {
}

void normalKeyPress(unsigned char key, int x, int y) {

    printf ("The '%c' key was pressed\n", key);

    switch(key) {
        case 'w':
            w_pressed = true;
            break;
        case 'a':
            a_pressed = true;
            break;
        case 's':
            s_pressed = true;
            break;
        case 'd':
            d_pressed = true;
            break;
        case ESCAPE_KEY:
            exit(0);
            break;
    }
}

void normalKeyRelease(unsigned char key, int x, int y) {

    printf ("The '%c' key was released\n", key);

    switch(key) {
        case 'w':
            w_pressed = false;
            break;
        case 'a':
            a_pressed = false;
            break;
        case 's':
            s_pressed = false;
            break;
        case 'd':
            d_pressed = false;
            break;
    }
}

///////////////////////////////////////////////////////////////////////////////
// Window has changed size, or has just been created. In either case, we need
// to use the window dimensions to set the viewport and the projection matrix.
void changeSize(int w, int h) {
    glViewport(0, 0, w, h);
    viewFrustum.SetPerspective(35.0f, float(w) / float(h), 1.0f, 500.0f);
    projectionMatrix.LoadMatrix(viewFrustum.GetProjectionMatrix());
    transformPipeline.SetMatrixStacks(modelViewMatrix, projectionMatrix);
}

///////////////////////////////////////////////////////////////////////////////
// Main entry point for GLUT based programs
int main(int argc, char* argv[])
    {
    glutInit(&argc,argv);
    glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGBA|GLUT_DEPTH|GLUT_STENCIL);
    glutInitWindowSize(WINDOW_WIDTH, WINDOW_HEIGHT);
    glutCreateWindow("Cube");
    glutReshapeFunc(changeSize);
    glutKeyboardFunc(normalKeyPress);
    glutKeyboardUpFunc(normalKeyRelease);
    glutSpecialFunc(specialKeyPress);
    glutSpecialUpFunc(specialKeyRelease);
    glutPassiveMotionFunc(getMouseCoords);
    glutDisplayFunc(renderScene);
    glutIdleFunc(update);

    GLenum err = glewInit();

    if(GLEW_OK != err){
        fprintf(stderr, "GLEW Error: %s\n", glewGetErrorString(err));
        return 1;
    }

    setupRC();

    glutMainLoop();
    return 0;
}