先来一张好康的图，让我们开始进入纹理章节！
一.前言
文档地址:https://learnopengl-cn.github.io/01%20Getting%20started/06%20Textures/#_2,本文主要对该文档的纹理相关知识点作部分总结;
二.纹理
2.1我们已经了解到，我们可以为每个顶点添加颜色来增加图形的细节，从而创建出有趣的图像。但是，如果想让图形看起来更真实，我们就必须有足够多的顶点，从而指定足够多的颜色。这将会产生很多额外开销，因为每个模型都会需求更多的顶点，每个顶点又需求一个颜色属性。
艺术家和程序员更喜欢使用纹理(Texture)。纹理是一个2D图片（甚至也有1D和3D的纹理），它可以用来添加物体的细节；你可以想象纹理是一张绘有砖块的纸，无缝折叠贴合到你的3D的房子上，这样你的房子看起来就像有砖墙外表了。因为我们可以在一张图片上插入非常多的细节，这样就可以让物体非常精细而不用指定额外的顶点。
除了图像以外，纹理也可以被用来储存大量的数据，这些数据可以发送到着色器上。
2.2为了能够把纹理映射(Map)到三角形上，我们需要指定三角形的每个顶点各自对应纹理的哪个部分。这样每个顶点就会关联着一个纹理坐标(Texture Coordinate)，用来标明该从纹理图像的哪个部分采样（译注：采集片段颜色）。之后在图形的其它片段上进行片段插值(Fragment Interpolation)。
纹理坐标在x和y轴上，范围为0到1之间（注意我们使用的是2D纹理图像）。使用纹理坐标获取纹理颜色叫做采样(Sampling)。纹理坐标起始于(0, 0)，也就是纹理图片的左下角，终始于(1, 1)，即纹理图片的右上角。下面的图片展示了我们是如何把纹理坐标映射到三角形上的。
我们为三角形指定了3个纹理坐标点。如上图所示，我们希望三角形的左下角对应纹理的左下角，因此我们把三角形左下角顶点的纹理坐标设置为(0, 0)；三角形的上顶点对应于图片的上中位置所以我们把它的纹理坐标设置为(0.5, 1.0)；同理右下方的顶点设置为(1, 0)。我们只要给顶点着色器传递这三个纹理坐标就行了，接下来它们会被传片段着色器中，它会为每个片段进行纹理坐标的插值。
代码如下:
float texCoords[] = {
0.0f, 0.0f, // 左下角
1.0f, 0.0f, // 右下角
0.5f, 1.0f // 上中
};!!!对纹理采样的解释非常宽松，它可以采用几种不同的插值方式。所以我们需要自己告诉OpenGL该怎样对纹理采样!!!;
三.纹理环绕方式
纹理坐标的范围通常是从(0, 0)到(1, 1)，那如果我们把纹理坐标设置在范围之外会发生什么？OpenGL默认的行为是重复这个纹理图像（我们基本上忽略浮点纹理坐标的整数部分），但OpenGL提供了更多的选择：
前面提到的每个选项都可以使用glTexParameter*函数对单独的一个坐标轴设置（s、t（如果是使用3D纹理那么还有一个r）它们和x、y、z是等价的）：
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT);
//1.第二个选项指定了两个东西:包括设置的选项，以及应用的纹理轴;GL_TEXTURE_WRAP_S就代表配置WRAP选项的S纹理轴;
//2.这里的s,t与x,y等价;!!!第一个参数指定了纹理目标；我们使用的是2D纹理，因此纹理目标是GL_TEXTURE_2D。第二个参数需要我们指定设置的选项与应用的纹理轴。我们打算配置的是WRAP选项，并且指定S和T轴。最后一个参数需要我们传递一个环绕方式(Wrapping)，在这个例子中OpenGL会给当前激活的纹理设定纹理环绕方式为GL_MIRRORED_REPEAT。
注意:如果我们选择GL_CLAMP_TO_BORDER选项，我们还需要指定一个边缘的颜色。这需要使用glTexParameter函数的fv后缀形式，用GL_TEXTURE_BORDER_COLOR作为它的选项，并且传递一个float数组作为边缘的颜色值：
float brodercolor[] = {1.0f,1.0f,1.0f,1.0f};
glTexParameterfv(GL_TEXTURE_2D,GL_TEXTURE_BORDER_COLOR,brodercolor);
//注意在使用GL_REPEAT,GL_MIRROR_REPERT,以及GL_CLAMP_TO_EDGE时用的是glTexParameteri,而此处GL_CLAMP_TO_BORDER用的是glTexParameterfv(另外一种后缀方式),并且传入了定义了其边缘颜色的一个颜色数组;四.纹理过滤
4.1 GL_LINEAR 和GL_NEAREST
纹理坐标不依赖于分辨率(Resolution)，它可以是任意浮点值，所以OpenGL需要知道怎样将纹理像素(Texture Pixel，也叫Texel，译注1)映射到纹理坐标;
OpenGL也有对于纹理过滤(Texture Filtering)的选项。纹理过滤有很多个选项，但是现在我们只讨论最重要的两种：GL_NEAREST和GL_LINEAR:
1.GL_NEAREST（也叫邻近过滤，Nearest Neighbor Filtering）是OpenGL默认的纹理过滤方式。当设置为GL_NEAREST的时候，OpenGL会选择中心点最接近纹理坐标的那个像素。下图中你可以看到四个像素，加号代表纹理坐标。左上角那个纹理像素的中心距离纹理坐标最近，所以它会被选择为样本颜色：
2.GL_LINEAR（也叫线性过滤，(Bi)linear Filtering）它会基于纹理坐标附近的纹理像素，计算出一个插值，近似出这些纹理像素之间的颜色。一个纹理像素的中心距离纹理坐标越近，那么这个纹理像素的颜色对最终的样本颜色的贡献越大。下图中你可以看到返回的颜色是邻近像素的混合色：
那么这两种纹理过滤方式有怎样的视觉效果呢？让我们看看在一个很大的物体上应用一张低分辨率的纹理会发生什么吧（纹理被放大了，每个纹理像素都能看到）：
GL_NEAREST产生了颗粒状的图案，我们能够清晰看到组成纹理的像素，而GL_LINEAR能够产生更平滑的图案，很难看出单个的纹理像素。GL_LINEAR可以产生更真实的输出，但有些开发者更喜欢8-bit风格，所以他们会用GL_NEAREST选项;
!!!当进行放大(Magnify)和缩小(Minify)操作的时候可以设置纹理过滤的选项，比如你可以在纹理被缩小的时候使用邻近过滤，被放大时使用线性过滤。我们需要使用glTexParameter*函数为放大和缩小指定过滤方式。这段代码看起来会和纹理环绕方式的设置很相似：
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
//以第一句代码为例，GL_TEXTURE_MIN_FILTER表示在进行缩小操作时，设置纹理过滤的选项,后面的GL_NEAREST则代表要选择线性过滤还是邻近过滤;
//MIN为缩小minify;MAG为放大magnify;4.2多级渐远纹理
4.2.1想象一下，假设我们有一个包含着上千物体的大房间，每个物体上都有纹理。有些物体会很远，但其纹理会拥有与近处物体同样高的分辨率。由于远处的物体可能只产生很少的片段，OpenGL从高分辨率纹理中为这些片段获取正确的颜色值就很困难，因为它需要对一个跨过纹理很大部分的片段只拾取一个纹理颜色。在小物体上这会产生不真实的感觉，更不用说对它们使用高分辨率纹理浪费内存的问题了。
OpenGL使用一种叫做多级渐远纹理(Mipmap)的概念来解决这个问题，它简单来说就是一系列的纹理图像，后一个纹理图像是前一个的二分之一。多级渐远纹理背后的理念很简单：距观察者的距离超过一定的阈值，OpenGL会使用不同的多级渐远纹理，即最适合物体的距离的那个。由于距离远，解析度不高也不会被用户注意到。同时，多级渐远纹理另一加分之处是它的性能非常好。让我们看一下多级渐远纹理是什么样子的：
手工为每个纹理图像创建一系列多级渐远纹理很麻烦，但OpenGL有一个glGenerateMipmaps函数，在创建完一个纹理后调用它OpenGL就会承担接下来的所有工作了!!!;
4.2.2在渲染中切换多级渐远纹理级别(Level)时，OpenGL在两个不同级别的多级渐远纹理层之间会产生不真实的生硬边界。就像普通的纹理过滤一样，切换多级渐远纹理级别时你也可以在两个不同多级渐远纹理级别之间使用NEAREST和LINEAR过滤。为了指定不同多级渐远纹理级别之间的过滤方式，你可以使用下面四个选项中的一个代替原有的过滤方式：
和纹理过滤一样，我们可以通过glTexParameteri函数将过滤方式设置为前面四种提到的方法之一：
glTexParametri(GL_TEXTURE_2D,GL_TEXTURE_MIN_LINEAR,GL_LINEAR_MIPMAP_NEAREST);
glTexParametri(GL_TEXTURE_2D,GL_TEXTURE_MAX_NEAREST,GL_LINEAR);//此段代码会报错;
//要注意多级渐远纹理只会应用在缩小纹理的选项当中，而不会出现在放大纹理的选项当中;一个常见的错误是，将放大过滤的选项设置为多级渐远纹理过滤选项之一。这样没有任何效果，因为多级渐远纹理主要是使用在纹理被缩小的情况下的：纹理放大不会使用多级渐远纹理，为放大过滤设置多级渐远纹理的选项会产生一个GL_INVALID_ENUM错误代码!!!。
五.加载与创建纹理
使用纹理之前要做的第一件事是把它们加载到我们的应用中。纹理图像可能被储存为各种各样的格式，每种都有自己的数据结构和排列，所以我们如何才能把这些图像加载到应用中呢？
5.1方法一
一个解决方案是选一个需要的文件格式，比如.PNG，然后自己写一个图像加载器，把图像转化为字节序列。写自己的图像加载器虽然不难，但仍然挺麻烦的，而且如果要支持更多文件格式呢？你就不得不为每种你希望支持的格式写加载器了。
5.2方法二
另一个解决方案也许是一种更好的选择，使用一个支持多种流行格式的图像加载库来为我们解决这个问题。比如说我们要用的stb_image.h库。
六.stb_image.h库
stb_image.h是Sean Barrett的一个非常流行的单头文件图像加载库，它能够加载大部分流行的文件格式，并且能够很简单得整合到你的工程之中。该头文件下载地址如下:
https://github.com/nothings/stb/blob/master/stb_image.h
下载这一个头文件，将它以stb_image.h的名字加入你的工程，并另创建一个新的C++文件，输入以下代码：
#define STB_IMAGE_IMPLEMENTATION
//这里定义了STB_IMAGE_IMPLEMENTATION,预处理器会修改头文件，让其仅包含相关的函数定义源码，等于是将这个头文件变成一个.cpp文件;
#include"stb_image.h"通过定义STB_IMAGE_IMPLEMENTATION，预处理器会修改头文件，让其只包含相关的函数定义源码，等于是将这个头文件变为一个 .cpp 文件了。
现在只需要在你的程序中包含stb_image.h并编译就可以了。
下面的教程中，我们会使用一张木箱的图片。要使用stb_image.h加载图片，我们需要使用它的stbi_load函数：
int width,height,nrChannels;
unsigned char*data = stbi_load("container.jpg",&width,&height,&nrChannels,0);
//stbi_load函数需要传入图片文件的位置(第一个参数)以及三个int类型的参数，分别用图像的宽度，高度，颜色通道的个数来进行填充;这个函数首先接受一个图像文件的位置作为输入。接下来它需要三个int作为它的第二、第三和第四个参数，stb_image.h将会用图像的宽度、高度和颜色通道的个数填充这三个变量。我们之后生成纹理的时候会用到的图像的宽度和高度的。
七.生成纹理
和之前生成的OpenGL对象一样，纹理也是使用ID引用的。让我们来创建一个：
unsigned int texture;
glGenTextures(1,&texture);
//glGenTexture函数要输入生成纹理的数量，并存储到第二个参数的unsigned int 数组中;就像其他对象一样，我们需要绑定它，让之后任何的纹理指令都可以配置当前绑定的纹理：
glBindTexture(GL_TEXTURE_2D,texture);
//将texture绑定到GL_TEXTURE_2D中;现在纹理已经绑定了，我们可以使用前面载入的图片数据生成一个纹理了。纹理可以通过glTexImage2D函数来生成：
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
//第一个参数指定纹理目标为2D;第二个参数为多级渐远纹理的级别，此处为最低级别0;第三个告诉OpenGL我们希望把纹理存储为RGB值(因为图形只有RGB值);第四第五个参数为纹理的宽高;第七第八个参数定义了源图的格式和数据类型，我们使用RGB加载图像，并存储为char(byte)数组;最后为真正的图形数据;d
glGenerateMipmap(GL_TEXTURE_2D);//由于上一步仅生成了原本的纹理图，采用glGenerateMipmap可以自动产生很多的多级渐远纹理;第一个参数指定了纹理目标(Target)。设置为GL_TEXTURE_2D意味着会生成与当前绑定的纹理对象在同一个目标上的纹理（任何绑定到GL_TEXTURE_1D和GL_TEXTURE_3D的纹理不会受到影响）。
第二个参数为纹理指定多级渐远纹理的级别，如果你希望单独手动设置每个多级渐远纹理的级别的话。这里我们填0，也就是基本级别。
第三个参数告诉OpenGL我们希望把纹理储存为何种格式。我们的图像只有RGB值，因此我们也把纹理储存为RGB值。
第四个和第五个参数设置最终的纹理的宽度和高度。我们之前加载图像的时候储存了它们，所以我们使用对应的变量。
下个参数应该总是被设为0（历史遗留的问题）。
第七第八个参数定义了源图的格式和数据类型。我们使用RGB值加载这个图像，并把它们储存为char(byte)数组，我们将会传入对应值。
最后一个参数是真正的图像数据。
!!!当调用glTexImage2D时，当前绑定的纹理对象就会被附加上纹理图像(也就是使用glTexImage2D函数后，texture纹理对象就被附加上纹理图像)。
!!!然而，目前只有基本级别(Base-level)的纹理图像被加载了，如果要使用多级渐远纹理，我们必须手动设置所有不同的图像（不断递增第二个参数）。或者，直接在生成纹理之后调用glGenerateMipmap。这会为当前绑定的纹理自动生成所有需要的多级渐远纹理。
生成了纹理和相应的多级渐远纹理后，我们要记得释放图像的内存:
stib_image_free(data);//将先前通过stbi_load函数加载的图片数据data;生成纹理的过程大致如下:
unsigned int texture;
glGenTextures(1, &texture);//首先要创建一个纹理对象;
glBindTexture(GL_TEXTURE_2D, texture);//进行绑定,之后任何的纹理指令都可以配置当前绑定的纹理;
//为纹理设置环绕和过滤的方式:
//环绕方式的设置，注意设置选项为WRAP;
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT);
//过滤方式的设置;
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);//图片缩小过滤选项使用邻近过滤;
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);//图片放大过滤选项使用线性过滤;
//开始加载并生成纹理;
//先采用stib_load函数来加载纹理;
int width, height, urChannels;
unsigned char* data = stbi_load("container.jpg", &width, &height, &urChannels, 0);
//接着用glTexImage2D函数将纹理附加到绑定的纹理对象texture上面去;
if (data)//如果获取到图像信息的话;
{
//附加纹理到对象;
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
//同时调用glGenerateMipmap函数来生成绑定的纹理对象的其他多级渐远纹理;
glGenerateMipmap(GL_TEXTURE_2D);
}
else
{
std::cout << "Fail to load a Image" << std::endl;
}
stbi_image_free(data);//最后不要忘了释放图像的内存;八.应用纹理
8.1顶点属性更新相关操作
后面的这部分我们会使用glDrawElements绘制「你好，三角形」教程最后一部分的矩形。我们需要告知OpenGL如何采样纹理，所以我们必须使用纹理坐标更新顶点数据：
float vertices[] = {
// ---- 位置 ---- ---- 颜色 ---- - 纹理坐标 -
0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, // 右上
0.5f, -0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, // 右下
-0.5f, -0.5f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, // 左下
-0.5f, 0.5f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f // 左上
};
//由于加入了新的顶点属性，因此我们要对顶点属性的链接做进一步的修改;由于我们添加了一个额外的顶点属性，我们必须告诉OpenGL我们新的顶点格式,如下图所示:
现在一个顶点就包含了32个字节，3个顶点属性,步长也要从两个属性时的6*sizeof(float)变到三个属性值时的8*sizeof(float);同时，对于新的属性链接也要注意偏移量为(void*)(6*sizeof(float));
同样，我们也要对顶点着色器和片段着色器做出调整:
//顶点属性链接;
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)0);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(6 * sizeof(float)));
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(6 * sizeof(float)));
//启动顶点属性;
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
glEnableVertexAttribArray(2);//启用新的顶点属性，纹理;接着我们需要调整顶点着色器使其能够接受顶点坐标为一个顶点属性，并把坐标传给片段着色器：
#version 330 core
layout(location = 0) in vec3 aPos;
layout(location = 1) in vec3 aColor;
layout(location = 2) in vec2 aTexCoord;
out vec3 OurColor;
out vec2 TexCoord;
void main()
{
gl_Position = vec4(aPos,1.0);
OurColor = aColor;
TexCoord = aTexCoord;
}片段着色器应该接下来会把输出变量TexCoord作为输入变量.
片段着色器也应该能访问纹理对象，但是我们怎样能把纹理对象传给片段着色器呢？GLSL有一个供纹理对象使用的内建数据类型，叫做采样器(Sampler)，它以纹理类型作为后缀，比如sampler1D、sampler3D，或在我们的例子中的sampler2D。我们可以简单声明一个uniform sampler2D把一个纹理添加到片段着色器中，稍后我们会把纹理赋值给这个uniform。
//片段着色器源码:
#version 330 core
in vec3 OurColor;
in vec2 TexCoord;
out vec4 FragColor;
//这里声明一个uniform sample2D 把纹理添加到片段着色器中;
uniform sample2D OurTexture;
void main()
{
FragColor = texture(OurTexture,TexCoord);
//第一个参数是纹理采样器，第二个参数为纹理坐标;
//这个输出的颜色就是纹理的（插值）纹理坐标上的(过滤后的)颜色。
}我们使用GLSL内建的texture函数来采样纹理的颜色，它第一个参数是纹理采样器，第二个参数是对应的纹理坐标。texture函数会使用之前设置的纹理参数对相应的颜色值进行采样。这个片段着色器的输出就是纹理的（插值）纹理坐标上的(过滤后的)颜色；
现在只剩下在调用glDrawElements之前绑定纹理了，它会自动把纹理赋值给片段着色器的采样器：
shader.useProgram();//启动着色器;
//绑定纹理;
glBindTexture(GL_TEXTURE_2D, texture);//!!在调用glDrawElements之前绑定纹理，它会自动把纹理赋值给片段着色器的采样器
glBindVertexArray(VAO);//绑定VAO
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0); 8.2main.cpp
下面是main.cpp的全部代码:
#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include<E:\OpenGl\1\shader s.h>
#include <iostream>
#define STB_IMAGE_IMPLEMENTATION
#include <E:/OpenGl/stb_image.h/stb-master/stb_image.h>//这两行代码加入了stb_image库;
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);
#ifdef __APPLE__
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
#endif
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;
}
//开始绘制三角形;
float vertices[] = {
// ---- 位置 ---- ---- 颜色 ---- - 纹理坐标 -
0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, // 右上
0.5f, -0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, // 右下
-0.5f, -0.5f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, // 左下
-0.5f, 0.5f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f // 左上
};
unsigned int indices[] =
{
0,1,3,
1,2,3
};
unsigned int VAO, VBO,EBO;
glGenBuffers(1, &VBO);
glGenVertexArrays(1, &VAO);
glGenBuffers(1, &EBO);
glBindVertexArray(VAO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,EBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
//顶点属性链接(位置-颜色-纹理);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)0);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(3 * sizeof(float)));//颜色的偏移量为3个float;
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(6 * sizeof(float)));//纹理坐标的偏移量是6个float;
//启动顶点属性;
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
glEnableVertexAttribArray(2);//启用新的顶点属性，纹理;
glBindVertexArray(0);
//着色器程序构建;
Shader shader("3.3.shader.vs", "3.3.shader.fs");
unsigned int texture;
glGenTextures(1, &texture);//首先要创建一个纹理对象;
glBindTexture(GL_TEXTURE_2D, texture);//进行绑定,之后任何的纹理指令都可以配置当前绑定的纹理;
//为纹理设置环绕和过滤的方式:
//环绕方式的设置，注意设置选项为WRAP;
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
//过滤方式的设置;
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);//图片缩小过滤选项使用邻近过滤;
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);//图片放大过滤选项使用线性过滤;
//开始加载并生成纹理;
//先采用stib_load函数来加载纹理;
int width, height, nrChannels;
unsigned char* data = stbi_load("E:/OpenGl/textures/container.jpg", &width, &height, &nrChannels, 0);
//unsigned char* data = stbi_load("container.jpg", &width, &height, &urChannels, 0);
//接着用glTexImage2D函数将纹理附加到绑定的纹理对象texture上面去;
if (data)//如果获取到图像信息的话;
{
//附加纹理到对象;
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
//同时调用glGenerateMipmap函数来生成绑定的纹理对象的其他多级渐远纹理;
glGenerateMipmap(GL_TEXTURE_2D);
}
else
{
std::cout << "Fail to load a Image" << std::endl;
}
stbi_image_free(data);//最后不要忘了释放图像的内存;
while (!glfwWindowShouldClose(window))
{
// input
// -----
processInput(window);
// render
// ------
glClearColor(0.1f, 0.1f, 0.2f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT);
shader.useProgram();//启动着色器;
//绑定纹理;
glBindTexture(GL_TEXTURE_2D, texture);//!!在调用glDrawElements之前绑定纹理，它会自动把纹理赋值给片段着色器的采样器
glBindVertexArray(VAO);//绑定VAO
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
glfwSwapBuffers(window);
glfwPollEvents();
}
// glfw: terminate, clearing all previously allocated GLFW resources.
glDeleteVertexArrays(1, &VAO);
glDeleteBuffers(1, &VBO);
glDeleteBuffers(1, &EBO);
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)
{
// make sure the viewport matches the new window dimensions; note that width and
// height will be significantly larger than specified on retina displays.
glViewport(0, 0, width, height);
}结果如下：
我们还可以把得到的纹理颜色与顶点颜色混合，来获得更有趣的效果。我们只需把纹理颜色与顶点颜色在片段着色器中相乘来混合二者的颜色，结果如下：
感觉好看一点？;
我们也可以换其他的纹理(调了下三角形的大小)：
好看捏!!!;
九.纹理单元
你可能会奇怪为什么sampler2D变量是个uniform，我们却不用glUniform给它赋值。[对的，我在看文档时就感觉到很怪，一直想不明白];
使用glUniform1i，我们可以给纹理采样器分配一个位置值，这样的话我们能够在一个片段着色器中设置多个纹理。一个纹理的位置值通常称为一个纹理单元(Texture Unit)。一个纹理的默认纹理单元是0，它是默认的激活纹理单元，所以教程前面部分我们没有分配一个位置值。
纹理单元的主要目的是让我们在着色器中可以使用多于一个的纹理。通过把纹理单元赋值给采样器，我们可以一次绑定多个纹理，只要我们首先激活对应的纹理单元。就像glBindTexture一样，我们可以使用glActiveTexture激活纹理单元，传入我们需要使用的纹理单元：
glActiveTexture(GL_TEXTURE0); // 在绑定纹理之前先激活纹理单元
glBindTexture(GL_TEXTURE_2D, texture);激活纹理单元之后，接下来的glBindTexture函数调用会绑定这个纹理到当前激活的纹理单元，纹理单元GL_TEXTURE0默认总是被激活，所以我们在前面的例子里当我们使用glBindTexture的时候，无需激活任何纹理单元。
[["OpenGL至少保证有16个纹理单元供你使用，也就是说你可以激活从GL_TEXTURE0到GL_TEXTRUE15。它们都是按顺序定义的，所以我们也可以通过GL_TEXTURE0 + 8的方式获得GL_TEXTURE8，这在当我们需要循环一些纹理单元的时候会很有用。"]]
我们仍然需要编辑片段着色器来接收另一个采样器:
#version 330 core
...
uniform sampler2D texture1;
uniform sampler2D texture2;
void main()
{
FragColor = mix(texture(texture1, TexCoord), texture(texture2, TexCoord), 0.2);
//texture函数是用来获取对应纹理坐标颜色的;
}最终输出颜色现在是两个纹理的结合。GLSL内建的mix函数需要接受两个值作为参数，并对它们根据第三个参数进行线性插值。如果第三个值是0.0，它会返回第一个输入；如果是1.0，会返回第二个输入值。0.2会返回80%的第一个输入颜色和20%的第二个输入颜色，即返回两个纹理的混合色。
我们可以载入并创建另外一张纹理,这一部分的步骤和上面类似;
为了使用第二个纹理（以及第一个），我们必须改变一点渲染流程:
1.绑定两个纹理到对应的纹理单元，
2.然后定义哪个uniform采样器对应哪个纹理单元：
glActiveTexture(GL_TEXTURE0);//启动纹理单元0;(其实这个已经默认是启动的);
glBindTexture(GL_TEXTURE_2D, texture1);//!!在调用glDrawElements之前绑定纹理，它会自动把纹理赋值给片段着色器的采样器
//前面两步会将纹理绑定到纹理单元上;
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, texture2);
//上面两个步骤将新的纹理绑定到一个新的纹理单元上;
//下面要告诉OpenGL哪个采样器对应哪一个纹理单元,由于仅需要进行一次，因此可以放在循环之前;//此处由于要进行下面操作，要先进行shader.useProgram();
shader.useProgram();//先激活着色器;
shader.setInt("OurTexture1", 0);//设置uniform变量OurTexture1对应纹理单元0;
shader.setInt("OurTexture2", 1);//设置uniform变量OurTexture2对应纹理单元1;
//可以理解为在片段着色器中的uniform sampler2D OurTexture1,2接收的就是对应第几个(从0开始)纹理单元;对于通过使用glUniform1i设置每个采样器的方式告诉OpenGL每个着色器采样器属于哪个纹理单元：我们只需要设置一次即可，所以这个会放在渲染循环的前面：
main.cpp
此时的main.cpp函数：
#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include<E:\OpenGl\1\shader s.h>
#include <iostream>
#define STB_IMAGE_IMPLEMENTATION
#include <E:/OpenGl/stb_image.h/stb-master/stb_image.h>//这两行代码加入了stb_image库;
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);
#ifdef __APPLE__
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
#endif
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;
}
//开始绘制三角形;
float vertices[] = {
// ---- 位置 ---- ---- 颜色 ---- - 纹理坐标 -
1.0f, 0.8f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, // 右上
1.0f, -0.8f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, // 右下
-1.0f, -0.8f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, // 左下
-1.0f, 0.8f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f // 左上
};
unsigned int indices[] =
{
0,1,3,
1,2,3
};
unsigned int VAO, VBO,EBO;
glGenBuffers(1, &VBO);
glGenVertexArrays(1, &VAO);
glGenBuffers(1, &EBO);
glBindVertexArray(VAO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,EBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
//顶点属性链接(位置-颜色-纹理);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)0);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(3 * sizeof(float)));//颜色的偏移量为3个float;
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(6 * sizeof(float)));//纹理坐标的偏移量是6个float;
//启动顶点属性;
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
glEnableVertexAttribArray(2);//启用新的顶点属性，纹理;
glBindVertexArray(0);
//着色器程序构建;
Shader shader("3.3.shader.vs", "3.3.shader.fs");
//纹理1.
unsigned int texture1;
glGenTextures(1, &texture1);//首先要创建一个纹理对象;
glBindTexture(GL_TEXTURE_2D, texture1);//进行绑定,之后任何的纹理指令都可以配置当前绑定的纹理;
//为纹理对象设置环绕和过滤的方式:
//环绕方式的设置，注意设置选项为WRAP;
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
//过滤方式的设置;
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);//图片缩小过滤选项使用邻近过滤;
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);//图片放大过滤选项使用线性过滤;
//开始加载并生成纹理;
//先采用stib_load函数来加载纹理;
int width, height, nrChannels;
unsigned char* data = stbi_load("E:/OpenGl/textures/840dbb9ec1f64948a991657c37373e08.jpg", &width, &height, &nrChannels, 0);
//unsigned char* data = stbi_load("container.jpg", &width, &height, &urChannels, 0);
//接着用glTexImage2D函数将纹理附加到绑定的纹理对象texture上面去;
if (data)//如果获取到图像信息的话;
{
//附加纹理到对象;
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
//同时调用glGenerateMipmap函数来生成绑定的纹理对象的其他多级渐远纹理;
glGenerateMipmap(GL_TEXTURE_2D);
}
else
{
std::cout << "Fail to load a Image" << std::endl;
}
stbi_image_free(data);//最后不要忘了释放图像的内存;
//纹理2:
unsigned int texture2;//创建第二张纹理;
glGenTextures(1, &texture2);//首先创建一个纹理对象;
glBindTexture(GL_TEXTURE_2D, texture2);//绑定，使后面的纹理操作都可以对该绑定纹理进行操作;
//为纹理设置环绕方式以及过滤方式;
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT);
//过滤方式;
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR);
//加载纹理;
int width1, height1, nrchannels1;
unsigned char* data1 = stbi_load("E:/OpenGl/textures/6b8d8968424f7c14a4ddfeee848f6cfd.jpg", &width1, &height1, &nrchannels1,0);
if (data1)//如果加载到数据;
{
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width1, height1, 0, GL_RGB, GL_UNSIGNED_BYTE, data1);
//最后data1为传入的图片的值;
glGenerateMipmap(GL_TEXTURE_2D);
}
stbi_image_free(data1);//最后同样不要忘了清除数据;
//此处由于要进行下面操作，要先进行shader.useProgram();
shader.useProgram();//先激活着色器;
shader.setInt("OurTexture1", 0);//设置uniform变量OurTexture1对应纹理单元0;
shader.setInt("OurTexture2", 1);//设置uniform变量OurTexture2对应纹理单元1;
while (!glfwWindowShouldClose(window))
{
// input
// -----
processInput(window);
// render
// ------
glClearColor(0.1f, 0.1f, 0.2f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT);
//shader.useProgram();//启动着色器;
glActiveTexture(GL_TEXTURE0);//启动纹理单元0;(其实这个已经默认是启动的);
glBindTexture(GL_TEXTURE_2D, texture1);//!!在调用glDrawElements之前绑定纹理，它会自动把纹理赋值给片段着色器的采样器
//前面两步会将纹理绑定到纹理单元上;
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, texture2);
//上面两个步骤将新的纹理绑定到一个新的纹理单元上;
//下面要告诉OpenGL哪个采样器对应哪一个纹理单元,由于仅需要进行一次，因此可以放在循环之前;
glBindVertexArray(VAO);//绑定VAO
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
glfwSwapBuffers(window);
glfwPollEvents();
}
// glfw: terminate, clearing all previously allocated GLFW resources.
glDeleteVertexArrays(1, &VAO);
glDeleteBuffers(1, &VBO);
glDeleteBuffers(1, &EBO);
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)
{
// make sure the viewport matches the new window dimensions; note that width and
// height will be significantly larger than specified on retina displays.
glViewport(0, 0, width, height);
}3.3.shader.fs
顶点着色器文件代码:
#version 330 core
in vec3 OurColor;
in vec2 TexCoord;
out vec4 FragColor;
uniform sampler2D OurTexture1;//2D采样器1;
uniform sampler2D OurTexture2;//2D采样器2;
void main()
{
FragColor = mix(texture(OurTexture1,TexCoord),texture(OurTexture2,TexCoord),0.2);
//texture函数用来获取纹理坐标对应的颜色，其中两个参数分别为纹理采样器，以及纹理坐标;
}结果:
我加了下面这个图：
是不是发现反过来了？
这是因为OpenGL要求y轴0.0坐标是在图片的底部的，但是图片的y轴0.0坐标通常在顶部。很幸运，stb_image.h能够在图像加载时帮助我们翻转y轴，只需要在加载任何图像前加入以下语句即可：
stbi_set_flip_vertically_on_load(true);
//注意是在每一次的加载纹理之前，也就是在以下两句之前：stbi_set_flip_vertically_on_load(true);//酱紫就不会出现上下颠倒辣!!!;
int width,height,nrchannels;
unsigned char*data = stbi_load("name",&width,&height,&nrchannels,0);结果:
很好看是不是捏!!!!,下面改了以下系数;
十.作业
作业2：
尝试用不同的纹理环绕方式，设定一个从0.0f到2.0f范围内的（而不是原来的0.0f到1.0f）纹理坐标。记得一定要试试其它的环绕方式。
以下我都使用了GL_MIRRORED_REPEAT的环绕方式:
float vertices[] = {
// ---- 位置 ---- ---- 颜色 ---- - 纹理坐标 -
1.0f, 0.8f, 0.0f, 1.0f, 0.0f, 0.0f, 2.0f, 2.0f, // 右上
1.0f, -0.8f, 0.0f, 0.0f, 1.0f, 0.0f, 2.0f, 0.0f, // 右下
-1.0f, -0.8f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, // 左下
-1.0f, 0.8f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 2.0f // 左上
};//为纹理对象设置环绕和过滤的方式:
//环绕方式的设置，注意设置选项为WRAP;
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT);
//过滤方式的设置;
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);//图片缩小过滤选项使用邻近过滤;
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);//图片放大过滤选项使用线性过滤;结果：
作业3:
尝试在矩形上只显示纹理图像的中间一部分，修改纹理坐标，达到能看见单个的像素的效果:
上面采用的是GL_NEAREST的环绕方式，后面一张采用的是GL_LINEAR,还是可以看出上一张的像素较为明显,下一张较为平滑;
作业4：
使用一个uniform变量作为mix函数的第三个参数来改变两个纹理可见度，通过上下键来改变颜色;
//设置一个全局变量;
float Textime = 0.2f;//在processInput做出以下修改;
void processInput(GLFWwindow* window)
{
if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
glfwSetWindowShouldClose(window, true);
if (glfwGetKey(window, GLFW_KEY_UP) == GLFW_PRESS)
{
Textime += 0.001f; // change this value accordingly (might be too slow or too fast based on system hardware)
if (Textime >= 1.0f)
Textime = 1.0f;
}
if (glfwGetKey(window, GLFW_KEY_DOWN) == GLFW_PRESS)
{
Textime -= 0.001f; // change this value accordingly (might be too slow or too fast based on system hardware)
if (Textime <= 0.0f)
Textime = 0.0f;
}
}片元着色器:
#version 330 core
in vec3 OurColor;
in vec2 TexCoord;
out vec4 FragColor;
uniform sampler2D OurTexture1;//2D采样器1;
uniform sampler2D OurTexture2;//2D采样器2;
uniform float Textime;
void main()
{
FragColor = mix(texture(OurTexture1,TexCoord),texture(OurTexture2,TexCoord),Textime);
//texture函数用来获取纹理坐标对应的颜色，其中两个参数分别为纹理采样器，以及纹理坐标;
}好，结束。
3222
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
