Question

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

Main.cpp的

#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;
}

VertexShader

#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;
}

FragmentShader

#version 330

in vec4 Colour0;

out vec4 FragColor;

void main()
{
    FragColor = Colour0;
}

Answer 1

您可以使用浮动变量进行旋转，然后从中创建旋转矩阵，然后存储它。每个帧都应该像这样更新世界矩阵：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游戏编程和计算机图形学数学”踢了屁股。当我在大学学习数学时，它甚至帮助了我;）。

在OpenGl中创建一个围绕它的y轴连续旋转的三角形

1 个答案: