OpenGL学习笔记——网格

╰+哭是因爲堅強的太久メ 2023-01-16 02:54 158阅读 0赞

### 文章目录 ###

*  一、网格类
 *  二、简单的测试

# 一、网格类 #

> 学习OpenGL一段时间之后，就应该学会让自己偷懒，不能每一次写个程序都有配置一大堆的参数啊\*^\*，所以就效仿《Learning OpenGL》一书中的做法，也创建一个网格类\*~\*。为了尽可能简单，我的这个网格类只需要顶点与顶点索引数据，不需要纹理数据，如下所示。

> MeshV1.h

#pragma once
    
    #include <glad/glad.h> // holds all OpenGL type declarations
    
    #include <glm/glm.hpp>
    #include <glm/gtc/matrix_transform.hpp>
    
    #include "shader.h"
    
    #include <string>
    #include <vector>
    using namespace std;
    
    struct Vertex		//顶点结构
    { 
    	//位置
    	glm::vec3 position;
    
    	//法向量
    	glm::vec3 normal;
    
    	//纹理坐标
    	glm::vec2 texCoords;
    
    	//切线
    	glm::vec3 tangent;
    
    	//双切线
    	glm::vec3 bitangent;
    
    	Vertex(const glm::vec3& position) :position(position) { };
    };
    
    class Mesh { 
    	//数据
    	vector<Vertex> vertices;	//顶点
    	vector<unsigned int> indices;	//顶点索引
    	unsigned int VAO;		//顶点数组对象
    
    public:
    	//构造函数
    	Mesh(vector<Vertex> vertices, vector<unsigned int> indices)
    		:vertices(vertices), indices(indices) { 
    		setupMesh();	//创建顶点的缓冲区并制定顶点各部分属性
    	}
    
    	//绘制网格
    	void Draw(Shader& shader) { 
    		glBindVertexArray(VAO);
    		glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);		//图形的前面与背面都以线的形式进行绘制
    		glDrawElements(GL_TRIANGLES, indices.size(), GL_UNSIGNED_INT, 0);
    		glBindVertexArray(0);
    	}
    
    	~Mesh() { 
    		glDeleteVertexArrays(1, &VAO);
    		glDeleteBuffers(1, &VBO);
    		glDeleteBuffers(1, &EBO);
    	}
    
    private:
    	//渲染时所需数据
    	unsigned int VBO, EBO;
    
    	void setupMesh() { 
    		glGenVertexArrays(1, &VAO);
    		glGenBuffers(1, &VBO);
    		glGenBuffers(1, &EBO);
    
    		glBindVertexArray(VAO);
    		glBindBuffer(GL_ARRAY_BUFFER, VBO);
    		glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(Vertex), &vertices[0], GL_STATIC_DRAW);
    		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
    		glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(unsigned int), &indices[0], GL_STATIC_DRAW);
    
    		glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)0);
    		glEnableVertexAttribArray(0);
    
    		glBindVertexArray(0);		//解除绑定
    	}
    };

# 二、简单的测试 #

> 网格类建好之后总要测试一下可不可以使用，要不然也不知道正确与否。

> shader\_ct.vs

#version 330 core
    
    //进行布局
    layout (location=0) in vec3 aPos;		//接收传进来的数据
    out vec4 myColor;
    
    //定义坐标转换变量
    uniform mat4 model;
    uniform mat4 view;
    uniform mat4 projection;
    
    void main(){ 
    	gl_Position = projection * view * model * vec4(aPos, 1.0);		//对顶点数据进行坐标转换
    	myColor = vec4(0,1,0,1);
    }

> shader\_ct.fs

#version 330 core
    
    in vec4 myColor;		//接收传过来的数据
    out vec4 fragColor;
    
    void main(){ 
    	fragColor = myColor;
    }

> MeshGL.h

#pragma once
    
    #include<glad\glad.h>
    #include<GLFW\glfw3.h>
    
    #include"Camera.h"
    #include"shader.h"
    #include"MeshV1.h"
    #define STB_IMAGE_IMPLEMENTATION
    #include"stb_image.h"
    
    namespace MeshGL { 
    	const unsigned int SCR_WIDTH = 800;
    	const unsigned int SCR_HEIGHT = 600;
    
    	Camera camera(glm::vec3(0.0f, 0.0f, 5.0f));
    	float lastX = SCR_WIDTH / 2.0f;
    	float lastY = SCR_HEIGHT / 2.0f;
    	bool firstMouse = true;
    
    	// timing
    	float deltaTime = 0.0f;
    	float lastFrame = 0.0f;
    
    	void processInput(GLFWwindow *window)
    	{ 
    		if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
    			glfwSetWindowShouldClose(window, true);
    
    		if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS)
    			camera.ProcessKeyboard(FORWARD, deltaTime);
    		if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS)
    			camera.ProcessKeyboard(BACKWARD, deltaTime);
    		if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS)
    			camera.ProcessKeyboard(LEFT, deltaTime);
    		if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS)
    			camera.ProcessKeyboard(RIGHT, deltaTime);
    	}
    
    	//窗口大小发生变化时会调用该函数
    	void framebuffer_size_callback(GLFWwindow* window, int width, int height)
    	{ 
    		glViewport(0, 0, width, height);		//重新设置视口大小
    	}
    
    	//鼠标事件
    	void mouse_callback(GLFWwindow* window, double xpos, double ypos)
    	{ 
    		if (firstMouse)
    		{ 
    			lastX = xpos;
    			lastY = ypos;
    			firstMouse = false;
    		}
    
    		float xoffset = xpos - lastX;
    		float yoffset = lastY - ypos; // reversed since y-coordinates go from bottom to top
    
    		lastX = xpos;
    		lastY = ypos;
    
    		camera.ProcessMouseMovement(xoffset, yoffset);
    	}
    
    	//滚轮事件
    	void scroll_callback(GLFWwindow* window, double xoffset, double yoffset)
    	{ 
    		camera.ProcessMouseScroll(yoffset);
    	}
    
    	void meshv1() { 
    		glfwInit();
    		glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    		glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    		glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    
    		GLFWwindow *window = glfwCreateWindow(800, 600, "Mesh", 0, 0);
    		if (window == NULL) { 
    			std::cout << "Creating window is failed" << std::endl;
    		}
    
    		glfwMakeContextCurrent(window);
    		glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
    		glfwSetCursorPosCallback(window, mouse_callback);
    		glfwSetScrollCallback(window, scroll_callback);
    		glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
    
    		if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) { 
    			std::cout << "Failed to initialize GLAD" << std::endl;
    			return;
    		}
    
    		int viewWidth, viewHeight;
    		glfwGetFramebufferSize(window, &viewWidth, &viewHeight);
    		glViewport(0, 0, viewWidth, viewHeight);
    		
    		Shader ourShader("../Shader/shader_ct.vs", "../Shader/shader_ct.fs");
    		
    		vector<Vertex> vertices = { 
    			Vertex(glm::vec3(-1,0,0)),
    			Vertex(glm::vec3(1,0,0)),
    			Vertex(glm::vec3(1,1,0)),
    			Vertex(glm::vec3(-1,1,0)),
    		};
    		vector<unsigned int> indices = { 
    			0,1,2,
    			0,2,3,
    		};
    		Mesh mesh(vertices,indices);
    
    		glEnable(GL_DEPTH_TEST);		//启用深度测试
    		//glPointSize(10);
    		while (!glfwWindowShouldClose(window)) { 
    			float currentFrame = glfwGetTime();
    			deltaTime = currentFrame - lastFrame;
    			lastFrame = currentFrame;
    
    			processInput(window);
    
    			glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
    			glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    
    			ourShader.use();
    			glm::mat4 model = glm::mat4(1.0f);
    			glm::mat4 view = glm::mat4(1.0f);
    			glm::mat4 projection = glm::mat4(1.0f);
    			projection = glm::perspective(glm::radians(camera.Zoom), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f);
    			view = camera.GetViewMatrix();
    			ourShader.setMat4("projection", projection);
    			ourShader.setMat4("view", view);
    			ourShader.setMat4("model", model);
    			//绘制图形
    			mesh.Draw(ourShader);
    
    			glfwSwapBuffers(window);
    			glfwPollEvents();
    		}
    		glfwTerminate();
    	}
    }

> main.cpp

#include"MeshGL.h"
    
    int main() { 
    	MeshGL::meshv1();
    	
    	return 0;
    }

运行效果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RheXVoYWl0YW5nMQ_size_16_color_FFFFFF_t_70]

> 参考资料：[《Learning OpenGL》][Learning OpenGL]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RheXVoYWl0YW5nMQ_size_16_color_FFFFFF_t_70]: /images/20221022/d86ab9cdffeb44a39391b10acb68f74c.png
[Learning OpenGL]: https://learnopengl-cn.readthedocs.io/zh/latest/03%20Model%20Loading/02%20Mesh/