Shader 只是进行一些简单的封装，主要功能：
1、编译着色程序
2、绑定 Uniform 数据
3、根据着色程序的顶点属性传递顶点数据到 GPU
着色程序的编译
GLuint Shader::createShaderProgram(const char* vsname, const char* psname)
{
std::string vShaderSource, fShaderSource;
std::ifstream vShaderFile, fShaderFile;
vShaderFile.exceptions(std::ifstream::badbit);
fShaderFile.exceptions(std::ifstream::badbit); try {
vShaderFile.open(PathHelper::fullPath(vsname), std::ios::in);
fShaderFile.open(PathHelper::fullPath(psname), std::ios::in); std::stringstream vShaderStream, fShaderStream; vShaderStream << vShaderFile.rdbuf();
fShaderStream << fShaderFile.rdbuf(); vShaderSource = vShaderStream.str();
fShaderSource = fShaderStream.str(); vShaderFile.close();
fShaderFile.close();
}
catch ( std::ifstream::failure e ) {
throw std::exception("Error shader: file not succesfully read");
}
const GLchar* vShaderCode = vShaderSource.c_str();
const GLchar* fShaderCode = fShaderSource.c_str(); /* 创建顶点作色器 */
GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vertexShader, , &vShaderCode, NULL);
glCompileShader(vertexShader); GLint success;
GLchar infoLog[]; glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
if ( !success ) {
glGetShaderInfoLog(vertexShader, , NULL, infoLog);
throw std::exception("");
} /* 创建片段着色器 */
GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragmentShader, , &fShaderCode, NULL);
glCompileShader(fragmentShader); glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
if ( !success ) {
glGetShaderInfoLog(fragmentShader, , NULL, infoLog);
throw std::exception("");
} /* 创建着色程序 */
GLuint shaderProgram = glCreateProgram();
glAttachShader(shaderProgram, vertexShader);
glAttachShader(shaderProgram, fragmentShader);
glLinkProgram(shaderProgram); glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
if ( !success ) {
glGetProgramInfoLog(shaderProgram, , NULL, infoLog);
throw std::exception("");
}
glDeleteShader(vertexShader);
glDeleteShader(fragmentShader); /* 使用着色程序 */
return shaderProgram;
}
Simple2D 只支持顶点着色器和片段着色器，暂不支持其他着色器。
OpenGL 绘制方式
使用openGL图形库绘制，都需要通过openGL接口向图像显卡提交顶点数据，显卡根据提交的数据绘制出相应的图形。
其中有四种方式：
1、立即模式
2、显示列表
3、顶点数组
4、现代VAO、ABO
立即模式和显示列表是 OpenGL 传统模式的绘制方法（现在都 2017 年了，应该没有人用这种方式了吧？），后两种是现代方式绘制。前面渲染器用的就是第四种方式：现代 VBO 和 VAO。
VBO 即 Vertex Buffer Object，是一个在高速视频卡中的内存缓冲，用来保存顶点数据,也可用于包含诸如归一化向量、纹理和索引等数据。
VAO 即 Vertex Array Object ，是一个包含一个或多个VBO的对象，被设计用来存储一个完整被渲染对象所需的信息。
这里不再对其进行介绍，感兴趣的可以点击这个链接：https://learnopengl-cn.github.io/01%20Getting%20started/04%20Hello%20Triangle/
本次渲染器用的是第三种方式，为了更好地理解这种绘制方式，下面举一个例子，假设顶点着色器的顶点属性为
layout(location = ) in vec3 Position;
layout(location = ) in vec2 Texcoord;
layout(location = ) in vec4 Color;
这里随机给定一些顶点数据，包含有位置、颜色和纹理坐标
GLfloat vertexes[] = {
0.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f,
1.0f, 1.0f, 0.0f,
1.0f, 0.0f, 0.0f,
};
GLfloat colors[] = {
1.0f, 1.0f, 1.0f, 1.0f,
1.0f, 1.0f, 1.0f, 1.0f,
1.0f, 1.0f, 1.0f, 1.0f,
1.0f, 1.0f, 1.0f, 1.0f
};
GLfloat texCoordes[] = {
0.0f, 1.0f,
0.0f, 0.0f,
1.0f, 0.0f,
1.0f, 1.0f
};
接下来使用函数 glVertexAttribPointer 把顶点数据传递到 GPU。
void glVertexAttribPointer( GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride,const GLvoid * pointer);
glEnableVertexAttribArray();
glEnableVertexAttribArray();
glEnableVertexAttribArray();
glVertexAttribPointer(, 3, GL_FLOAT, GL_FALSE, , vertexes);
glVertexAttribPointer(, 2, GL_FLOAT, GL_FALSE, , colores);
glVertexAttribPointer(, 4, GL_FLOAT, GL_FALSE, , texCoordes);
然后调用 glDrawArrays 函数进行绘制（使用了顶点索引的可调用 glDrawElements），上面的例子中每个顶点属性的数据储存在不同的数组中。如果你想把数据都储存在一个数组中，就如下面一样
GLfloat data[] = {
0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f,
0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f,
1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f,
1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f
};
这样称之为交错数组，而且使用函数 glVertexAttribPointer 的参数需要作出相应的改变
glEnableVertexAttribArray();
glEnableVertexAttribArray();
glEnableVertexAttribArray();
glVertexAttribPointer(, 3, GL_FLOAT, GL_FALSE, 9 * sizeof(GLfloat), (char*)data + sizeof(GLfloat) * 0);
glVertexAttribPointer(, 2, GL_FLOAT, GL_FALSE, 9 * sizeof(GLfloat), (char*)data + sizeof(GLfloat) * 3);
glVertexAttribPointer(, 4, GL_FLOAT, GL_FALSE, 9 * sizeof(GLfloat), (char*)data + sizeof(GLfloat) * 5);
第五个参数是跨度，即所有顶点属性的大小，3 + 2 + 4 = 9，最后一个参数是数据的指针，不同顶点属性的数据要加上适当的偏移。最后调用绘制函数即可。
通过上面的例子可知，每个顶点着色器的顶点属性都不一定一样，所以在传递顶点数据到 GPU 时所执行的操作不一样。所以在创建 Shader 前需要设置 Shader 的顶点属性数组，通过顶点属性数组来执行传递数据到 GPU 的操作。
分析 glVertexAttribPointer 函数的参数，定义下面顶点属性的结构
struct VertexAttribute
{
int layout;
int size;
int type;
int stride;
int offset;
};
Shader 默认有两种顶点属性，分别是 位置-颜色 和 位置-纹理坐标-颜色
enum CustomVertexAttribute
{
CVA_UNKNOEWN,
CVA_V3F_C4F,
CVA_V3F_T2F_C4F
};
设置着色器的顶点属性数组，默认最多存在8个顶点属性
void Shader::setVertexAttribute(CustomVertexAttribute cva)
{
if ( cva == CustomVertexAttribute::CVA_V3F_C4F ) {
VertexAttribute vertexAttributes[] = {
{ , , GL_FLOAT, * sizeof(GL_FLOAT), * sizeof(GL_FLOAT) },
{ , , GL_FLOAT, * sizeof(GL_FLOAT), * sizeof(GL_FLOAT) }
};
this->setVertexAttribute(vertexAttributes, sizeof(vertexAttributes) / sizeof(VertexAttribute));
}
else if(cva == CustomVertexAttribute::CVA_V3F_T2F_C4F){
VertexAttribute vertexAttributes[] = {
{ , , GL_FLOAT, * sizeof(GL_FLOAT), * sizeof(GL_FLOAT) },
{ , , GL_FLOAT, * sizeof(GL_FLOAT), * sizeof(GL_FLOAT) },
{ , , GL_FLOAT, * sizeof(GL_FLOAT), * sizeof(GL_FLOAT) }
};
this->setVertexAttribute(vertexAttributes, sizeof(vertexAttributes) / sizeof(VertexAttribute));
}
} void Shader::setVertexAttribute(VertexAttribute* attribute, int count)
{
assert(count < );
for ( nVertexAttributeCount = ; nVertexAttributeCount < count; nVertexAttributeCount++ ) {
vertexAttributes[nVertexAttributeCount] = attribute[nVertexAttributeCount];
}
}
在设置好 Shader 的顶点属性数组后，就可以正确的传递顶点数据到 GPU 了
void Shader::bindVertexDataToGPU(void* data)
{
void* data_offset = nullptr;
for ( int i = ; i < nVertexAttributeCount; i++ ) {
data_offset = static_cast< char* > ( data ) +vertexAttributes[i].offset; /* 上传顶点数据 */
glVertexAttribPointer(
vertexAttributes[i].layout,
vertexAttributes[i].size,
vertexAttributes[i].type,
GL_FALSE,
vertexAttributes[i].stride,
data_offset); glEnableVertexAttribArray(vertexAttributes[i].layout);
}
}
函数接受顶点数据的指针，然后根据顶点属性数组调用 glVertexAttribPointer 函数设置顶点属性数组的数据格式和位置，最后调用绘制函数绘制即可。
绑定 Uniform 数据
假如你要绑定一个整数 2 到着色器，你可以通过两步完成：
1、调用函数 glGetUniformLocation 获取着色器中 Uniform 变量的绑定点 location。
2、调用 glUniform 为当前着色程序对象指定Uniform变量的值。
由于只是绑定一个整型数 2，可以使用下面的代码绑定
glUniform1i(glGetUniformLocation(shaderProgram, "valueName"), 2);
值得注意的是，C 语言没有函数重载，所以会有很多名字相同后缀不同的函数版本存在。其中函数名中包含数字（1、2、3、4）表示接受这个数字个用于更改uniform变量的值，i表示32位整形，f表示32位浮点型，ub表示8位无符号byte，ui表示32位无符号整形，v表示接受相应的指针类型。
下面列举了这些函数
void glUniform1f(GLint location, GLfloat v0);
void glUniform2f(GLint location, GLfloat v0, GLfloat v1);
void glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
void glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
void glUniform1i(GLint location, GLint v0);
void glUniform2i(GLint location, GLint v0, GLint v1);
void glUniform3i(GLint location, GLint v0, GLint v1, GLint v2);
void glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3); void glUniform1fv(GLint location, GLsizei count, const GLfloat *value);
void glUniform2fv(GLint location, GLsizei count, const GLfloat *value);
void glUniform3fv(GLint location, GLsizei count, const GLfloat *value);
void glUniform4fv(GLint location, GLsizei count, const GLfloat *value);
void glUniform1iv(GLint location, GLsizei count, const GLint *value);
void glUniform2iv(GLint location, GLsizei count, const GLint *value);
void glUniform3iv(GLint location, GLsizei count, const GLint *value);
void glUniform4iv(GLint location, GLsizei count, const GLint *value); void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
这次 Shader 类对 Uniform 的绑定做一点简单的封装，新定义一个 Uniform 类，实现 Uniform 数据的绑定（一个 Uniform 类对象表示着色器中的一个 Uniform 数据，如果着色器存在多个 Uniform 数据，则 Shader 也相应有 Uniform 对象数组）。首先定义 Uniform 类型枚举
enum UniformType
{
UT_1I, UT_1F,
UT_2I, UT_2F,
UT_3I, UT_3F,
UT_4I, UT_4F, UT_TEXTURE
};
这次绑定 Uniform 数据不包括数组和矩阵，只是一些绑定简单的数据。
要绑定一个 Uniform 数据，需要绑定点 location 和值 value，故 Uniform 类成员属性如下
int nLocation;
UniformType uniformType;
float fV0, fV1, fV2, fV3;
当绑定一个 float 数据时使用 fV0，如果绑定 vec2 数据则使用 fV0 和 fV1（后两个不使用），其他情况类似。
下面看具体的绑定函数
bool bind(int tex = )
{
switch ( uniformType ) {
case Simple2D::Uniform::UT_1I:
glUniform1i(nLocation, fV0);
break;
case Simple2D::Uniform::UT_1F:
glUniform1f(nLocation, fV0);
break;
case Simple2D::Uniform::UT_2I:
glUniform2i(nLocation, fV0, fV1);
break;
case Simple2D::Uniform::UT_2F:
glUniform2f(nLocation, fV0, fV1);
break;
case Simple2D::Uniform::UT_3I:
glUniform3i(nLocation, fV0, fV1, fV2);
break;
case Simple2D::Uniform::UT_3F:
glUniform3f(nLocation, fV0, fV1, fV2);
break;
case Simple2D::Uniform::UT_4I:
glUniform4i(nLocation, fV0, fV1, fV2, fV3);
break;
case Simple2D::Uniform::UT_4F:
glUniform4f(nLocation, fV0, fV1, fV2, fV3);
break;
case Simple2D::Uniform::UT_TEXTURE:
glActiveTexture(GL_TEXTURE0 + tex);
glBindTexture(GL_TEXTURE_2D, fV0);
glUniform1i(nLocation, tex);
return true;
}
return false;
}
函数的最后实现的是绑定纹理的功能，设置纹理到着色器，我们可以使用 glActiveTexture 激活纹理单元，传入我们需要使用的纹理单元：
glActiveTexture(GL_TEXTURE0); // 在绑定纹理之前先激活纹理单元
glBindTexture(GL_TEXTURE_2D, texture);
glUniform1i(location, 0);
激活纹理单元之后，接下来的 glBindTexture 函数调用会绑定这个纹理到当前激活的纹理单元，最后的 glUniform1i 函数传入纹理单元序号 0（纹理单元 GL_TEXTURE8 的序号为 8） 参数实现将纹理设置到着色器。纹理单元 GL_TEXTURE0 默认总是被激活，所以我们只有一张纹理时使用 glBindTexture 的时候，无需激活任何纹理单元。
OpenG L至少保证有 16 个纹理单元供你使用，也就是说你可以激活从 GL_TEXTURE0 到 GL_TEXTURE15。它们都是按顺序定义的，所以我们也可以通过GL_TEXTURE0 + 8 的方式获得 GL_TEXTURE8。
如果我要使用 Shader 绑定一个 vec2 数据，希望可以通过这样的代码实现：
shader->getUniformByName("valueName")->setValue(, );
主要是 getUniformByName 和 setValue 函数的实现：
Uniform* Shader::getUniformByName(const char* name)
{
int location = glGetUniformLocation(program, name);
assert(location != -); auto it = mUniforms.find(location);
if ( it != mUniforms.end() ) {
return &it->second;
} return &mUniforms.insert(std::make_pair(location, Uniform(location))).first->second;
}
Shader 有一张 Uniform 数据表：
std::map<int, Uniform> mUniforms;
绑定点可以索引到 Uniform 数据，函数 getUniformByName 一开始根据 Uniform 名称查找其绑定点 location，然后通过 location 查找 Uniform 数据表，有就直接返回 Uniform，否则插入一个新的 Uniform 后返回。
接下来就是将值储存到 Uniform 对象中：
void setValue(int v0) { uniformType = UT_1I; fV0 = v0; }
void setValue(float v0) { uniformType = UT_1F; fV0 = v0; }
void setValue(int v0, int v1) { uniformType = UT_2I; fV0 = v0; fV1 = v1; }
void setValue(float v0, float v1) { uniformType = UT_2F; fV0 = v0; fV1 = v1; }
void setValue(int v0, int v1, int v2) { uniformType = UT_3I; fV0 = v0; fV1 = v1; fV2 = v2; }
void setValue(float v0, float v1, float v2) { uniformType = UT_3F; fV0 = v0; fV1 = v1; fV2 = v2; }
void setValue(int v0, int v1, int v2, int v3) { uniformType = UT_4I; fV0 = v0; fV1 = v1; fV2 = v2; fV3 = v3; }
void setValue(float v0, float v1, float v2, float v3) { uniformType = UT_4F; fV0 = v0; fV1 = v1; fV2 = v2; fV3 = v3; }
void setTexture(int v0) { uniformType = UT_TEXTURE; fV0 = v0; }
最后，在 Shader 的 bindUniform 函数实现 Shader 中所有 Uniform 的绑定：
void Shader::bindUniform()
{
int tex = ;
for ( auto& ele : mUniforms ) {
if ( ele.second.bind(tex) ) {
tex++;
}
}
}
就是调用 Uniform 的 bind 函数而已。
Shader 简易封装到此结束，源码在完成重构渲染器后给出。