0

我想知道如何在 OpenGL 中围绕其 Y 轴旋转 OpenGL 三角形，我已经能够将三角形从对象空间转换到剪辑空间。我想知道是否有人对这个问题有任何经验并且可以伸出援助之手。

主文件

#include <iostream>
#include <fstream>
#include <sstream>
#include <GL/glew.h>
#include <GL/freeglut.h>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <Windows.h>

using namespace std;
using namespace glm;

const int windowWidth = 1024; 
const int windowHeight = 768;

GLuint VBO;
const int NUMVERTS = 3;
GLuint gModelToWorldTransformLocation;
GLuint gWorldToViewTransformLocation;
GLuint gProjectionTransformLocation;
struct SimpleVertex
{
    vec3        pos;
    vec4        colour; 
};

static void renderSceneCallBack()
{
    static mat4 modelToWorldTransform = mat4(1.0f);
    static mat4 worldToViewTransform = lookAt(
        vec3(0.0f,0.0f,3.0f), // position of your camera, in world space
        vec3(0.0f,0.0f,0.0f), // look at in world space
        vec3(0.0f,1.0f,0.0f)  // Camera up direction (set to 0,-1,0 to look upside-down)
); 
    static mat4 projectionTransform = perspective(45.0f, (float)windowWidth / (float)windowHeight, 1.0f, 100.0f);
    glUniformMatrix4fv(gModelToWorldTransformLocation, 1, GL_FALSE, &modelToWorldTransform[0][0]);
    glUniformMatrix4fv(gWorldToViewTransformLocation, 1, GL_FALSE, &worldToViewTransform[0][0]);
    glUniformMatrix4fv(gProjectionTransformLocation, 1, GL_FALSE, &projectionTransform[0][0]);

    glClear(GL_COLOR_BUFFER_BIT);
    glEnableVertexAttribArray(0);
    glEnableVertexAttribArray(1);
    glBindBuffer(GL_ARRAY_BUFFER, VBO);

    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(SimpleVertex), 0);
    glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, sizeof(SimpleVertex), (const GLvoid*)12);
    glDrawArrays(GL_TRIANGLES, 0, NUMVERTS);
    glDisableVertexAttribArray(0);
    glDisableVertexAttribArray(1);
    glutSwapBuffers();
}

static void initializeGlutCallbacks()
{
    glutDisplayFunc(renderSceneCallBack);
    glutIdleFunc(renderSceneCallBack);
}

static void createVertexBuffer()
{
    // Create some vertices to put in our VBO.
    // Create vertex buffer
    SimpleVertex vertices[] =
    {
        {vec3(-0.5f, -0.5f, 0.0f), vec4(1.0f, 0.0f, 0.0f, 1.0f)},
        {vec3(0.5f, -0.5f, 0.0f),  vec4(0.0f, 1.0f, 0.0f, 1.0f)},
        {vec3( 0.0f, 0.5f, 0.0f),  vec4(0.0f, 0.0f, 1.0f, 1.0f)}
    };

    glGenBuffers(1, &VBO);
    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(SimpleVertex) * 3, vertices, GL_STATIC_DRAW);
}

static void addShader(GLuint shaderProgram, const char* pShaderText, GLenum shaderType)
{
    GLuint shaderObj = glCreateShader(shaderType);

    if (shaderObj == 0) 
    {
        cerr<<"Error creating shader type "<<shaderType<<endl;
        exit(0);
    }

    const GLchar* p[1];
    p[0] = pShaderText;
    GLint Lengths[1];
    Lengths[0]= strlen(pShaderText);
    glShaderSource(shaderObj, 1, p, Lengths);
    glCompileShader(shaderObj);
    GLint success;
    glGetShaderiv(shaderObj, GL_COMPILE_STATUS, &success);
    if (!success) 
    {
        GLchar InfoLog[1024];
        glGetShaderInfoLog(shaderObj, 1024, NULL, InfoLog);
        cerr<<"Error compiling shader type "<<shaderType<<": "<<InfoLog<<endl;
        exit(1);
    }

    glAttachShader(shaderProgram, shaderObj);
}

const string readFileToString(char* filename)
{
    ifstream file (filename, ios::in);
    if (file.is_open())
    {
        stringstream continut;
        continut << file.rdbuf();
        continut << '\0';
        return continut.str();
    }
    return "";
}

static void buildShaders()
{
    GLuint shaderProgram = glCreateProgram();

    if (shaderProgram == 0) 
    {
        cerr<<"Error creating shader program\n";
        exit(1);
    }

    string VS = readFileToString("vertexShader.glsl");
    string FS = readFileToString("fragmentShader.glsl");

    addShader(shaderProgram, VS.c_str(), GL_VERTEX_SHADER);
    addShader(shaderProgram, FS.c_str(), GL_FRAGMENT_SHADER);

    GLint success = 0;
    GLchar errorLog[1024] = { 0 };

    glLinkProgram(shaderProgram);
    glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
    if (success == 0) 
    {
        glGetProgramInfoLog(shaderProgram, sizeof(errorLog), NULL, errorLog);
        cerr<<"Error linking shader program: "<<errorLog<<endl;
        exit(1);
    }

    glValidateProgram(shaderProgram);
    glGetProgramiv(shaderProgram, GL_VALIDATE_STATUS, &success);
    if (!success) 
    {
        glGetProgramInfoLog(shaderProgram, sizeof(errorLog), NULL, errorLog);
        cerr<<"Error linking shader program: "<<errorLog<<endl;
        exit(1);
    }

    glUseProgram(shaderProgram);

    gModelToWorldTransformLocation = glGetUniformLocation(shaderProgram, "gModelToWorldTransform");
    //assert(gModelToWorldTransformLocation != 0xFFFFFFFF);
    gWorldToViewTransformLocation = glGetUniformLocation(shaderProgram, "gWorldToViewTransform");
    //assert(gWorldToViewTransformLocation != 0xFFFFFFFF);
    gProjectionTransformLocation = glGetUniformLocation(shaderProgram, "gProjectionTransform"); 
    //assert(gProjectionTransformLocation != 0xFFFFFFFF);

}

int main(int argc, char** argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGBA);
    glutInitWindowSize(windowWidth, windowHeight);
    glutInitWindowPosition(100, 100);
    glutCreateWindow("Transformations");

    initializeGlutCallbacks();

    // Must be done after glut is initialized!
    GLenum res = glewInit();
    if (res != GLEW_OK) 
    {
        cerr<<"Error: "<<glewGetErrorString(res)<<"\n";
        return 1;
    }

    buildShaders();

    glClearColor(0.0f, 0.0f, 0.0f, 0.0f); 

    // Create a vertex buffer
    createVertexBuffer();

    glutMainLoop();

    return 0;
}

顶点着色器

#version 330

layout (location = 0) in vec3 Position;
layout (location = 1) in vec4 Colour;

out vec4 Colour0;

uniform mat4 gModelToWorldTransform;
uniform mat4 gWorldToViewTransform;
uniform mat4 gProjectionTransform;

void main()
{  
    vec4 vertexPositionInModelSpace = vec4(Position, 1);
    vec4 vertexInWorldSpace = gModelToWorldTransform * vertexPositionInModelSpace;
    vec4 vertexInViewSpace = gWorldToViewTransform * vertexInWorldSpace;
    vec4 vertexInHomogeneousClipSpace = gProjectionTransform * vertexInViewSpace;
    gl_Position = vertexInHomogeneousClipSpace;
    Colour0 = Colour;
}

片段着色器

#version 330

in vec4 Colour0;

out vec4 FragColor;

void main()
{
    FragColor = Colour0;
}
4

1 回答 1

2

您可以有一个用于旋转的浮点变量，并从中创建一次旋转矩阵，然后将其存储。每一帧你都应该像这样更新世界矩阵： modelToWorldTransform = rotationTransform * modelToWorldTransform; 请参阅维基百科以创建围绕 y 的旋转矩阵：http ://en.wikipedia.org/wiki/Rotation_matrix#Basic_rotations

编辑：我想你在仿射变换方面遇到了麻烦。要在世界中移动（无论如何 - 平移、旋转）对象，您必须对其应用转换。目前，您正在应用一种转换，即平移到位置 0、0、3。到目前为止，一切都很好。但是你的三角形是静态的（它不会移动）。所以要旋转它，您需要应用另一个转换（再次由矩阵表示）。但是，如果您始终应用一个相同的旋转，三角形将针对其原始变换进行旋转，但它不会再次移动。因此，您需要每帧应用一次旋转，将结果存储在 modeltoworldtransform 中，然后在下一帧重复该步骤。例如在 renderCallback 中：

static mat4 modelToWorldTransform = mat4(1.0f);
static mat4 rotationTransform = <rotation by the described in wiki way>;

modelToWorldTransform = rotationTransform * modelToWorldTransform;

此外，矩阵相乘的顺序很重要，因为它们的乘法（我们用来从对象空间到相机空间的变换）不是可交换的，并且 A * B 与 B * A 不同。我强烈建议您阅读更多关于线性代数及其将帮助您了解“幕后”发生的事情。许多关于游戏开发者图形的书籍都以非常好的和易于理解的方式解释了它。Eric Lengyel 的“用于 3D 游戏编程和计算机图形学的数学”非常出色。当我在大学学习数学时，它甚至对我有所帮助；）。

于 2013-10-16T15:58:21.597 回答