Opengl+VS2022实现绘制简易时钟【含源码】

【实验目的】

• 1. 熟悉OpenGL的应用工具包GLUT的安装和使用。 •

 2. 掌握基本的OpenGL编程方法。 •

 3. 掌握显示窗口的显示方法。

• 4. 掌握基本交互式程序的编程方法。

 • 5. 掌握基本动画程序的编程方法。

【实验内容】

1. 在窗口中绘制一个矩形 分别实现键盘和鼠标对矩形的控制，例如：拖动，缩放。并加入菜单进行 属性操作

初始化创口大小为800*800个像素，结果如图

注册回调函数

可以将窗口任意拖拉，重新绘图

利用glfw封装的库可以响应ESC键退出

实验二： 1. 编写一个时钟绘制功能, 回答下面的问题：

glFlush()函数和glClear(GL_COLOR_BUFFER_BIT)函数的作用分别是什么？ （可将这两个函数注释掉，和注释前的结果对比）

a. 尝试直线圆环的绘制

在圆环的绘制过程中我想到了用多边形取近似一个圆，刚开始我只想到了绘制一个正15变形

然后让边数=300，便绘制出了简易圆环：

 b. 尝试旋转与移动等功能

然后是使用opengl封装的

实现旋转矩阵的生成，因为此次实验是在二维作图，因此我将旋转轴设为（0，0，1）Z轴

为了实现时间的同步，我设置了

vect.push_back(glm::vec2(0.35 * cos((3.1415 / 2.0)-((timeNow.wMinute * 60 + timeNow.wSecond) / 3600.0 * 360 * 3.1415 / 180.0)), 0.35* sin((3.1415 / 2.0)-((timeNow.wMinute * 60 + timeNow.wSecond) / 3600.0 * 360 * 3.1415 / 180.0) )));

来将显示时间同步到程序中，我在设计这一步时，巧妙地发现我们要显示的结果与世界坐标系之间刚好是互余的关系因此我在每一步的都会加上3.1415 / 2.0)-。

为了让时钟动起来上述设置的角度需要在循环里不断变化因此

只要加上window.h文件的这个函数通过变量timeNow不断获取当前时间即可

#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include<glm/glm.hpp>
#include<glm/gtc/matrix_transform.hpp>
#include<glm/gtc/type_ptr.hpp>
#include <iostream>
#include<vector>
#include<math.h>
#include <windows.h>
void framebuffer_size_callback(GLFWwindow* window, int width, int height);
void processInput(GLFWwindow* window);

// settings
const unsigned int SCR_WIDTH = 800;
const unsigned int SCR_HEIGHT = 800;

struct Vertex {
    glm::vec2 position;
};

const char* vertexShaderSource = "#version 430 core\n"      //顶点着色器
"layout (location = 0) in vec3 aPos;\n"
"void main()\n"
"{\n"
"   gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0);\n"
"}\0";
const char* fragmentShaderSource = "#version 430 core\n"   //片元着色器
"out vec4 FragColor;\n"
"void main()\n"
"{\n"
"   FragColor = vec4(1.0f, 0.9f, 0.2f, 1.0f);\n"
"}\n\0";

/*const char* vertexShaderSource_clock = "#version 430 core\n"      //顶点着色器
"layout (location = 0) in vec3 aPos;\n"
"uniform float t; \n"
"uniform float R; \n"
"void main()\n"
"{\n"
"   gl_Position = vec4(R * cos(t), R * sin(t), 0.0, 1.0);\n"
"}\0";
*/
//"   gl_Position =  vec4((abs(aPos.x+t))%1-1, (abs(aPos.y+t))%1-1,0, 1.0);\n"
const char* vertexShaderSource_clock = "#version 430 core\n"      //顶点着色器
"layout (location = 0) in vec3 aPos;\n"
"uniform float R; \n"
"void main()\n"
"{\n"
"   gl_Position =  vec4(aPos.x, aPos.y,aPos.z, 1.0);\n"
"}\0";
const char* vertexShaderSource_clock_point = "#version 430 core\n"      //顶点着色器
"layout (location = 0) in vec3 aPos;\n"
"uniform mat4 trans; \n"
"uniform float R; \n"
"void main()\n"
"{\n"
"   gl_Position =trans*  vec4(aPos.x, aPos.y,aPos.z, 1.0);\n"
"}\0";



