图形学学习（二）：Shader输入输出及自制Shader类

在LearnOpengl学了Shader的输入输出和自制Shader类，输入输出还是好理解的，自制Shader类的讲解我感觉还是用代码更直观一些（个人感觉），这两天看了一下秋招的面试面经，想了想明年找工作的问题，刺激，十分感慨，优秀的人还是太多了，不过最重要的还是得做好自己！！！

Shader的输入输出

总结有两种方式：一种是着色器之间关联的，一种是Uniform全局变量形式

如下即是着色器之间关联的输入输出方式：

顶点着色器：

layout (location = 0) in   vec3 aPos;//此为接收输入，输入要在变量前加前缀in

Out  vec4 vertexColor;//此为输出

顶点着色器输入的接收要用到我们之前用到glVertexAttribPointer函数传递，void main()中是我们对输入输出数据的处理

片段着色器：

out  vec4 FragColor;

In   vec4 vertexColor;//变量名一样才能接收到顶点着色器的输入

void main()中显然我们根据顶点着色器的输入进行了处理。

如下是Uniform的输入输出方式：

Uniform是全局的，我们不需要顶点着色器做中介，直接在代码中把数据传入就行，比较麻烦的是要调用函数去处理。
 

在渲染循环中添加就好了，然后解释一下这个
glUniform4f(vertexColorLocation, 0.0f, greenValue, 0.0f, 1.0f);

第一个参数vertexColorLocation在我看来是用指定的着色器程序找到这个Uniform变量的位置，后面是个才是参数值设置，也就是后面4个float参数，glUniform4f中的4f就是说4个float参数，这四个float代表的就是RGBA（red，green，blue，alpha）四个值的设置。

自制Shader类

 想了想先给出着色器类的代码和我遇到的问题吧，有些东西讲太冗余也没必要，我遇到的问题就是突然cpp文件无法链接到文档.h头文件了。

shader.h

#include<glad/glad.h>
#include<string>
#include<fstream>
#include<sstream>
#include<iostream>

using namespace std;

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

	//构造器读取并构建着色器
	Shader(const char* vertexPath, const char* 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();
			//转换数据流到string
			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 Shader
		fragment = glCreateShader(GL_FRAGMENT_SHADER);
		glShaderSource(fragment, 1, &fShaderCode, NULL);
		glCompileShader(fragment);
		checkCompileErrors(fragment, "FRAGMENT");
		// shader Program
		ID = glCreateProgram();
		glAttachShader(ID, vertex);
		glAttachShader(ID, fragment);
		glLinkProgram(ID);
		checkCompileErrors(ID, "PROGRAM");
		// delete the shaders as they're linked into our program now and no longer necessary
		glDeleteShader(vertex);
		glDeleteShader(fragment);

	}
	//使用激活程序
	void use() 
	{
		glad_glUseProgram(ID);
	}
	//uniform工具函数
	void setBool(const string& name, bool value) const
	{
		glUniform1i(glGetUniformLocation(ID, name.c_str()), (int)value);
	}
	void setInt(const string& name, int value) const
	{
		glUniform1i(glGetUniformLocation(ID, name.c_str()), value);
	}
	void setFloat(const string& name, float value) const
	{
		glUniform1f(glGetUniformLocation(ID, name.c_str()), value);
	}

private:
	
	void checkCompileErrors(unsigned int shader, string type)
	{
		int success;
		char infoLog[1024];
		if (type != "PROGRAM")
		{
			glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
			if (!success)
			{
				glGetShaderInfoLog(shader, 1024, NULL, infoLog);
				cout << "ERROR::SHADER_COMPILATION_ERROR of type: " << type << "\n" << infoLog << "\n -- "<<endl;
			}
		}
		else
		{
			glGetProgramiv(shader, GL_LINK_STATUS, &success);
			if (!success)
			{
				glGetProgramInfoLog(shader, 1024, NULL, infoLog);
				cout << "ERROR::PROGRAM_LINKING_ERROR of type: " << type << "\n" << infoLog << "\n -- - -- " << endl;
			}
		}
	}
};

shader.cpp

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

#include "shader.h"

#include <iostream>

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()
{

    glfwInit();
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

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


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

    Shader ourShader("shader.vs", "shader.fs"); // you can name your shader files however you like


    float vertices[] = {
        // positions         // colors
         0.5f, -0.5f, 0.0f,  1.0f, 0.0f, 0.0f,  // bottom right
        -0.5f, -0.5f, 0.0f,  0.0f, 1.0f, 0.0f,  // bottom left
         0.0f,  0.5f, 0.0f,  0.0f, 0.0f, 1.0f   // top 
    };

    unsigned int VBO, VAO;
    glGenVertexArrays(1, &VAO);
    glGenBuffers(1, &VBO);
    // bind the Vertex Array Object first, then bind and set vertex buffer(s), and then configure vertex attributes(s).
    glBindVertexArray(VAO);

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

    // position attribute
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)0);
    glEnableVertexAttribArray(0);
    // color attribute
    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)(3 * sizeof(float)));
    glEnableVertexAttribArray(1);



    while (!glfwWindowShouldClose(window))
    {

        processInput(window);

 
        glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT);

        // render the triangle
        ourShader.use();
        glBindVertexArray(VAO);
        glDrawArrays(GL_TRIANGLES, 0, 3);

  
        glfwSwapBuffers(window);
        glfwPollEvents();
    }


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


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

问题解决：

在这里加上你的工程文件所在目录（如下图）就好了。

自制shader类把一下固定的前置代码都放在一个类中设置，而不用显示在main函数中一大串，也是为了方便。
也就是如下内容要放到外部文件或者Shader类中：

一、Shader代码

//顶点着色器

const char *vertexShaderSource = "#version 330 core\n"

"layout (location = 0) in vec3 aPos;\n"

"layout (location = 1) in vec3 aColor;\n"

"out vec3 ourColor;\n"

"void main()\n"

"{\n"

"   gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0);\n"

"   ourColor = aColor;\n"  

"}\0";



//片段着色器

const char* fragmentShaderSource = "#version 330 core\n"

"out vec4 FragColor;\n"

"in vec3 ourColor;\n"

"void main()\n"

"{\n"

"   FragColor = vec4(ourColor,1.0f);\n"

"}\n\0";

二、顶点着色器、片段着色器、链接着色器的配置

 //创建顶点着色器

 unsigned int 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 = 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 = glCreateProgram();

 glAttachShader(shaderProgram, vertexShader);

 glAttachShader(shaderProgram, fragmentShader);

 glLinkProgram(shaderProgram);

 //检测链接成功没有

 glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);

 if (!success)

 {

     glGetProgramInfoLog(shaderProgram, 513, NULL, infoLog);

     std::cout << "ERROR::SHADER::PROGRAM::LINKING_FAILED\n" << infoLog << std::endl;

 }



 glDeleteShader(vertexShader);

 glDeleteShader(fragmentShader);

为达成以上目标：

首先我们将顶点着色器和片段着色器代码写在了外部（文件名及其后缀随意）

然后我也遇到一个问题就是文件中中双引号要不要写进去，发现其实不用写进去

然后它们长这样

之后就是着色器类的编写了，因为着色器写成了外部文件我们要记得去读取，然后我直接给出读取的代码了。

//从文件路径中获取顶点片段着色器

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();

//转换数据流到string

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();

其他的就和向之前一样编写着色器的配置和链接就好了，不过这个ShaderProgram的程序ID这个变量要变成写在构造函数外面。

main中调用生成Shader对象就行了。