Preliminary use of Opengl Shader

Mainly follow the Opengl website to learn how to read and use Shader files.

VertexShader.vs

#version 330 core
layout (location = 0) in vec3 aPos;
layout (location = 1) in vec3 aColor;
out vec3 ourColor;
uniform float xOffset;
//输出顶点给片元着色器
out vec3 selfPos;
void main()
{
   //向左偏移，倒置三角形
   gl_Position = vec4(aPos.x - xOffset, -aPos.y,aPos.z, 1.0);
   ourColor = aColor;
   selfPos = aPos;
};

FragmentShader.fs

#version 330 core
out vec4 FragColor;
in vec3 ourColor;
in vec3 selfPos;
void main()
{
   //FragColor = vec4(ourColor, 1.0f);
   FragColor = vec4(selfPos, 1.0f);
};

Shader.h

#ifndef SHADER_H
#define SHADER_H

#include <glad/glad.h>; // 包含glad来获取所有的必须OpenGL头文件

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

using namespace std;

class Shader
{
public:
	Shader();
	~Shader();
	// 程序ID
	unsigned int ID;

	// 构造器读取并构建着色器
	Shader(const GLchar* vertexPath, const GLchar* fragmentPath) 
	{
		string vertexCode;
		string fragmentCode;

		ifstream vShaderFile;
		ifstream fShaderFile;
		//保证ifstream对象可以抛出异常：
		vShaderFile.exceptions(ifstream::failbit | ifstream::badbit);
		fShaderFile.exceptions(ifstream::failbit | ifstream::badbit);
		try
		{
			vShaderFile.open(vertexPath);
			fShaderFile.open(fragmentPath);
			stringstream vShaderStream, fShaderStream;
			//实现一个流对象指向的内容用另一个流对象来输出
			vShaderStream << vShaderFile.rdbuf();
			fShaderStream << fShaderFile.rdbuf();
			vShaderFile.close();
			fShaderFile.close();

			vertexCode = vShaderStream.str();
			fragmentCode = fShaderStream.str();
		}
		catch (ifstream::failure e)
		{
			cout << "ERROR::SHADER::FILE_NOT_SUCCESFULLY_READ" << endl;
		}

		const char* vShaderCode = vertexCode.c_str();
		const char* fShaderCode = fragmentCode.c_str();
		unsigned int vertex, fragment;
		vertex = glCreateShader(GL_VERTEX_SHADER);
		glShaderSource(vertex, 1, &vShaderCode, NULL);
		glCompileShader(vertex);
		checkCompileErrors(vertex, "VERTEX");

		fragment = glCreateShader(GL_FRAGMENT_SHADER);
		glShaderSource(fragment, 1, &fShaderCode, NULL);
		glCompileShader(fragment);
		checkCompileErrors(fragment, "FRAGMENT");

		ID = glCreateProgram();
		glAttachShader(ID, vertex);
		glAttachShader(ID, fragment);
		glLinkProgram(ID);
		checkCompileErrors(ID, "PROGRAM");

		glDeleteShader(vertex);
		glDeleteShader(fragment);
	}

	// 使用/激活程序
	void use() 
	{
		glUseProgram(ID);
	}

	// uniform工具函数
	void setBool(const std::string &name, bool value) const 
	{
		glUniform1i(glGetUniformLocation(ID, name.c_str()), (int)value);
	}

	void setInt(const std::string &name, int value) const 
	{
		glUniform1i(glGetUniformLocation(ID, name.c_str()), value);
	}

	void setFloat(const std::string &name, float value) const 
	{
		glUniform1f(glGetUniformLocation(ID, name.c_str()), value);
	}
private:
	// utility function for checking shader compilation/linking errors.
	// ------------------------------------------------------------------------
	void checkCompileErrors(unsigned int shader, std::string type)
	{
		int success;
		char infoLog[1024];
		if (type != "PROGRAM")
		{
			glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
			if (!success)
			{
				glGetShaderInfoLog(shader, 1024, NULL, infoLog);
				std::cout << "ERROR::SHADER_COMPILATION_ERROR of type: " << type << "\n" << infoLog << "\n -- --------------------------------------------------- -- " << std::endl;
			}
		}
		else
		{
			glGetProgramiv(shader, GL_LINK_STATUS, &success);
			if (!success)
			{
				glGetProgramInfoLog(shader, 1024, NULL, infoLog);
				std::cout << "ERROR::PROGRAM_LINKING_ERROR of type: " << type << "\n" << infoLog << "\n -- --------------------------------------------------- -- " << std::endl;
			}
		}
	}
};

Shader::Shader()
{
}

Shader::~Shader()
{
}

#endif // !SHADER_H

Specific usage functions:

/**
* GLFW窗口
*/

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

#include <Shader/Shader.h>

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

void inputProcess(GLFWwindow* window);

//顶点数据
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    // 顶部
};

//顶点缓冲对象(Vertex Buffer Objects, VBO)，它会在GPU内存（通常被称为显存）中储存大量顶点
//使用这些缓冲对象的好处是我们可以一次性的发送一大批数据到显卡上，而不是每个顶点发送一次
unsigned int VBO;
//顶点数组对象(Vertex Array Object, VAO)可以像顶点缓冲对象那样被绑定，任何随后的顶点属性调用都会储存在这个VAO中。
//这样的好处就是，当配置顶点属性指针时，你只需要将那些调用执行一次，之后再绘制物体的时候只需要绑定相应的VAO就行了。
unsigned int VAO;

int main()
{
	//初始化glfw
	glfwInit();
	//第一个参数代表选项的名称，我们可以从很多以GLFW_开头的枚举值中选择；第二个参数接受一个整型，用来设置这个选项的值
	//其实就是设置用Opengl哪个版本，这里是3.3版本
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
	//MAC系统要打开
	//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);
	//在调用任何OpenGL的函数之前我们需要初始化GLAD
	//加载系统相关的OpenGL函数指针地址
	if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
	{
		std::cout << "Failed to initialize GLAD" << std::endl;
		return -1;
	}
	//设置窗口大小改变的回调
	glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);

	Shader ourShader("Shader/Vertex/VertexShader.vs", "Shader/Vertex/FragmentShader.fs");
	glGenVertexArrays(1, &VAO);
	glGenBuffers(1, &VBO);
	glBindVertexArray(VAO);

	glBindBuffer(GL_ARRAY_BUFFER, VBO);
	glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

	// 顶点属性
	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);

	//渲染循环(Render Loop),一直检测glfw窗口是否被要求关闭
	while (!glfwWindowShouldClose(window))
	{
		//处理按键输入
		inputProcess(window);

		/***********这里做具体的渲染指令************/

		//设置清空屏幕所用的颜色
		glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
		//清空颜色缓冲
		glClear(GL_COLOR_BUFFER_BIT);
		//设置偏移量
		float offset = 0.5f;
		ourShader.setFloat("xOffset", offset);

		ourShader.use();

		glBindVertexArray(VAO); 
		glDrawArrays(GL_TRIANGLES, 0, 3);

		/***********这里做具体的渲染指令************/

		//交换颜色缓冲（它是一个储存着GLFW窗口每一个像素颜色值的大缓冲），它在这一迭代中被用来绘制，并且将会作为输出显示在屏幕上。
		glfwSwapBuffers(window);
		//检查有没有触发什么事件（比如键盘输入、鼠标移动等）、更新窗口状态，并调用对应的回调函数（可以通过回调方法手动设置）。
		glfwPollEvents();
	}

	glDeleteVertexArrays(1, &VAO);
	glDeleteBuffers(1, &VBO);

	//释放或者删除之前的分配的所有资源
	glfwTerminate();
	return 0;
}

//窗口大小变化的时候的回调
void framebuffer_size_callback(GLFWwindow* window, int width, int height)
{
	//看下宽高变化的数据
	printf("w = %d, h = %d \n",width, height);
	//设置OpenGL渲染窗口的尺寸大小(视口Viewport),前两个参数控制窗口左下角的位置。第三个和第四个参数控制渲染窗口的宽度和高度（像素）
	glViewport(0, 0, width, height);
}

//处理按键输入
void inputProcess(GLFWwindow* window)
{
	//按下ESC的时候
	if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
	{
		//把WindowShouldClose属性设置为 true，在循环肿关闭窗口
		glfwSetWindowShouldClose(window, true);
		printf("窗口即将关闭...");
	}
}

1. The file stream is used to read the Shader file.
2. Customize processing and set some Shader properties
3. Offset of vertex position
4. The color value of the vertex position in the vertex shader is processed in the fragment shader.

Final effect: