OpenGL学习笔记4——在文件中获取着色器

继续看LearnOpenGL的着色器才发现，原来我上一次做的练习就是着色器里面的内容。现在就剩下一个从文件中读取并编译着色器了。（偷懒直接粘代码，不想一点一点来了）
之前我们都是直接用char数组作为shader的源码，非常的不方便。现在开始我们可以封装一个Shader类，直接在一个文件里面使用glsl编写shader,然后Shader类负责获取shader源码和编译。

1 头文件

给Shader写一个头文件，如下。没啥特别的，名称为shader.h。

#pragma once

#include <glad/glad.h>

#include <string>
#include <fstream>
#include <sstream>
#include <iostream>

class Shader {
public:
	// 着色器程序ID
	unsigned int id;
	
	// 构造函数
	Shader(const GLchar* vertexPath, const GLchar* fragmentPath);

	// 使用/激活函数
	void use();
	// uniform工具函数
	void setBool(const std::string &name, bool value)const;
	void setInt(const std::string& name, int value) const;
	void setFloat(const std::string& name, float value)const;
};

2 实现Shader类的函数

新建CPP文件为shader.cpp。内容如下

#include "shader.h"

Shader::Shader(const GLchar* vertexPath, const GLchar* fragmentPath)
{
	/* 从文件路径中获取着色器 */

	std::string vertexCode;
	std::string fragmentCode;
	std::ifstream vertexShaderFile;
	std::ifstream fragmentShaderFile;
	// 保证ifstream对象可以抛出异常
	vertexShaderFile.exceptions(std::ifstream::failbit | std::ifstream::badbit);
	fragmentShaderFile.exceptions(std::ifstream::failbit | std::ifstream::badbit);
	// 上面这两行还不知道是什么操作
	try
	{
		// 打开文件
		vertexShaderFile.open(vertexPath);
		fragmentShaderFile.open(fragmentPath);
		std::stringstream vShaderStream, fShaderStream;
		// 读取文件的缓冲内容到数据流中
		vShaderStream << vertexShaderFile.rdbuf();
		fShaderStream << fragmentShaderFile.rdbuf();
		// 关闭文件
		vertexShaderFile.close();
		fragmentShaderFile.close();
		// 转换数据流到string
		vertexCode = vShaderStream.str();
		fragmentCode = fShaderStream.str();
	}
	catch (std::ifstream::failure e)
	{
		std::cout << "ERROR::SHADER::FILE_NOT_SUCCESFULLY_READ" << std::endl;
	}
	// 将string转为char数组
	const char* vShaderCode = vertexCode.c_str();
	const char* fShaderCode = fragmentCode.c_str();


	/* 编译着色器 */

	unsigned int vertexShader, fragmentShader; // 着色器ID
	int success;; // 编译结果
	char infoLog[512]; // 报错信息

	// 顶点着色器
	vertexShader = glCreateShader(GL_VERTEX_SHADER);
	glShaderSource(vertexShader, 1, &vShaderCode, NULL);
	glCompileShader(vertexShader);
	// 打印编译错误（如果有的话）
	glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
	if (!success)
	{
		glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);
		std::cout << "ERROR::SHADER::VERTEX::COMPILATION_FAILED\n" << infoLog << std::endl;
	};

	// 片元着色器
	fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
	glShaderSource(fragmentShader, 1, &fShaderCode, NULL);
	glCompileShader(fragmentShader);
	// 打印编译错误（如果有的话）
	glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
	if (!success)
	{
		glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);
		std::cout << "ERROR::SHADER::VERTEX::COMPILATION_FAILED\n" << infoLog << std::endl;
	};

	// 着色器程序
	id = glCreateProgram(); // 着色器程序ID
	glAttachShader(id, vertexShader);
	glAttachShader(id, fragmentShader);
	glLinkProgram(id);
	// 打印连接错误（如果有的话）
	glGetProgramiv(id, GL_LINK_STATUS, &success);
	if (!success)
	{
		glGetProgramInfoLog(id, 512, NULL, infoLog);
		std::cout << "ERROR::SHADER::PROGRAM::LINKING_FAILED\n" << infoLog << std::endl;
	}

	// 删除着色器，它们已经链接到我们的程序中了，已经不再需要了
	glDeleteShader(vertexShader);
	glDeleteShader(fragmentShader);
}

// 使用着色器
void Shader::use()
{
	glUseProgram(id);
}

// 设置Bool
void Shader::setBool(const std::string& name, bool value) const
{
	glUniform1i(glGetUniformLocation(id, name.c_str()), (int)value);
	// 把bool转换成int，应该是用c的opengl里面没有bool吧。不太清楚
	// 而且好像还没实现另外几个向量的uniform设置
}

// 设置Int
void Shader::setInt(const std::string& name, int value) const
{
	glUniform1i(glGetUniformLocation(id, name.c_str()), value);
}

// 设置Float
void Shader::setFloat(const std::string& name, float value) const
{
	glUniform1f(glGetUniformLocation(id, name.c_str()), value);
}

3 着色器

新建一个vertexShader.vert，把原来的shader源码粘进去。
顶点着色器：

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

同理创建一个fragmentShader.frag。后缀名倒是没有什么关系，原教程用的是vs和fs，但是fs后缀被识别成focusSky的文件了，我就换了一下。
片元着色器：