int main()
{
    // glfw: initialize and configure
    // ------------------------------
    glfwInit();
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

#ifdef __APPLE__
    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
#endif

    // glfw window creation
    // --------------------
    GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "OpenGL_homework_01", NULL, NULL);
    if (window == NULL)
    {
        std::cout << "Failed to create GLFW window" << std::endl;
        glfwTerminate();
        return -1;
    }
    glfwMakeContextCurrent(window);
    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);

    // glad: load all OpenGL function pointers
    // ---------------------------------------
    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
    {
        std::cout << "初始化GLAD失败" << std::endl;
        return -1;
    }


    // build and compile our shader program
    // ------------------------------------
    // vertex shader
    unsigned int vertexShader = glCreateShader(GL_VERTEX_SHADER);  //创建着色器vertexShader
    glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);
    glCompileShader(vertexShader);
    unsigned int vertexShader2 = glCreateShader(GL_VERTEX_SHADER);  //创建着色器vertexShader
    glShaderSource(vertexShader2, 1, &vertexShaderSource_clock, NULL);
    glCompileShader(vertexShader2);
    unsigned int vertexShader3 = glCreateShader(GL_VERTEX_SHADER);  //创建着色器vertexShader
    glShaderSource(vertexShader3, 1, &vertexShaderSource_clock_point, NULL);
    glCompileShader(vertexShader3);
    // check for shader compile errors
    int success;
    char infoLog[512];
    glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);  //检查着色器的编译状态
    if (!success)
    {
        glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);
        std::cout << "ERROR::SHADER::VERTEX::COMPILATION_FAILED\n" << infoLog << std::endl;
    }
    // fragment shader（点着色器）
    unsigned int fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
    glCompileShader(fragmentShader);

    unsigned int fragmentShader2 = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragmentShader2, 1, &fragmentShaderSource, NULL);
    glCompileShader(fragmentShader2);


    // check for shader compile errors
    glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
    if (!success)
    {
        glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);
        std::cout << "ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n" << infoLog << std::endl;
    }
    // link shaders （片元着色器）
    unsigned int shaderProgram = glCreateProgram();
    glAttachShader(shaderProgram, vertexShader);
    glAttachShader(shaderProgram, fragmentShader);//装载着色器
    glLinkProgram(shaderProgram);

    unsigned int shaderProgram2 = glCreateProgram();
    glAttachShader(shaderProgram2, vertexShader2);
    glAttachShader(shaderProgram2, fragmentShader2);//装载着色器
    glLinkProgram(shaderProgram2);

    unsigned int shaderProgram3 = glCreateProgram();
    glAttachShader(shaderProgram3, vertexShader3);
    glAttachShader(shaderProgram3, fragmentShader2);//装载着色器
    glLinkProgram(shaderProgram3);

    unsigned int shaderProgram4 = glCreateProgram();
    glAttachShader(shaderProgram4, vertexShader3);
    glAttachShader(shaderProgram4, fragmentShader2);//装载着色器
    glLinkProgram(shaderProgram4);
    // check for linking errors
    glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);  //检查着色器的链接状态
    if (!success) {
        glGetProgramInfoLog(shaderProgram, 512, NULL, infoLog);
        std::cout << "ERROR::SHADER::PROGRAM::LINKING_FAILED\n" << infoLog << std::endl;
    }
    glDeleteShader(vertexShader);
    glDeleteShader(vertexShader2);
    glDeleteShader(vertexShader3);
    glDeleteShader(fragmentShader);
    glDeleteShader(fragmentShader2);
    // set up vertex data (and buffer(s)) and configure vertex attributes
    // ------------------------------------------------------------------
    float vertices[] = {
         0.5f,  0.5f, 0.0f,  // 右上
         0.5f, -0.5f, 0.0f,  // 右下
        -0.5f, -0.5f, 0.0f,  // 左下
        -0.5f,  0.5f, 0.0f   // 左上
    };
    unsigned int indices[] = {  // note that we start from 0!
        0, 1, 3,  // first Triangle
        1, 2, 3   // second Triangle
    };

    //clock


    std::vector<glm::vec2> vert, vect;

    // 在你的初始化代码中准备顶点数据
    double twopi = 6.28318;
    int r = 40;

    // 计算线段的顶点
    double t = twopi / 12.1;
    Vertex start = { glm::vec2(300, 250) };
    Vertex end = { glm::vec2(300 + (r - 40) * cos(t), 250 + (r - 40) * sin(t)) };

    /* {
          vert.push_back((glm::vec2(0.25, 0.5)));//右上
          vert.push_back((glm::vec2(0.5, 0)));//右中
          vert.push_back((glm::vec2(0.5, 0)));//右中
          vert.push_back((glm::vec2(0.25, -0.5)));//右下
          vert.push_back((glm::vec2(0.25, -0.5)));//右下
          vert.push_back((glm::vec2(-0.25, -0.5)));//左下
          vert.push_back((glm::vec2(-0.25, -0.5)));//左下
          vert.push_back((glm::vec2(-0.5, 0)));//左中
          vert.push_back((glm::vec2(-0.5, 0)));//左中
          vert.push_back((glm::vec2(-0.25, 0.5)));//左上
          vert.push_back((glm::vec2(-0.25, 0.5)));//左上
          vert.push_back((glm::vec2(0.25, 0.5)));//右上

      }*/
    {
        int numSegments = 300;
        float M_PI = 3.1415;
        float centerX = 0.0, centerY = 0.0, radius = 0.75;
        glm::vec2 temp;
        SYSTEMTIME timeNow;
        GetLocalTime(&timeNow);
        vect.push_back(glm::vec2(0, 0));
        vect.push_back(glm::vec2(0.55 * cos((3.1415 / 2.0) - (360 / 60.0 * timeNow.wSecond * 3.1415 / 180.0)), 0.55 * sin((3.1415 / 2.0) - (360 / 60.0 * timeNow.wSecond * 3.1415 / 180.0))));
        vect.push_back(glm::vec2(0, 0));
        vect.push_back(glm::vec2(0.35 * cos((3.1415 / 2.0) - ((timeNow.wMinute * 60 + timeNow.wSecond) / 3600.0 * 360 * 3.1415 / 180.0)), 0.35 * sin((3.1415 / 2.0) - ((timeNow.wMinute * 60 + timeNow.wSecond) / 3600.0 * 360 * 3.1415 / 180.0))));
        //std::cout << (timeNow.wMinute * 60 + timeNow.wSecond) / 3600.0 * 360*3.1415/180.0<< "  " <<float((timeNow.wMinute * 60 + timeNow.wSecond) / 3600.0 * 360 * 3.1415 / 180.0)<<" " <<timeNow.wMinute <<" " << timeNow.wSecond << std::endl;
        //std::cout << "timeNow.wMinute=" << timeNow.wMinute << "timeNow.wSecond=" << timeNow.wSecond << "(timeNow.wMinute * 60 + timeNow.wSecond) =" << (timeNow.wMinute * 60 + timeNow.wSecond) << "(timeNow.wMinute * 60 + timeNow.wSecond) / 3600.0 * 360 * 3.1415 / 180.0=" << (timeNow.wMinute * 60 + timeNow.wSecond) / 3600.0 * 360 * 3.1415 / 180.0;
        for (int i = 0; i <= numSegments; i++) {
            float angle = 2.0f * M_PI * (float)i / (float)numSegments; // Angle between segments
            float x = radius * cos(angle) + centerX; // Calculate x position
            float y = radius * sin(angle) + centerY; // Calculate y position
            vert.push_back((glm::vec2(x, y))); // Draw vertex
            if (i == 0)
            {
                temp = glm::vec2(x, y);
                continue;
            }
            vert.push_back((glm::vec2(x, y)));
            if (i == numSegments)
            {
                vert.push_back(temp);
            }
        }

    }
    //vert.push_back(Vertex(start));
   // vert.push_back(Vertex(end));


    unsigned int VBOs[4], VAOs[4], EBO;
    glGenVertexArrays(1, &VAOs[0]);  //绑定VAO
    glGenBuffers(1, &VBOs[0]);  //绑定VBO
    glGenBuffers(1, &EBO);  //绑定EBO索引数组
    // bind the Vertex Array Object first, then bind and set vertex buffer(s), and then configure vertex attributes(s).
    glBindVertexArray(VAOs[0]);

    glBindBuffer(GL_ARRAY_BUFFER, VBOs[0]);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);


    glEnableVertexAttribArray(0);

    // note that this is allowed, the call to glVertexAttribPointer registered VBO as the vertex attribute's bound vertex buffer object so afterwards we can safely unbind
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    // remember: do NOT unbind the EBO while a VAO is active as the bound element buffer object IS stored in the VAO; keep the EBO bound.
    //glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
    // You can unbind the VAO afterwards so other VAO calls won't accidentally modify this VAO, but this rarely happens. Modifying other
    // VAOs requires a call to glBindVertexArray anyways so we generally don't unbind VAOs (nor VBOs) when it's not directly necessary.
    glBindVertexArray(0);  //解绑VAO

    glGenVertexArrays(1, &VAOs[1]);  //绑定VAO
    glGenBuffers(1, &VBOs[1]);  //绑定VBO

    glBindVertexArray(VAOs[1]);

    glBindBuffer(GL_ARRAY_BUFFER, VBOs[1]);
    glBufferData(GL_ARRAY_BUFFER, vert.size() * sizeof(Vertex), vert.data(), GL_STATIC_DRAW);
    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)0);
    glEnableVertexAttribArray(0);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glBindVertexArray(0);

    glGenVertexArrays(1, &VAOs[2]);  //绑定VAO
    glGenBuffers(1, &VBOs[2]);  //绑定VBO

    glBindVertexArray(VAOs[2]);

    glBindBuffer(GL_ARRAY_BUFFER, VBOs[2]);
    glBufferData(GL_ARRAY_BUFFER, vect.size() * sizeof(Vertex), vect.data(), GL_STATIC_DRAW);
    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (GLvoid*)0);
    glEnableVertexAttribArray(0);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glBindVertexArray(0);

    glGenVertexArrays(1, &VAOs[3]);  //绑定VAO
    glGenBuffers(1, &VBOs[3]);  //绑定VBO

    glBindVertexArray(VAOs[3]);

    glBindBuffer(GL_ARRAY_BUFFER, VBOs[3]);
    glBufferData(GL_ARRAY_BUFFER, vect.size() * sizeof(Vertex), vect.data(), GL_STATIC_DRAW);
    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)(2 * sizeof(Vertex)));
    glEnableVertexAttribArray(0);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glBindVertexArray(0);
    // uncomment this call to draw in wireframe polygons.
    //glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);

    // render loop
    // -----------
    int n = 6;
    //glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);			//线框模式
    glLineWidth(2.0);			//设置线宽
    glm::mat4 trans = glm::mat4(1.0f);
    while (!glfwWindowShouldClose(window))
    {
        // input
        // -----

        processInput(window);
        SYSTEMTIME timeNow;
        GetLocalTime(&timeNow);

        glm::mat4 transs = glm::rotate(trans, glm::radians(float(timeNow.wSecond)), glm::vec3(0.0, 0.0, 1.0));
        int vertexpos_Trans = glGetUniformLocation(shaderProgram3, "trans");

        glm::mat4 trans1 = glm::mat4(1.0f);
        glm::mat4 transs1 = glm::rotate(trans1, glm::radians(float(timeNow.wMinute)), glm::vec3(0.0, 0.0, 1.0));
        int vertexpos_Trans1 = glGetUniformLocation(shaderProgram4, "trans");

        // render
        // ------
        glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT);

        // draw our first triangle
        glUseProgram(shaderProgram);
        glBindVertexArray(VAOs[0]); // seeing as we only have a single VAO there's no need to bind it every time, but we'll do so to keep things a bit more organized
        //glDrawArrays(GL_TRIANGLES, 0, 6);
        //glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
        glBindVertexArray(0); // no need to unbind it every time 

        // glfw: swap buffers and poll IO events (keys pressed/released, mouse moved etc.)
        glUseProgram(shaderProgram2);
        //  float vertexpos_T = glGetUniformLocation(shaderProgram2, "t");
       //   float vertexpos_R = glGetUniformLocation(shaderProgram2, "R");

         // float t = glfwGetTime();

        //  glUniform1f(vertexpos_T, t);
        //  float R = 0.25;
        //  glUniform1f(vertexpos_R, R);


        glBindVertexArray(VAOs[1]); // seeing as we only have a single VAO there's no need to bind it every time, but we'll do so to keep things a bit more organized
        //glDrawArrays(GL_TRIANGLES, 0, 6);

        glDrawArrays(GL_LINES, 0, vert.size());
        glBindVertexArray(0);
        glUseProgram(shaderProgram3);
        glBindVertexArray(VAOs[2]);
        glUniformMatrix4fv(vertexpos_Trans, 1, GL_FALSE, glm::value_ptr(transs));
        glDrawArrays(GL_LINES, 0, 2);
        glBindVertexArray(0);
        glBindVertexArray(VAOs[3]);
        glUniformMatrix4fv(vertexpos_Trans1, 1, GL_FALSE, glm::value_ptr(transs1));
        glDrawArrays(GL_LINES, 0, 2);
        glBindVertexArray(0);
        // -------------------------------------------------------------------------------

        glfwSwapBuffers(window);  //交换前后帧
        glfwPollEvents();
    }

    // optional: de-allocate all resources once they've outlived their purpose:
    // ------------------------------------------------------------------------

    glDeleteBuffers(1, VBOs);
    glDeleteBuffers(1, &EBO);
    glDeleteProgram(shaderProgram);
    glDeleteVertexArrays(1, VAOs);
    // glfw: terminate, clearing all previously allocated GLFW resources.
    // ------------------------------------------------------------------
    glfwTerminate();   //释放glfw所申请的内存
    return 0;
}
// process all input: query GLFW whether relevant keys are pressed/released this frame and react accordingly
// ---------------------------------------------------------------------------------------------------------
void processInput(GLFWwindow* window)
{
    if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
        glfwSetWindowShouldClose(window, true);
}
// glfw: whenever the window size changed (by OS or user resize) this callback function executes
// ---------------------------------------------------------------------------------------------
void framebuffer_size_callback(GLFWwindow* window, int width, int height)
{

    glViewport(0, 0, width, height);
}