justhomework/OpenGL/hello/src/main.cpp

#include "glad/glad.h"
#include <GLFW/glfw3.h>
#include <iostream>

// 三角形顶点
float vertices[] = {
    // 第一个三角形
    0.4f, 0.4f, 0.0f,   // 右上角
    0.4f, -0.4f, 0.0f,  // 右下角
    -0.4f, -0.4f, 0.0f, // 左下角
    -0.4f, 0.4f, 0.0f   // 左上角
};

// 索引
unsigned int indices[] = {
    0, 1, 3, // 第一个三角形
    1, 2, 3  // 第二个三角形
};

// 顶点着色器源码
const char *vertexShaderSource =R"(
    #version 330 core
    layout (location = 0) in vec3 aPos;
    layout (location = 1) in vec3 aColor;

    out vec3 color;

    void main()
    {
        gl_Position = vec4(aPos, 1.0);
        color = aColor;
    }
)";

// 片段着色器源码
const char *fragmentShaderSource = R"(
    #version 330 core
    in vec3 color;
    out vec4 FragColor;

    void main()
    {
        FragColor = vec4(color, 1.0);
    }
)";

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 = 600;

int main() {

  // 设置 glfw
  glfwInit();
  glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
  glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
  glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
  // glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);

  // 创建窗口
  GLFWwindow *window = glfwCreateWindow(800, 600, "LearnOpenGL", NULL, NULL);
  if (window == NULL) {
    std::cout << "Failed to create GLFW window" << std::endl;
    glfwTerminate();
    return -1;
  }
  glfwMakeContextCurrent(window);

  // 加载glad
  if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
    std::cout << "Failed to initialize GLAD" << std::endl;
    return -1;
  }

  // 设置视口
  glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);

  // 创建顶点着色器
  unsigned int vertexShader;
  vertexShader = glCreateShader(GL_VERTEX_SHADER);
  // 将着色器源码附加到着色器对象上
  glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);
  // 编译着色器
  glCompileShader(vertexShader);
  // 检查编译是否成功
  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;
  }

  // 创建片段着色器
  unsigned int fragmentShader;
  fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
  // 将着色器源码附加到着色器对象上
  glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
  // 编译着色器
  glCompileShader(fragmentShader);
  // 检查编译是否成功
  glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
  if (!success) {
    // 获取错误信息
    glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);
    std::cout << "ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n"
              << infoLog << std::endl;
  }

  // 创建着色器程序
  unsigned int shaderProgram;
  shaderProgram = glCreateProgram();
  // 将着色器附加到程序上
  glAttachShader(shaderProgram, vertexShader);
  glAttachShader(shaderProgram, fragmentShader);
  // 链接程序
  glLinkProgram(shaderProgram);
  // 检查链接是否成功
  glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
  if (!success) {
    // 获取错误信息
    glGetProgramInfoLog(shaderProgram, 512, NULL, infoLog);
    std::cout << "ERROR::SHADER::PROGRAM::LINK_FAILED\n"
              << infoLog << std::endl;
  }

  // 删除着色器
  glDeleteShader(vertexShader);
  glDeleteShader(fragmentShader);


  unsigned int VAO,VBO,EBO;
  // 创建顶点数组对象
  glGenVertexArrays(1, &VAO);
  glBindVertexArray(VAO);

  // 创建顶点缓冲对象
  glGenBuffers(1, &VBO);
  glBindBuffer(GL_ARRAY_BUFFER, VBO);
  glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

  // 创建索引缓冲对象
  glGenBuffers(1, &EBO);
  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
  glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices,
               GL_STATIC_DRAW);

  // 设置顶点属性指针
  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void *)0);
  glEnableVertexAttribArray(0);

  // 循环渲染
  while (!glfwWindowShouldClose(window)) {
    // 处理输入
    processInput(window);

    // 设置为白色
    glClearColor(1.0f, 1.0f, 1.0f, 0.0f);
    glClear(GL_COLOR_BUFFER_BIT);

    // 绘制三角形, 激活程序
    glUseProgram(shaderProgram);
    glBindVertexArray(VAO);
    //使用线框模式绘制
    glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
    // 设置线宽
    glLineWidth(3.0f);
    // 绘制
    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
    glBindVertexArray(0);

    // 检查并调用事件，交换缓冲
    glfwSwapBuffers(window);
    glfwPollEvents();
  }

  // 释放资源
  glfwTerminate();
  return 0;
}

// 处理输入
void processInput(GLFWwindow *window) {
  if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
    glfwSetWindowShouldClose(window, true);
}

// 窗口大小改变时回调该函数
void framebuffer_size_callback(GLFWwindow *window, int width, int height) {
  glViewport(0, 0, width, height);
}