OpenGL.Tutorial03_Matrices_测试

时间：2024-09-19 21:03:20

1、

2、

// ZC: 工程-->右键-->属性--> 配置属性：

// ZC:    C/C++ -->常规-->附加包含目录，里面添加：

// ZC:        E:\OpenGL_something\glfw-3.2.1.bin.WIN32\include

// ZC:        E:\OpenGL_something\glm-0.9.8.5

// ZC:        E:\OpenGL_something\glew-2.1.0\include

// ZC:    链接器-->输入-->附加依赖项，里面添加：

// ZC:        E:\OpenGL_something\glfw-3.2.1.bin.WIN32\lib-vc2010\glfw3.lib        这个应该是静态链接的lib(动态的貌似是glfw3dll.lib[ZC：我是看文件大小判断的...])

// ZC:        E:\OpenGL_something\glew-2.1.0\lib\Release\Win32\glew32.lib

// ZC:        opengl32.lib

// ZC:        glu32.lib

// ZC:        kernel32.lib

// ZC:        user32.lib

// ZC:        gdi32.lib

// ZC:        winspool.lib

// ZC:        shell32.lib

// ZC:        ole32.lib

// ZC:        oleaut32.lib

// ZC:        uuid.lib

// ZC:        comdlg32.lib

// ZC:        advapi32.lib

// ZC: 关于使用glew32.lib还是glew32s.lib:

// ZC:    看文件大小判断 静态链接的lib应该是glew32s.lib，但是我在编译的时候，发现无法定位函数grewInit(...)... 于是只能使用动态的glew32s.lib

// ZC:    于是还要将"E:\OpenGL_something\glew-2.1.0\bin\Release\Win32\glew32.dll"复制到项目的"E:\Project_VS10\OpenGL_Console_zz\Test\Test"中

// Include standard headers

#include <stdio.h>

#include <stdlib.h>

// Include GLEW

#include <GL/glew.h>

// Include GLFW

#include <GLFW/glfw3.h>

extern GLFWwindow* window;

// Include GLM

#include <glm/glm.hpp>

#include <glm/gtc/matrix_transform.hpp>

using namespace glm;

#include <common/shader.hpp>

int mainTutorial03Matrices( void )

{

    // Initialise GLFW

    if( !glfwInit() )

    {

        fprintf( stderr, "Failed to initialize GLFW\n" );

        getchar();

        return -;

    }

    glfwWindowHint(GLFW_SAMPLES, );

    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, );

    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, );

    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); // To make MacOS happy; should not be needed

    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); //We don't want the old OpenGL 

    // Open a window and create its OpenGL context

    /*window = glfwCreateWindow( 1024, 768, "Tutorial 03 - Matrices", NULL, NULL);*/

    window = glfwCreateWindow( , , "Tutorial 03 - Matrices", NULL, NULL);

    if( window == NULL ){

        fprintf( stderr, "Failed to open GLFW window. If you have an Intel GPU, they are not 3.3 compatible. Try the 2.1 version of the tutorials.\n" );

        getchar();

        glfwTerminate();

        return -;

    }

    glfwMakeContextCurrent(window);

    // Initialize GLEW

    glewExperimental = true; // Needed for core profile

    if (glewInit() != GLEW_OK) {

        fprintf(stderr, "Failed to initialize GLEW\n");

        getchar();

        glfwTerminate();

        return -;

    }

    // Ensure we can capture the escape key being pressed below

    glfwSetInputMode(window, GLFW_STICKY_KEYS, GL_TRUE);

    // Dark blue background

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

    GLuint VertexArrayID;

    glGenVertexArrays(, &VertexArrayID);

    glBindVertexArray(VertexArrayID);

    // Create and compile our GLSL program from the shaders

    GLuint programID = LoadShaders( "../Test/shaders/SimpleTransform_03.vertexshader", "../Test/shaders/SingleColor_03.fragmentshader" );

    // Get a handle for our "MVP" uniform

    GLuint MatrixID = glGetUniformLocation(programID, "MVP");

    // Projection matrix : 45?Field of View, 4:3 ratio, display range : 0.1 unit <-> 100 units

    //glm::mat4 Projection = glm::perspective(glm::radians(45.0f), 4.0f / 3.0f, 0.1f, 100.0f);

    glm::mat4 Projection = glm::perspective(glm::radians(45.0f), 4.0f / 3.0f, 0.1f, 100.0f);

    // Or, for an ortho camera :

    //glm::mat4 Projection = glm::ortho(-10.0f, 10.0f, -10.0f, 10.0f, 0.0f, 100.0f); // In world coordinates

    // Camera matrix

    //glm::mat4 View       = glm::lookAt(

    //                            glm::vec3(4,3,3), // Camera is at (4,3,3), in World Space

    //                            glm::vec3(0,0,0), // and looks at the origin

    //                            glm::vec3(0,1,0)  // Head is up (set to 0,-1,0 to look upside-down)

    //                       );

    glm::mat4 View       = glm::lookAt(

        glm::vec3(,,),// Camera is at (4,3,3), in World Space

        glm::vec3(,,), // and looks at the origin

        glm::vec3(,,)  // Head is up (set to 0,-1,0 to look upside-down)

        );

    // ZC: 上面的参数的理解：

    // ZC:    第一个参数：摄像机所在的位置(世界坐标系)

    // ZC:    第二个参数：摄像机往哪个点看过去（摄像机往哪个点的方向看去）        (ZC: 这个应该是参与计算的)

    // ZC:    第三个参数：头的位置（这里的"头" 实际就是指"摄像机"）：            (ZC: 这个稍微测试了一下，发现 应该就是指方向[即 其次坐标的"w"是0])

    // ZC:        (0,1,0):就是正常的人类头顶朝上的样子，

    // ZC:        (1,0,0):就是头往X轴正方向倒90°，

    // ZC:        (0,0,1):应该就是头朝Z轴正方向倒90°(也就是往后倒，稍微验证了一下，应该就是这样子的)

    // Model matrix : an identity matrix (model will be at the origin)

    glm::mat4 Model      = glm::mat4(1.0f);

    //glm::mat4 Model      = glm::mat4(

    //    2.0f, 0.0f, 0.0f, 0.0f,

    //    0.0f, 2.0f, 0.0f, 0.0f,

    //    0.0f, 0.0f, 2.0f, 0.0f,

    //    0.0f, 0.0f, 0.0f, 1.0f);

    printf("%f, %f, %f, %f\n", Model[].x, Model[].y, Model[].z, Model[].w);

    printf("%f, %f, %f, %f\n", Model[].x, Model[].y, Model[].z, Model[].w);

    printf("%f, %f, %f, %f\n", Model[].x, Model[].y, Model[].z, Model[].w);

    printf("%f, %f, %f, %f\n", Model[].x, Model[].y, Model[].z, Model[].w);

    printf("\n");

    // Our ModelViewProjection : multiplication of our 3 matrices

    glm::mat4 MVP        = Projection * View * Model; // Remember, matrix multiplication is the other way around

    printf("%f, %f, %f, %f\n", MVP[].x, MVP[].y, MVP[].z, MVP[].w);

    printf("%f, %f, %f, %f\n", MVP[].x, MVP[].y, MVP[].z, MVP[].w);

    printf("%f, %f, %f, %f\n", MVP[].x, MVP[].y, MVP[].z, MVP[].w);

    printf("%f, %f, %f, %f\n", MVP[].x, MVP[].y, MVP[].z, MVP[].w);

    printf("\n");

    static const GLfloat g_vertex_buffer_data[] = {

        -1.0f, -1.0f, 0.0f,

        1.0f, -1.0f, 0.0f,

        0.0f,  1.0f, 0.0f,

    };

    //static const GLfloat g_vertex_buffer_data[] = {

    //    -2.0f, -2.0f, 0.0f,

    //    2.0f, -2.0f, 0.0f,

    //    0.0f,  2.0f, 0.0f,

    //};

    GLuint vertexbuffer;

    glGenBuffers(, &vertexbuffer);

    glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);

    glBufferData(GL_ARRAY_BUFFER, sizeof(g_vertex_buffer_data), g_vertex_buffer_data, GL_STATIC_DRAW);

    do{

        // Clear the screen

        glClear( GL_COLOR_BUFFER_BIT );

        // Use our shader

        glUseProgram(programID);

        // Send our transformation to the currently bound shader,

        // in the "MVP" uniform

        glUniformMatrix4fv(MatrixID, , GL_FALSE, &MVP[][]);

        // 1rst attribute buffer : vertices

        glEnableVertexAttribArray();

        glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);

        glVertexAttribPointer(

            ,                  // attribute. No particular reason for 0, but must match the layout in the shader.

            ,                  // size

            GL_FLOAT,           // type

            GL_FALSE,           // normalized?

            ,                  // stride

            (void*)            // array buffer offset

            );

        // Draw the triangle !

        glDrawArrays(GL_TRIANGLES, , ); // 3 indices starting at 0 -> 1 triangle

        glDisableVertexAttribArray();

        // Swap buffers

        glfwSwapBuffers(window);

        glfwPollEvents();

    } // Check if the ESC key was pressed or the window was closed

    while( glfwGetKey(window, GLFW_KEY_ESCAPE ) != GLFW_PRESS &&

        glfwWindowShouldClose(window) ==  );

    // Cleanup VBO and shader

    glDeleteBuffers(, &vertexbuffer);

    glDeleteProgram(programID);

    glDeleteVertexArrays(, &VertexArrayID);

    // Close OpenGL window and terminate GLFW

    glfwTerminate();

    return ;

}

3、改变中间的一段代码 用于测试：

　3.1、上面的代码执行的现象：

　　OpenGL.Tutorial03_Matrices_测试

　3.2、放大2倍（方式1）：

    // Model matrix : an identity matrix (model will be at the origin)

    //glm::mat4 Model      = glm::mat4(1.0f);　　// ZC: 变化的是这里，把X/Y/Z坐标都扩大了2倍

    glm::mat4 Model      = glm::mat4(

        2.0f, 0.0f, 0.0f, 0.0f,

        0.0f, 2.0f, 0.0f, 0.0f,

        0.0f, 0.0f, 2.0f, 0.0f,

        0.0f, 0.0f, 0.0f, 1.0f);

    printf("%f, %f, %f, %f\n", Model[].x, Model[].y, Model[].z, Model[].w);

    printf("%f, %f, %f, %f\n", Model[].x, Model[].y, Model[].z, Model[].w);

    printf("%f, %f, %f, %f\n", Model[].x, Model[].y, Model[].z, Model[].w);

    printf("%f, %f, %f, %f\n", Model[].x, Model[].y, Model[].z, Model[].w);

    printf("\n");

    // Our ModelViewProjection : multiplication of our 3 matrices

    glm::mat4 MVP        = Projection * View * Model; // Remember, matrix multiplication is the other way around

    printf("%f, %f, %f, %f\n", MVP[].x, MVP[].y, MVP[].z, MVP[].w);

    printf("%f, %f, %f, %f\n", MVP[].x, MVP[].y, MVP[].z, MVP[].w);

    printf("%f, %f, %f, %f\n", MVP[].x, MVP[].y, MVP[].z, MVP[].w);

    printf("%f, %f, %f, %f\n", MVP[].x, MVP[].y, MVP[].z, MVP[].w);

    printf("\n");

    static const GLfloat g_vertex_buffer_data[] = {

        -1.0f, -1.0f, 0.0f,

        1.0f, -1.0f, 0.0f,

        0.0f,  1.0f, 0.0f,

    };

　现象：

　　OpenGL.Tutorial03_Matrices_测试

　3.3、放大2倍（方式2）：

    // Model matrix : an identity matrix (model will be at the origin)

    glm::mat4 Model      = glm::mat4(1.0f);　　// ZC: 这里没改变

    //glm::mat4 Model      = glm::mat4(

    //    2.0f, 0.0f, 0.0f, 0.0f,

    //    0.0f, 2.0f, 0.0f, 0.0f,

    //    0.0f, 0.0f, 2.0f, 0.0f,

    //    0.0f, 0.0f, 0.0f, 1.0f);

    printf("%f, %f, %f, %f\n", Model[].x, Model[].y, Model[].z, Model[].w);

    printf("%f, %f, %f, %f\n", Model[].x, Model[].y, Model[].z, Model[].w);

    printf("%f, %f, %f, %f\n", Model[].x, Model[].y, Model[].z, Model[].w);

    printf("%f, %f, %f, %f\n", Model[].x, Model[].y, Model[].z, Model[].w);

    printf("\n");

    // Our ModelViewProjection : multiplication of our 3 matrices

    glm::mat4 MVP        = Projection * View * Model; // Remember, matrix multiplication is the other way around

    printf("%f, %f, %f, %f\n", MVP[].x, MVP[].y, MVP[].z, MVP[].w);

    printf("%f, %f, %f, %f\n", MVP[].x, MVP[].y, MVP[].z, MVP[].w);

    printf("%f, %f, %f, %f\n", MVP[].x, MVP[].y, MVP[].z, MVP[].w);

    printf("%f, %f, %f, %f\n", MVP[].x, MVP[].y, MVP[].z, MVP[].w);

    printf("\n");//static const GLfloat g_vertex_buffer_data[] = {

    //    -1.0f, -1.0f, 0.0f,

    //    1.0f, -1.0f, 0.0f,

    //    0.0f,  1.0f, 0.0f,

    //};

    static const GLfloat g_vertex_buffer_data[] = { // ZC: 这里改变了，手动的将 三角形的3个点的坐标放大了

        -2.0f, -2.0f, 0.0f,

        2.0f, -2.0f, 0.0f,

        0.0f,  2.0f, 0.0f,

    };

　现象：

　　OpenGL.Tutorial03_Matrices_测试

　3.4、测试：刚开始 放大 是使用的 “glm::mat4 Model = glm::mat4(2.0f);”，实际这是没有 放大效果的（视觉上 大小没变化），原因寻找：Model的矩阵信息为：

　　2.0f  0.0f  0.0f  0.0f

　　0.0f  2.0f  0.0f  0.0f

　　0.0f  0.0f  2.0f  0.0f

　　0.0f  0.0f  0.0f  2.0f

　　∵ 它把 X/Y/Z轴的数据放大了，但是 它的最后一行数据“0.0f 0.0f 0.0f 2.0f” 实现了类似这样的功能：把摄像机拉远了一倍距离。这个的数学解释 我暂时还不太明白，只是做了一个实验 验证了一下