#version 330 core
uniform float time;
in vec3 Color;
out vec4 FragColor;
void main(){
	FragColor = vec4(
        (sin(time*-0.5 + Color.x) + 1)/2,
        (sin(time*1.5+Color.y * 2+sin(time - 7.2)* sin(time / 1.8) + 2) + 1)/2,
        (sin(time*1.23+Color.z * 2.5) + 1)/2,
         1.0f);
}

这样就可以直接编辑，不用双引号和换行符了。不过在VS中打开还是很难看。

我改成用vscode打开，更改一下打开方式。

下个shader的扩展插件就舒服多了。然后弄了一个CLang-format用来格式化代码，但是用了一下貌似有点问题，“\”除号他也会换行，有空再研究研究怎么配置这个插件。

4 应用Shader类

回到原来的主函数中，可以将所有和shader有关的都删掉了，shader的源码，创建shader和编译shader，检查编译错误和使用shader全部删掉。
然后引用shader.h头文件，创建Shader对象，然后把刚才两个shader文件的相对路径写进去。我直接放在目录底下。然后在渲染循环里面调用use方法就可以了。
完整代码：

#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include <iostream>
#include "shader.h"
using namespace std;

void framebuffer_size_callback(GLFWwindow* window, int width, int height);
void processInput(GLFWwindow* window);

int main() {

#pragma region 窗口创建以及初始化
	glfwInit();// 初始化GLFW
	/*glfwWindowHint用来配置GLFW，第一个参数是选项名，第二个参数是这个选项的值*/
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);// 将主版本号设为3（因为用的OpenGL版本是3.3）
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);// 将此版本号设为3
	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);// 使用核心模式
	//glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);如果是MAC OS X系统需要加上这句

	/*创建窗口对象*/
	GLFWwindow* window = glfwCreateWindow(800, 600, "OpengGL_Testing", nullptr, nullptr);// 设置窗口大小、名字
	if (window == nullptr) {
		cout << "创建窗口失败" << endl;
		glfwTerminate();// 销毁所有剩余的窗口和游标
		return -1;
	}
	glfwMakeContextCurrent(window);// 设置当前的上下文（OpenGL是一个庞大的状态机，其状态被称为上下文）

	/*使用GLAD管理指针*/
	if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
		cout << "初始化GLAD失败" << endl;
		return -1;
	}

	/*设置视口，告诉OpenGL渲染窗口的尺寸大小*/
	glViewport(0, 0, 800, 600);// 前两个是窗口左下角的位置，后两个是宽和高

	/*告诉GLFW，每次窗口调用的时候使用framebuffer_size_callback函数*/
	glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);

#pragma endregion

#pragma region 绘制三角形相关

	// 三角形的顶点数据
	float vertices[] = {
	-0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 0.0f,
	 0.5f, -0.5f, 0.0f, 0.0f, 1.0f, 0.0f,
	 0.0f,  0.5f, 0.0f, 0.0f, 0.0f, 1.0f
	};

	// 创建顶点数组对象VAO（Vertex Array Object）
	unsigned int VAO;
	glGenVertexArrays(1, &VAO); // 第一个参数是几个对象，如果是多个对象的时候可以在第二个参数传一个数组进去
	glBindVertexArray(VAO); // 绑定VAO

	// 创建顶点缓冲对象VBO（Vertex Buffer Object）
	unsigned int VBO;
	glGenBuffers(1, &VBO);// 第一个参数是几个对象，如果是多个对象的时候可以在第二个参数传一个数组进去
	glBindBuffer(GL_ARRAY_BUFFER, VBO); // 绑定VBO

	// 将顶点数据绑定到GL_ARRAY_BUFFER上
	glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

	// 着色器
	Shader myShader("vertexShader.vert", "fragmentShader.frag");

	// VAO的设置
	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)0);
	glEnableVertexAttribArray(0);

	glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)(3 * sizeof(float)));
	glEnableVertexAttribArray(1);
#pragma endregion

#pragma region 渲染循环
	/*渲染循环*/
	// glfwWindowShouldClose用来检查window是否被要求退出
	while (!glfwWindowShouldClose(window)) {
		processInput(window); // 处理输入

		/*渲染操作*/
		//glClearColor(0.2f, 0.3f, 0.3f, 1.0f);// 用颜色清空屏幕
		glClearColor(0.0f, 0.0f, 0.0f, 1.0f);// 用颜色清空屏幕
		glClear(GL_COLOR_BUFFER_BIT);// 清空一个缓冲位的缓冲（还不太理解）

		/*传入时间*/
		myShader.setFloat("time", glfwGetTime() * 2);

		/*绘制三角形*/
		glBindVertexArray(VAO);
		//glUseProgram(shaderProgram);
		myShader.use();
		glDrawArrays(GL_TRIANGLES, 0, 3);


		glfwSwapBuffers(window); // 交换颜色缓冲
		glfwPollEvents(); // 检查有没有触发事件（比如键盘输入、鼠标移动等等），更新窗口状态，并调用对应的回调函数
	}
#pragma endregion

	/*释放资源*/
	glfwTerminate();

	return 0;
}

// 回调函数，窗口大小改变的时候也应该改变视口的大小
void framebuffer_size_callback(GLFWwindow* window, int width, int height) {
	// 不知道这个window有什么作用
	glViewport(0, 0, 800, 600);
}

// 处理输入
void processInput(GLFWwindow* window) {
	if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)// 判断是否按下Esc
		glfwSetWindowShouldClose(window, true);// 将窗口设置为需要关闭
}

然后没有错误的话，结果就和之前一样。就是方便了我们shader的编写。