　　3.4.1、

    glm::mat4 View       = glm::lookAt(

        glm::vec3(,,),// Camera is at (4,3,3), in World Space

        glm::vec3(,,), // and looks at the origin

        glm::vec3(,,)  // Head is up (set to 0,-1,0 to look upside-down)

        );

    // Model matrix : an identity matrix (model will be at the origin)

    //glm::mat4 Model      = glm::mat4(1.0f);

    glm::mat4 Model      = glm::mat4(2.0f);　　// ZC: 改了这里

    //glm::mat4 Model      = glm::mat4(

    //    2.0f, 0.0f, 0.0f, 0.0f,

    //    0.0f, 2.0f, 0.0f, 0.0f,

    //    0.0f, 0.0f, 2.0f, 0.0f,

    //    0.0f, 0.0f, 0.0f, 1.0f);

    printf("%f, %f, %f, %f\n", Model[].x, Model[].y, Model[].z, Model[].w);

    printf("%f, %f, %f, %f\n", Model[].x, Model[].y, Model[].z, Model[].w);

    printf("%f, %f, %f, %f\n", Model[].x, Model[].y, Model[].z, Model[].w);

    printf("%f, %f, %f, %f\n", Model[].x, Model[].y, Model[].z, Model[].w);

    printf("\n");

    // Our ModelViewProjection : multiplication of our 3 matrices

    glm::mat4 MVP        = Projection * View * Model; // Remember, matrix multiplication is the other way around

    printf("%f, %f, %f, %f\n", MVP[].x, MVP[].y, MVP[].z, MVP[].w);

    printf("%f, %f, %f, %f\n", MVP[].x, MVP[].y, MVP[].z, MVP[].w);

    printf("%f, %f, %f, %f\n", MVP[].x, MVP[].y, MVP[].z, MVP[].w);

    printf("%f, %f, %f, %f\n", MVP[].x, MVP[].y, MVP[].z, MVP[].w);

    printf("\n");

　　　现象：

　　OpenGL.Tutorial03_Matrices_测试

　　3.4.2、

    glm::mat4 View       = glm::lookAt(

        glm::vec3(,,),// ZC: 这里，手动将摄像机 拉远了一倍距离

        glm::vec3(,,), // and looks at the origin

        glm::vec3(,,)  // Head is up (set to 0,-1,0 to look upside-down)

        );

    // Model matrix : an identity matrix (model will be at the origin)

    //glm::mat4 Model      = glm::mat4(1.0f);

    //glm::mat4 Model      = glm::mat4(2.0f);

    glm::mat4 Model      = glm::mat4(　　// ZC: 这里，将 X/Y/Z轴数据放大1倍

        2.0f, 0.0f, 0.0f, 0.0f,

        0.0f, 2.0f, 0.0f, 0.0f,

        0.0f, 0.0f, 2.0f, 0.0f,

        0.0f, 0.0f, 0.0f, 1.0f);

    printf("%f, %f, %f, %f\n", Model[].x, Model[].y, Model[].z, Model[].w);

    printf("%f, %f, %f, %f\n", Model[].x, Model[].y, Model[].z, Model[].w);

    printf("%f, %f, %f, %f\n", Model[].x, Model[].y, Model[].z, Model[].w);

    printf("%f, %f, %f, %f\n", Model[].x, Model[].y, Model[].z, Model[].w);

    printf("\n");

    // Our ModelViewProjection : multiplication of our 3 matrices

    glm::mat4 MVP        = Projection * View * Model; // Remember, matrix multiplication is the other way around

    printf("%f, %f, %f, %f\n", MVP[].x, MVP[].y, MVP[].z, MVP[].w);

    printf("%f, %f, %f, %f\n", MVP[].x, MVP[].y, MVP[].z, MVP[].w);

    printf("%f, %f, %f, %f\n", MVP[].x, MVP[].y, MVP[].z, MVP[].w);

    printf("%f, %f, %f, %f\n", MVP[].x, MVP[].y, MVP[].z, MVP[].w);

    printf("\n");

　　现象：

　　OpenGL.Tutorial03_Matrices_测试

　　ZC：可以看到，虽然 矩阵Model 的信息不同，但是 最后的 矩阵MVP 的信息是一样的，∴ 肉眼看起来 效果一样...

4、尝试 C++中计算好位置，直接传入 GLSL（不要再在 GLSL中去做乘法计算）

　　ZC：貌似 这个例子中使用的 "glDrawArrays(GL_TRIANGLES, 0, 3);"的方式，暂时不支持实现 这个尝试，看后面会不会 学习到别的方式，或者 后面水平高了再来尝试吧...

5、

相关文章