• OpenGL学习

    免费课程：计算机图形学OpenGL：5.2、缩放，旋转，位移_哔哩哔哩_bilibili 

    付费课程：计算机图形学OpenGL【合集】大礼包_腾讯课堂 

    我看的是免费版的 

    1.1，状态机-上下文-对象

    GPU渲染流程 

    OpenGL自身是一个巨大的状态机(State Machine)：一系列的变量描述OpenGL此刻应当如何运行。

    状态机：变量（描述该如何操作）的大集合

    OpenGL的状态通常被称为OpenGL上下文(Context)。

    对象（Object）：类似一个结构体 

    在OpenGL中一个对象是指一些选项的集合，它代表OpenGL状态的一个子集

     

     1.2，创建一个窗口

     1.2.1 GLFW-GLAD

    GLFW解决操作系统层面的不同

    GLAD使代码可以可以用于不同的OpenGL驱动

     注意头文件顺序，glad的include中包含了glfw所需的gl.h文件

    测试代码：

    1. #include 
    2.  
    3. #include 
    4. #include 
    5.  
    6. //用户调整窗口大小之后的回调
    7. void framebuffer_size_callback(GLFWwindow* window, int width, int height)
    8. {
    9. 	glViewport(0, 0, width, height);
    10. }
    11.  
    12. //实现输入控制
    13. void processInput(GLFWwindow* window)
    14. {
    15. 	if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)//检查用户是否按下了返回键(Esc)
    16. 	{
    17. 		glfwSetWindowShouldClose(window, true);
    18. 	}
    19. }
    20. int main()
    21. {
    22. 	glfwInit();	//初始化GLFW
    23. 	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);//主版本号(Major)
    24. 	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);//次版本号(Minor)
    25. 	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);//核心模式(Core-profile)
    26.  
    27. 	GLFWwindow* window = glfwCreateWindow(800, 600, "learnOpenGL", NULL, NULL);
    28. 	if (window == NULL)
    29. 	{
    30. 		std::cout << "Failed to create GLFW window!\n" << std::endl;
    31. 		glfwTerminate();
    32. 		return -1;
    33. 	}
    34. 	glfwMakeContextCurrent(window);//创建完窗口我们就可以通知GLFW将我们窗口的上下文设置为当前线程的主上下文了
    35. 	
    36. 	//初始化glad
    37. 	//glad:加载所有OpenGL的函数指针
    38. 	if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
    39. 	{
    40. 		std::cout << "Failed to initialize GLAD" << std::endl;
    41. 		return -1;
    42. 	}
    43.  
    44. 	//告诉OpenGL渲染窗口的大小
    45. 	glViewport(0, 0, 800, 600);
    46.  
    47. 	//设置窗口大小变化之后的回调
    48. 	glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
    49.  
    50. 	//渲染循环
    51. 	//在窗口结束之前，不断绘制图像，并且能够接收用户的输入
    52. 	while (!glfwWindowShouldClose(window))//检查gldw是否被要求退出
    53. 	{
    54. 		/*
    55. 		双缓冲(Double Buffer)
    56. 		应用程序使用单缓冲绘图时可能会存在图像闪烁的问题。 这是因为生成的图像不是一下子被绘制出来的，
    57. 		而是按照从左到右，由上而下逐像素地绘制而成的。最终图像不是在瞬间显示给用户，而是通过一步一步
    58. 		生成的，这会导致渲染的结果很不真实。为了规避这些问题，我们应用双缓冲渲染窗口应用程序。前缓冲
    59. 		保存着最终输出的图像，它会在屏幕上显示；而所有的的渲染指令都会在后缓冲上绘制。当所有的渲染指
    60. 		令执行完毕后，我们交换(Swap)前缓冲和后缓冲，这样图像就立即呈显出来，之前提到的不真实感就消除了。
    61. 		前缓冲区：屏幕上显示的图片
    62. 		后缓冲区：正在渲染的图片
    63. 		*/
    64. 		/*
    65. 		当调用glClear函数，清除颜色缓冲之后，整个颜色缓冲都会被填充为glClearColor里所设置的颜色。
    66. 		*/
    67. 		// 输入
    68. 		processInput(window);		//检查是否键盘输入
    69.  
    70. 		//渲染指令
    71. 		glClearColor(0.2f, 0.3f, 0.3f, 1.0f);//设置状态
    72. 		glClear(GL_COLOR_BUFFER_BIT);//使用状态
    73.  
    74. 		// 检查并调用事件，交换缓冲
    75. 		glfwSwapBuffers(window);	//交换颜色缓冲（他是一个存储glfw窗口每一个像素颜色值的大缓冲），他在这一迭代中被用来绘制，并且将作为输出显示在屏幕上
    76. 		glfwPollEvents();					//检查有没有触发什么事件，并且调用对应的回调
    77. 	}
    78.  
    79. 	glfwTerminate();
    80. 	return 0;
    81. }

     2.1，渲染管线-VBO-VAO

    在学习此节之前，建议将这三个单词先记下来：

    • 顶点数组对象：Vertex Array Object，VAO
    • 顶点缓冲对象：Vertex Buffer Object，VBO
    • 元素缓冲对象：Element Buffer Object，EBO 或 索引缓冲对象 Index Buffer Object，IBO

     图形渲染管线（Graphics Pipeline，大多译为管线，实际上指的是一堆原始图形数据途经一个输送管道，期间经过各种变化处理最终出现在屏幕的过程）

    图形渲染管线可以被划分为两个主要部分：

    第一部分把你的3D坐标转换为2D坐标，

    第二部分是把2D坐标转变为实际的有颜色的像素。

    渲染和shader

    渲染由一套渲染管线来管理
    shader用来设置一些点线面的位置信息，以及映射图片到纹理这些逻辑，从而拿到图像数据，然后如何处理图像，也可以通过shader来处理。

    图形渲染管线可以被划分为几个阶段，每个阶段将会把前一个阶段的输出作为输入。所有这些阶段都是高度专门化的（它们都有一个特定的函数），并且很容易并行执行。正是由于它们具有并行执行的特性，当今大多数显卡都有成千上万的小处理核心，它们在GPU上为每一个（渲染管线）阶段运行各自的小程序，从而在图形渲染管线中快速处理你的数据。这些小程序叫做着色器(Shader)。

    图形渲染管线的各个阶段的作用：

    1，顶点着色器(Vertex Shader)，它把一个单独的顶点作为输入。顶点着色器主要的目的是把3D坐标转为另一种3D坐标（后面会解释），同时顶点着色器允许我们对顶点属性进行一些基本处理。

    2，图元装配(Primitive Assembly)阶段将顶点着色器输出的所有顶点作为输入（如果是GL_POINTS，那么就是一个顶点），并所有的点装配成指定图元的形状；本节例子中是一个三角形。

    3，图元装配阶段的输出会传递给几何着色器(Geometry Shader)。几何着色器把图元形式的一系列顶点的集合作为输入，它可以通过产生新顶点构造出新的（或是其它的）图元来生成其他形状。例子中，它生成了另一个三角形。

    4，几何着色器的输出会被传入光栅化阶段(Rasterization Stage)，这里它会把图元映射为最终屏幕上相应的像素，生成供片段着色器(Fragment Shader)使用的片段(Fragment)。在片段着色器运行之前会执行裁切(Clipping)。裁切会丢弃超出你的视图以外的所有像素，用来提升执行效率。

    OpenGL中的一个片段是OpenGL渲染一个像素所需的所有数据。

    5，片段着色器的主要目的是计算一个像素的最终颜色，这也是所有OpenGL高级效果产生的地方。通常，片段着色器包含3D场景的数据（比如光照、阴影、光的颜色等等），这些数据可以被用来计算最终像素的颜色。

    6，在所有对应颜色值确定以后，最终的对象将会被传到最后一个阶段，我们叫做Alpha测试和混合(Blending)阶段。这个阶段检测片段的对应的深度（和模板(Stencil)）值（后面会讲），用它们来判断这个像素是其它物体的前面还是后面，决定是否应该丢弃。这个阶段也会检查alpha值（alpha值定义了一个物体的透明度）并对物体进行混合(Blend)。所以，即使在片段着色器中计算出来了一个像素输出的颜色，在渲染多个三角形的时候最后的像素颜色也可能完全不同。

     什么是VAO，VBO？

    VBO用于存放数据，VAO用于描述数据的属性（如何将数据取出来）

    我们的顶点缓冲数据会被解析为下面这样子：

    • 位置数据被储存为32位（4字节）浮点值。
    • 每个位置包含3个这样的值。
    • 在这3个值之间没有空隙（或其他值）。这几个值在数组中紧密排列(Tightly Packed)。
    • 数据中第一个值在缓冲开始的位置。

    元素缓冲对象(Element Buffer Object，EBO)，也叫索引缓冲对象(Index Buffer Object，IBO)。

    1. float vertices[] = {
    2.     // 第一个三角形
    3.     0.5f, 0.5f, 0.0f,   // 右上角
    4.     0.5f, -0.5f, 0.0f,  // 右下角
    5.     -0.5f, 0.5f, 0.0f,  // 左上角
    6.     // 第二个三角形
    7.     0.5f, -0.5f, 0.0f,  // 右下角
    8.     -0.5f, -0.5f, 0.0f, // 左下角
    9.     -0.5f, 0.5f, 0.0f   // 左上角
    10. };

    就可以转化成：

    1. float vertices[] = {
    2.     0.5f, 0.5f, 0.0f,   // 右上角
    3.     0.5f, -0.5f, 0.0f,  // 右下角
    4.     -0.5f, -0.5f, 0.0f, // 左下角
    5.     -0.5f, 0.5f, 0.0f   // 左上角
    6. };
    7.  
    8. unsigned int indices[] = {
    9.     // 注意索引从0开始! 
    10.     // 此例的索引(0,1,2,3)就是顶点数组vertices的下标，
    11.     // 这样可以由下标代表顶点组合成矩形
    12.  
    13.     0, 1, 3, // 第一个三角形
    14.     1, 2, 3  // 第二个三角形
    15. };

    着色器程序

    着色器程序对象(Shader Program Object)是多个着色器合并之后并最终链接完成的版本。如果要使用刚才编译的着色器我们必须把它们链接(Link)为一个着色器程序对象，然后在渲染对象的时候激活这个着色器程序。已激活着色器程序的着色器将在我们发送渲染调用的时候被使用。

    函数理解：

    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);

    • 第一个参数指定我们要配置的顶点属性。还记得我们在顶点着色器中使用layout(location = 0)定义了position顶点属性的位置值(Location)吗？它可以把顶点属性的位置值设置为0。因为我们希望把数据传递到这一个顶点属性中，所以这里我们传入0。
    • 第二个参数指定顶点属性的大小。顶点属性是一个vec3，它由3个值组成，所以大小是3。
    • 每个顶点属性从一个VBO管理的内存中获得它的数据，而具体是从哪个VBO（程序中可以有多个VBO）获取则是通过在调用glVertexAttribPointer时绑定到GL_ARRAY_BUFFER的VBO决定的。由于在调用glVertexAttribPointer之前绑定的是先前定义的VBO对象，顶点属性0现在会链接到它的顶点数据。

    代码：画一个矩形

    1. // sample_1_1_HelloWindow.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
    2. //
    3.  
    4. #include 
    5.  
    6. #include 
    7. #include 
    8.  
    9.  
    10. //顶点着色器
    11. const char* vertexShaderSource ="#version 330 core\n"
    12. "layout (location = 0) in vec3 aPos;\n"
    13. "void main()\n"
    14. "{\n"
    15. "   gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0);\n"
    16. "}\0";
    17.  
    18. //片段着色器
    19. const char * fragmentShaderSource = "#version 330 core\n"
    20. "out vec4 FragColor;\n"
    21. "void main()\n"
    22. "{\n"
    23. "   FragColor = vec4(1.0f, 0.5f, 0.2f, 1.0f);\n"
    24. "}\n\0";
    25.  
    26. //用户调整窗口大小之后的回调
    27. void framebuffer_size_callback(GLFWwindow* window, int width, int height)
    28. {
    29. 	glViewport(0, 0, width, height);
    30. }
    31.  
    32. //实现输入控制
    33. void processInput(GLFWwindow* window)
    34. {
    35. 	if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)//检查用户是否按下了返回键(Esc)
    36. 	{
    37. 		glfwSetWindowShouldClose(window, true);
    38. 	}
    39. }
    40. int main()
    41. {
    42. 	glfwInit();	//初始化GLFW
    43. 	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);//主版本号(Major)
    44. 	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);//次版本号(Minor)
    45. 	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);//核心模式(Core-profile)
    46.  
    47. 	GLFWwindow* window = glfwCreateWindow(800, 600, "learnOpenGL", NULL, NULL);
    48. 	if (window == NULL)
    49. 	{
    50. 		std::cout << "Failed to create GLFW window!\n" << std::endl;
    51. 		glfwTerminate();
    52. 		return -1;
    53. 	}
    54. 	glfwMakeContextCurrent(window);//创建完窗口我们就可以通知GLFW将我们窗口的上下文设置为当前线程的主上下文了
    55. 	
    56. 	//glad:加载所有OpenGL的函数指针
    57. 	if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
    58. 	{
    59. 		std::cout << "Failed to initialize GLAD" << std::endl;
    60. 		return -1;
    61. 	}
    62.  
    63. 	//告诉OpenGL渲染窗口的大小
    64. 	glViewport(0, 0, 800, 600);
    65.  
    66. 	//设置窗口大小变化之后的回调
    67. 	glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
    68.  
    69. 	/************************************************************************/
    70. 	/*画一个三角形                                                                      */
    71. 	//顶点着色器创建
    72. 	//顶点着色器附加源码，并且运行时动态编译它的源代码
    73. 	unsigned int vertexShader=glCreateShader(GL_VERTEX_SHADER);
    74. 	glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);
    75. 	glCompileShader(vertexShader);
    76. 	int success = -1;
    77. 	char infoLog[512];
    78. 	glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
    79. 	if (!success)
    80. 	{
    81. 		glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);
    82. 		std::cout << "ERROR::SHADER::VERTEX::COMPILATION_FAILEED\n" << infoLog << std::endl;
    83. 	}
    84.  
    85. 	//片段着色器
    86. 	unsigned int fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    87. 	glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
    88. 	glCompileShader(fragmentShader);
    89. 	glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
    90. 	if (!success)
    91. 	{
    92. 		glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);
    93. 		std::cout << "ERROR::SHADER::FRAGMEMT::COMPILATION_FAILEED\n" << infoLog << std::endl;
    94. 	}
    95.  
    96. 	//着色器程序,链接着色器
    97. 	unsigned int shaderProgram = glCreateProgram();
    98. 	glAttachShader(shaderProgram, vertexShader);
    99. 	glAttachShader(shaderProgram, fragmentShader);
    100. 	glLinkProgram(shaderProgram);
    101. 	glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
    102. 	if (!success)
    103. 	{
    104. 		glGetProgramInfoLog(shaderProgram, 512, NULL, infoLog);
    105. 		std::cout << "ERROR::PROGRAM::LINK\n" << infoLog << std::endl;
    106. 	}
    107. 	//把着色器对象链接到程序对象以后，记得删除着色器对象，我们不再需要它们
    108. 	glDeleteShader(vertexShader);
    109. 	glDeleteShader(fragmentShader);
    110.  
    111. /*
    112. 	float vertices[] = {
    113. 		 0.5f,  0.5f, 0.0f,  // top right
    114. 		 0.5f, -0.5f, 0.0f,  // bottom right
    115. 		-0.5f, -0.5f, 0.0f,  // bottom left
    116. 		-0.5f,  0.5f, 0.0f   // top left 
    117. 	};*/
    118. 	float vertices[] = {
    119. 	-0.5f, -0.5f, 0.0f,
    120. 	 0.5f, -0.5f, 0.0f,
    121. 	 0.0f,  0.5f, 0.0f
    122. 	};
    123. 	unsigned int indices[] = {  // note that we start from 0!
    124. 	0, 1, 3,  // first Triangle
    125. 	1, 2, 3   // second Triangle
    126. 	};
    127. 	//使用glGenBuffers函数和一个缓冲ID生成一个VBO对象
    128. 	unsigned int VBO = 0;
    129. 	unsigned int VAO = 0;
    130. 	unsigned int EBO = 0;
    131. 	glGenVertexArrays(1, &VAO);
    132. 	glGenBuffers(1, &VBO);
    133. 	glGenBuffers(1, &EBO);
    134.  
    135. 	//OpenGL有很多缓冲对象类型，顶点缓冲对象的缓冲类型是GL_ARRAY_BUFFER。
    136. 	// OpenGL允许我们同时绑定多个缓冲，只要它们是不同的缓冲类型。我们可以使用
    137. 	// glBindBuffer函数把新创建的缓冲绑定到GL_ARRAY_BUFFER目标上
    138. 	//任何对GL_ARRAY_BUFFER的操作，都是对VBO的操作
    139. 	//把之前定义的顶点数据复制到缓冲的内存
    140. 	glBindVertexArray(VAO);
    141. 	glBindBuffer(GL_ARRAY_BUFFER, VBO);
    142. 	glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
    143. 	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
    144. 	glBufferData(GL_ELEMENT_ARRAY_BUFFER,sizeof(indices), indices, GL_STATIC_DRAW);
    145.  
    146. 	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
    147. 	glEnableVertexAttribArray(0);
    148. 	
    149. 	glBindBuffer(GL_ARRAY_BUFFER, 0);
    150. 	glBindVertexArray(0);
    151. 	/*画一个三角形 end                                                                     */
    152. 	/************************************************************************/
    153. 	//渲染循环
    154. 	//在窗口结束之前，不断绘制图像，并且能够接收用户的输入
    155. 	while (!glfwWindowShouldClose(window))
    156. 	{
    157. 		// 输入
    158. 		processInput(window);	
    159.  
    160. 		//渲染指令
    161. 		//激活,在glUseProgram函数调用之后，每个着色器调用和渲染调用都会使用这个程序对象
    162. 		//（也就是之前写的着色器)了。
    163. 		glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
    164. 		glClear(GL_COLOR_BUFFER_BIT);
    165. 		glUseProgram(shaderProgram);
    166. 		glBindVertexArray(VAO);
    167. 		glDrawArrays(GL_TRIANGLES, 0, 3);
    168. 		//glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
    169.  
    170. 		// 检查并调用事件，交换缓冲
    171. 		glfwSwapBuffers(window);	
    172. 		glfwPollEvents();					
    173. 	}
    174.  
    175. 	glDeleteVertexArrays(1, &VAO);
    176. 	glDeleteBuffers(1, &VBO);
    177. 	glDeleteBuffers(1, &EBO);
    178. 	glDeleteProgram(shaderProgram);
    179.  
    180. 	glfwTerminate();
    181. 	return 0;
    182. }

    2.2 着色器：

    着色器语言：

    默认基础数据类型：int、float、double、uint和bool。

    GLSL也有两种容器类型：分别是向量(Vector)和矩阵(Matrix)

    向量：

    类型

    		含义
    vecn包含n个float分量的默认向量
    bvecn包含n个bool分量的向量
    ivecn包含n个int分量的向量
    uvecn包含n个unsigned int分量的向量
    dvecn包含n个double分量的向量

    重组(Swizzling)：

    重组允许这样的语法：

    1. vec2 someVec;
    2. vec4 differentVec = someVec.xyxx;
    3. vec3 anotherVec = differentVec.zyw;
    4. vec4 otherVec = someVec.xxxx + anotherVec.yxzy;
    1. vec2 vect = vec2(0.5, 0.7);
    2. vec4 result = vec4(vect, 0.0, 0.0);
    3. vec4 otherResult = vec4(result.xyz, 1.0);

    一个典型的着色器有下面的结构：

    1. #version version_number
    2. in type in_variable_name;
    3. in type in_variable_name;
    4.  
    5. out type out_variable_name;
    6.  
    7. uniform type uniform_name;
    8.  
    9. int main()
    10. {
    11.   // 处理输入并进行一些图形操作
    12.   ...
    13.   // 输出处理过的结果到输出变量
    14.   out_variable_name = weird_stuff_we_processed;
    15. }

    uniform：一个全局的变量

    关于layout(location = attribute index) in vec3 position;语句的分析？

    ayout(location=0) in vec4 vPosition_Luckie stone的博客-CSDN博客#version 430 core layout(location = 0) in vec4 vPosition; void main(){ gl_Position = vPosition;}第一行#version 430 core 表示我们所使用的4.3版本的OpenGL对应的GLSL语言，core表示使用OpenGL的核心模式。若#version没有设置，则默...https://blog.csdn.net/suyimin2010/article/details/99700711

    这个文章可以解惑。
            例如：layout( location=0) in vec3 position;

                       layout( location=1) in vec3 color;
            如果这个index和glVertexAttribPointer的第一个参数一样，那么相关缓存区的数据就会传递到这个变量中去。

            所以，

            glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);

            glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);

            如果这个index=0，那么读取的相关缓存区的数据就会传递到这个变量position中去。

            如果这个index=1，那么读取的相关缓存区的数据就会传递到这个变量color中去。

    为什么解绑VBO之后，再解绑VAO，但是再后续使用VBO，VAO的时候，只需绑定VAO就够了？而EBO缺只能在解绑VAO之后才能解绑

    因为glVertexAttribPointer函数执行之后，会影响改变VAO的状态，VBO会被复制保存到VAO中。之后如果改变了当前所绑定的缓存对象，也不会改变到VAO里的对象。

    顶点着色器

    1. int drawTriangle()
    2. {
    3. 	glfwInit();	//初始化GLFW
    4. 	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);//主版本号(Major)
    5. 	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);//次版本号(Minor)
    6. 	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);//核心模式(Core-profile)
    7.  
    8. 	GLFWwindow* window = glfwCreateWindow(800, 600, "learnOpenGL", NULL, NULL);
    9. 	if (window == NULL)
    10. 	{
    11. 		std::cout << "Failed to create GLFW window!\n" << std::endl;
    12. 		glfwTerminate();
    13. 		return -1;
    14. 	}
    15. 	glfwMakeContextCurrent(window);//创建完窗口我们就可以通知GLFW将我们窗口的上下文设置为当前线程的主上下文了
    16.  
    17. 	//glad:加载所有OpenGL的函数指针
    18. 	if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
    19. 	{
    20. 		std::cout << "Failed to initialize GLAD" << std::endl;
    21. 		return -1;
    22. 	}
    23.  
    24. 	//告诉OpenGL渲染窗口的大小
    25. 	glViewport(0, 0, 800, 600);
    26.  
    27. 	//设置窗口大小变化之后的回调
    28. 	glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
    29.  
    30. 	/************************************************************************/
    31. 	/*画一个三角形                                                                      */
    32. 	//顶点着色器创建
    33. 	//顶点着色器附加源码，并且运行时动态编译它的源代码
    34. 	unsigned int vertexShader = glCreateShader(GL_VERTEX_SHADER);
    35. 	glShaderSource(vertexShader, 1, &vertexShaderSource2, NULL);
    36. 	glCompileShader(vertexShader);
    37. 	int success = -1;
    38. 	char infoLog[512];
    39. 	glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
    40. 	if (!success)
    41. 	{
    42. 		glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);
    43. 		std::cout << "ERROR::SHADER::VERTEX::COMPILATION_FAILEED\n" << infoLog << std::endl;
    44. 	}
    45.  
    46. 	//片段着色器
    47. 	unsigned int fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    48. 	glShaderSource(fragmentShader, 1, &fragmentShaderSource2, NULL);
    49. 	glCompileShader(fragmentShader);
    50. 	glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
    51. 	if (!success)
    52. 	{
    53. 		glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);
    54. 		std::cout << "ERROR::SHADER::FRAGMEMT::COMPILATION_FAILEED\n" << infoLog << std::endl;
    55. 	}
    56.  
    57. 	//着色器程序,链接着色器
    58. 	unsigned int shaderProgram = glCreateProgram();
    59. 	glAttachShader(shaderProgram, vertexShader);
    60. 	glAttachShader(shaderProgram, fragmentShader);
    61. 	glLinkProgram(shaderProgram);
    62. 	glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
    63. 	if (!success)
    64. 	{
    65. 		glGetProgramInfoLog(shaderProgram, 512, NULL, infoLog);
    66. 		std::cout << "ERROR::PROGRAM::LINK\n" << infoLog << std::endl;
    67. 	}
    68. 	//把着色器对象链接到程序对象以后，记得删除着色器对象，我们不再需要它们
    69. 	glDeleteShader(vertexShader);
    70. 	glDeleteShader(fragmentShader);
    71.  
    72. 	float vertices[] = {
    73. 		// 位置              // 颜色
    74. 		 0.5f, -0.5f, 0.0f,  1.0f, 0.0f, 0.0f,   // 右下
    75. 		-0.5f, -0.5f, 0.0f,  0.0f, 1.0f, 0.0f,   // 左下
    76. 		 0.0f,  0.5f, 0.0f,  0.0f, 0.0f, 1.0f    // 顶部
    77. 	};
    78. 	unsigned int indices[] = {  // note that we start from 0!
    79. 	0, 1, 3,  // first Triangle
    80. 	1, 2, 3   // second Triangle
    81. 	};
    82. 	//使用glGenBuffers函数和一个缓冲ID生成一个VBO对象
    83. 	unsigned int VBO = 0;
    84. 	unsigned int VAO = 0;
    85. 	unsigned int EBO = 0;
    86. 	glGenVertexArrays(1, &VAO);
    87. 	glGenBuffers(1, &VBO);
    88. 	glGenBuffers(1, &EBO);
    89.  
    90. 	//OpenGL有很多缓冲对象类型，顶点缓冲对象的缓冲类型是GL_ARRAY_BUFFER。
    91. 	// OpenGL允许我们同时绑定多个缓冲，只要它们是不同的缓冲类型。我们可以使用
    92. 	// glBindBuffer函数把新创建的缓冲绑定到GL_ARRAY_BUFFER目标上
    93. 	//任何对GL_ARRAY_BUFFER的操作，都是对VBO的操作
    94. 	//把之前定义的顶点数据复制到缓冲的内存
    95. 	glBindVertexArray(VAO);
    96. 	glBindBuffer(GL_ARRAY_BUFFER, VBO);
    97. 	glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
    98. 	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
    99. 	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
    100.  
    101. 	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)0);
    102. 	glEnableVertexAttribArray(0);
    103. 	glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)(3 * sizeof(float)));
    104. 	glEnableVertexAttribArray(1);
    105.  
    106. 	//当目标是GL_ELEMENT_ARRAY_BUFFER的时候，VAO会储存glBindBuffer的函数调用。
    107. 	// 这也意味着它也会储存解绑调用，所以确保你没有在解绑VAO之前解绑索引数组缓冲，否
    108. 	// 则它就没有这个EBO配置了。
    109. 	glBindBuffer(GL_ARRAY_BUFFER, 0);
    110. 	glBindVertexArray(0);
    111. 	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
    112.  
    113.  
    114. 	//画成线条
    115. 	//glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
    116.  
    117.  
    118. 	/*画一个三角形 end                                                                     */
    119. 	/************************************************************************/
    120. 	//渲染循环
    121. 	//在窗口结束之前，不断绘制图像，并且能够接收用户的输入
    122. 	while (!glfwWindowShouldClose(window))
    123. 	{
    124. 		// 输入
    125. 		processInput(window);
    126.  
    127. 		//渲染指令
    128. 		//激活,在glUseProgram函数调用之后，每个着色器调用和渲染调用都会使用这个程序对象
    129. 		//（也就是之前写的着色器)了。
    130. 		glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
    131. 		glClear(GL_COLOR_BUFFER_BIT);
    132. 		glUseProgram(shaderProgram);
    133. 		glBindVertexArray(VAO);
    134. 		glDrawArrays(GL_TRIANGLES, 0, 3);
    135. 		//glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
    136.  
    137. 		// 检查并调用事件，交换缓冲
    138. 		glfwSwapBuffers(window);
    139. 		glfwPollEvents();
    140. 	}
    141.  
    142. 	glDeleteVertexArrays(1, &VAO);
    143. 	glDeleteBuffers(1, &VBO);
    144. 	glDeleteBuffers(1, &EBO);
    145. 	glDeleteProgram(shaderProgram);
    146.  
    147. 	glfwTerminate();
    148. 	return 0;
    149. }

    运行结果：

    我们只设置了三个点的值，但是出来的颜色 都是渐变的，原因如下：

    这个图片可能不是你所期望的那种，因为我们只提供了3个颜色，而不是我们现在看到的大调色板。这是在片段着色器中进行的所谓片段插值(Fragment Interpolation)的结果。当渲染一个三角形时，光栅化(Rasterization)阶段通常会造成比原指定顶点更多的片段。光栅会根据每个片段在三角形形状上所处相对位置决定这些片段的位置。
    基于这些位置，它会插值(Interpolate)所有片段着色器的输入变量。比如说，我们有一个线段，上面的端点是绿色的，下面的端点是蓝色的。如果一个片段着色器在线段的70%的位置运行，它的颜色输入属性就会是一个绿色和蓝色的线性结合；更精确地说就是30%蓝 + 70%绿。

     3.1纹理

    1，什么叫纹理？

    纹理是一个2D图片（甚至也有1D和3D的纹理），它可以用来添加物体的细节；你可以想象纹理是一张绘有砖块的纸，无缝折叠贴合到你的3D的房子上，这样你的房子看起来就像有砖墙外表了。

    2，什么叫纹理坐标？为什么需要纹理坐标

    为了能够把纹理映射(Map)到三角形上，我们需要指定三角形的每个顶点各自对应纹理的哪个部分。这样每个顶点就会关联着一个纹理坐标(Texture Coordinate)，用来标明该从纹理图像的哪个部分采样（译注：采集片段颜色） 

    1. 	float vertices[] = {
    2. 		//     ---- 位置 ----       ---- 颜色 ----     - 纹理坐标 -
    3. 			 0.5f,  0.5f, 0.0f,   1.0f, 0.0f, 0.0f,   1.0f, 1.0f,   // 右上
    4. 			 0.5f, -0.5f, 0.0f,   0.0f, 1.0f, 0.0f,   1.0f, 0.0f,   // 右下
    5. 			-0.5f, -0.5f, 0.0f,   0.0f, 0.0f, 1.0f,   0.0f, 0.0f,   // 左下
    6. 			-0.5f,  0.5f, 0.0f,   1.0f, 1.0f, 0.0f,   0.0f, 1.0f    // 左上
    7. 	};

    3，什么叫采样？

    纹理坐标在x和y，范轴上围为0到1之间（注意我们使用的是2D纹理图像）。使用纹理坐标获取纹理颜色叫做采样(Sampling)。纹理坐标起始于(0, 0)，也就是纹理图片的左下角，终始于(1, 1)，即纹理图片的右上角。

    4，纹理环绕方式

    当纹理坐标超出默认范围时，每个选项都有不同的视觉效果输出。我们来看看这些纹理图像的例子：

    5，纹理坐标和纹理像素

    Texture Pixel也叫Texel，你可以想象你打开一张.jpg格式图片，不断放大你会发现它是由无数像素点组成的，这个点就是纹理像素；注意不要和纹理坐标搞混，纹理坐标是你给模型顶点设置的那个数组，OpenGL以这个顶点的纹理坐标数据去查找纹理图像上的像素，然后进行采样提取纹理像素的颜色。

    6，纹理过滤

     

    GL_NEAREST（也叫邻近过滤，Nearest Neighbor Filtering）是OpenGL默认的纹理过滤方式。当设置为GL_NEAREST的时候，OpenGL会选择中心点最接近纹理坐标的那个像素。下图中你可以看到四个像素，加号代表纹理坐标。左上角那个纹理像素的中心距离纹理坐标最近，所以它会被选择为样本颜色：

    GL_LINEAR（也叫线性过滤，(Bi)linear Filtering）它会基于纹理坐标附近的纹理像素，计算出一个插值，近似出这些纹理像素之间的颜色。一个纹理像素的中心距离纹理坐标越近，那么这个纹理像素的颜色对最终的样本颜色的贡献越大。下图中你可以看到返回的颜色是邻近像素的混合色:

     7，glTexParameteri函数的用法：

    （1）设置环绕方式：

    环绕方式描述
    GL_REPEAT对纹理的默认行为。重复纹理图像。
    GL_MIRRORED_REPEAT和GL_REPEAT一样，但每次重复图片是镜像放置的。
    GL_CLAMP_TO_EDGE纹理坐标会被约束在0到1之间，超出的部分会重复纹理坐标的边缘，产生一种边缘被拉伸的效果。
    GL_CLAMP_TO_BORDER超出的坐标为用户指定的边缘颜色。
    1. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT);
    2. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT);
    1. //设置缩小之后边缘的颜色
    2. float borderColor[] = { 1.0f, 1.0f, 0.0f, 1.0f };
    3. glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, borderColor);

    （2）纹理过滤

    GL_NEAREST：选择中心点最接近纹理坐标的那个像素

    GL_LINEAR：    它会基于纹理坐标附近的纹理像素，计算出一个插值，近似出这些纹理像素之间的颜色

    1. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    2. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

    （3）多级渐远纹理

    过滤方式描述
    GL_NEAREST_MIPMAP_NEAREST使用最邻近的多级渐远纹理来匹配像素大小，并使用邻近插值进行纹理采样
    GL_LINEAR_MIPMAP_NEAREST使用最邻近的多级渐远纹理级别，并使用线性插值进行采样
    GL_NEAREST_MIPMAP_LINEAR在两个最匹配像素大小的多级渐远纹理之间进行线性插值，使用邻近插值进行采样
    GL_LINEAR_MIPMAP_LINEAR在两个邻近的多级渐远纹理之间使用线性插值，并使用线性插值进行采样
    1. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
    2. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    GL_LINEAR_MIPMAP_NEAREST中linear和nearest控制的部分

     注意：当纹理缩小的时候，像素直接就进选取就行，因为当0~1有1000个像素的时候，像素之间的色差不大

    8，生成纹理

    1. glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
    2. glGenerateMipmap(GL_TEXTURE_2D);

    当调用glTexImage2D时，当前绑定的纹理对象就会被附加上纹理图像。

    然而，目前只有基本级别(Base-level)的纹理图像被加载了，如果要使用多级渐远纹理，我们必须手动设置所有不同的图像（不断递增第二个参数）。

    或者，直接在生成纹理之后调用glGenerateMipmap。这会为当前绑定的纹理自动生成所有需要的多级渐远纹理。

    9，纹理单元

    一个纹理的位置值通常称为一个纹理单元(Texture Unit)。一个纹理的默认纹理单元是0，它是默认的激活纹理单元，所以教程前面部分我们没有分配一个位置值。

    （1）图像翻转代码

    stbi_set_flip_vertically_on_load(true);

    （2）步骤：（把纹理单元，纹理对象和采样器三者绑定起来）

                    1）激活纹理单元0号--->绑定纹理0号--->读取第0张图片

                    2）激活纹理单元1号--->绑定纹理1号--->读取第1张图片

                    3）告诉着色器，那个采样器属于几号纹理单元，代码如下

    1. 	/*
    2. 	* GLSL有一个供纹理对象使用的内建数据类型，叫做采样器(Sampler)，它以纹理类型作为后缀，比如sampler1D、sampler3D，或在我们的例子中的sampler2D
    3. 	* 告诉OpenGL每个着色器 采样器属于哪个纹理单元。我们只需要设置一次即可，所以这个会放在渲染循环的前面
    4. 	* ourTexture0着色器属于0号纹理单元
    5. 	*/
    6. 	ourShader.use();
    7. 	ourShader.setInt("ourTexture0", 0);
    8. 	ourShader.setInt("ourTexture1", 1);

    具体实现：

    片段着色器：

    1. #version 330 core
    2. out vec4 FragColor;
    3.  
    4. in vec3 ourColor;
    5. in vec2 TexCoord;
    6.  
    7. uniform sampler2D ourTexture0;
    8. uniform sampler2D ourTexture1;
    9.  
    10. void main()
    11. {
    12.     FragColor =  mix(texture(ourTexture0, TexCoord), texture(ourTexture1,TexCoord), 0.3) * vec4(ourColor, 1.0);
    13.  }

    顶点着色器：

    1. #version 330 core
    2. layout (location = 0) in vec3 aPos;
    3. layout (location = 1) in vec3 aColor;
    4. layout (location = 2) in vec2 aTexCoord;
    5.  
    6. out vec3 ourColor;
    7. out vec2 TexCoord;
    8.  
    9. void main()
    10. {
    11.     gl_Position = vec4(aPos, 1.0);
    12.     ourColor = aColor;
    13.     TexCoord = aTexCoord;
    14. }
    1.  
    2. // sample_1_1_HelloWindow.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
    3. //
    4.  
    5. #include 
    6.  
    7. #include 
    8. #include 
    9. #include "Shader.h"
    10. #define  STB_IMAGE_IMPLEMENTATION
    11. #include "stb_image.h"
    12.  
    13. void framebuffer_size_callback(GLFWwindow* window, int width, int height);//用户调整窗口大小之后的回调
    14. void processInput(GLFWwindow* window);//实现输入控制
    15. int drawRect();//画一个矩形
    16. int drawTriangle();
    17.  
    18. int main()
    19. {
    20. 	drawRect();
    21. 	return 0;
    22. }
    23.  
    24. //用户调整窗口大小之后的回调
    25. void framebuffer_size_callback(GLFWwindow* window, int width, int height)
    26. {
    27. 	glViewport(0, 0, width, height);
    28. }
    29.  
    30. //实现输入控制
    31. void processInput(GLFWwindow* window)
    32. {
    33. 	if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)//检查用户是否按下了返回键(Esc)
    34. 	{
    35. 		glfwSetWindowShouldClose(window, true);
    36. 	}
    37. }
    38.  
    39. int drawRect()
    40. {
    41. 	glfwInit();																												//初始化GLFW
    42. 	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);									//主版本号(Major)
    43. 	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);									//次版本号(Minor)
    44. 	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);	//核心模式(Core-profile)
    45.  
    46. 	GLFWwindow* window = glfwCreateWindow(800, 600, "learnOpenGL", NULL, NULL);
    47. 	if (window == NULL)
    48. 	{
    49. 		std::cout << "Failed to create GLFW window!\n" << std::endl;
    50. 		glfwTerminate();
    51. 		return -1;
    52. 	}
    53. 	/*创建完窗口我们就可以通知GLFW将我们窗口的上下文设置为当前线程的主上下文了*/
    54. 	glfwMakeContextCurrent(window);
    55.  
    56. 	/*glad:加载所有OpenGL的函数指针*/
    57. 	if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
    58. 	{
    59. 		std::cout << "Failed to initialize GLAD" << std::endl;
    60. 		return -1;
    61. 	}
    62.  
    63. 	/*告诉OpenGL渲染窗口的大小*/
    64. 	glViewport(0, 0, 800, 600);
    65.  
    66. 	/*设置窗口大小变化之后的回调*/
    67. 	glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
    68.  
    69. 	/*着色器*/
    70. 	CShader ourShader("shader.vs", "shader.fs");
    71. 	float vertices[] = {
    72. 		     /*---- 位置 ----       ---- 颜色 ----     - 纹理坐标 -*/
    73. 			 0.5f,  0.5f, 0.0f,   1.0f, 0.0f, 0.0f,   1.0f, 1.0f,   // 右上
    74. 			 0.5f, -0.5f, 0.0f,   0.0f, 1.0f, 0.0f,   1.0f, 0.0f,   // 右下
    75. 			-0.5f, -0.5f, 0.0f,   0.0f, 0.0f, 1.0f,   0.0f, 0.0f,   // 左下
    76. 			-0.5f,  0.5f, 0.0f,   1.0f, 1.0f, 0.0f,   0.0f, 1.0f    // 左上
    77. 	};
    78. 	unsigned int indices[] = {		// note that we start from 0!
    79. 	0, 1, 3,										// first Triangle
    80. 	1, 2, 3										// second Triangle
    81. 	};
    82.  
    83. 	/*	使用glGenBuffers函数和一个缓冲ID生成一个VBO对象*/
    84. 	unsigned int VBO = 0;
    85. 	unsigned int VAO = 0;
    86. 	unsigned int EBO = 0;
    87.  
    88. 	glGenVertexArrays(1, &VAO);
    89. 	glGenBuffers(1, &VBO);
    90. 	glGenBuffers(1, &EBO);
    91.  
    92. 	/*
    93. 	*	OpenGL有很多缓冲对象类型，顶点缓冲对象的缓冲类型是GL_ARRAY_BUFFER。
    94. 	*	 OpenGL允许我们同时绑定多个缓冲，只要它们是不同的缓冲类型。我们可以使用
    95. 	*	 glBindBuffer函数把新创建的缓冲绑定到GL_ARRAY_BUFFER目标上
    96. 	*	任何对GL_ARRAY_BUFFER的操作，都是对VBO的操作
    97. 	*	把之前定义的顶点数据复制到缓冲的内存
    98. 	*/
    99. 	glBindVertexArray(VAO);
    100. 	glBindBuffer(GL_ARRAY_BUFFER, VBO);
    101. 	glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
    102. 	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
    103. 	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
    104.  
    105. 	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)0);
    106. 	glEnableVertexAttribArray(0);
    107. 	glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(3 * sizeof(float)));
    108. 	glEnableVertexAttribArray(1);
    109. 	glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(6 * sizeof(float)));
    110. 	glEnableVertexAttribArray(2);
    111.  
    112. 	unsigned int texture0, texture1;
    113. 	glActiveTexture(GL_TEXTURE0);					//激活一个纹理单元
    114. 	glGenTextures(1, &texture0);						//生成纹理
    115. 	glBindTexture(GL_TEXTURE_2D, texture0);	//绑定纹理
    116. 	/*为当前绑定的纹理对象设置环绕、过滤方式*/
    117. 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_LINES);
    118. 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_LINES);
    119. 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINES);
    120. 	/*纹理放大不会使用多级渐远纹理，为放大过滤设置多级渐远纹理的选项会产生一个GL_INVALID_ENUM错误代码。*/
    121. 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINE);
    122.  
    123. 	/*加载并生成纹理*/
    124. 	int width, height, nrChannels;
    125. 	/*图像翻转*/
    126. 	stbi_set_flip_vertically_on_load(true);
    127. 	unsigned char* data = stbi_load("yun.png", &width, &height, &nrChannels, 0);
    128. 	if (data)
    129. 	{
    130. 		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
    131. 		/*会为当前绑定的纹理自动生成所有需要的多级渐远纹理*/
    132. 		glGenerateMipmap(GL_TEXTURE_2D);
    133. 	}
    134. 	else
    135. 	{
    136. 		std::cout << "Failed to load texture" << std::endl;
    137. 	}
    138. 	stbi_image_free(data);
    139.  
    140. 	glActiveTexture(GL_TEXTURE1);					//激活一个纹理单元
    141. 	glGenTextures(1, &texture1);						//生成纹理
    142. 	glBindTexture(GL_TEXTURE_2D, texture1);	//绑定纹理
    143. 	/*为当前绑定的纹理对象设置环绕、过滤方式*/
    144. 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_LINES);
    145. 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_LINES);
    146. 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINES);
    147. 	/*纹理放大不会使用多级渐远纹理，为放大过滤设置多级渐远纹理的选项会产生一个GL_INVALID_ENUM错误代码。*/
    148. 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINE);
    149.  
    150. 	/*加载并生成纹理*/
    151. 	data = stbi_load("container.jpg", &width, &height, &nrChannels, 0);
    152. 	if (data)
    153. 	{
    154. 		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
    155. 		/*会为当前绑定的纹理自动生成所有需要的多级渐远纹理*/
    156. 		glGenerateMipmap(GL_TEXTURE_2D);
    157. 	}
    158. 	else
    159. 	{
    160. 		std::cout << "Failed to load texture" << std::endl;
    161. 	}
    162. 	stbi_image_free(data);
    163.  
    164. 	/*
    165. 	* 当目标是GL_ELEMENT_ARRAY_BUFFER的时候，VAO会储存glBindBuffer的函数调用。
    166. 	* 这也意味着它也会储存解绑调用，所以确保你没有在解绑VAO之前解绑索引数组缓冲，否
    167. 	* 则它就没有这个EBO配置了。
    168. 	*/
    169. 	glBindBuffer(GL_ARRAY_BUFFER, 0);
    170. 	glBindVertexArray(0);
    171. 	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
    172.  
    173.  
    174. 	/*画成线条*/
    175. 	//glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
    176.  
    177. 	/*
    178. 	* GLSL有一个供纹理对象使用的内建数据类型，叫做采样器(Sampler)，它以纹理类型作为后缀，比如sampler1D、sampler3D，或在我们的例子中的sampler2D
    179. 	* 告诉OpenGL每个着色器 采样器属于哪个纹理单元。我们只需要设置一次即可，所以这个会放在渲染循环的前面
    180. 	* ourTexture0着色器属于0号纹理单元
    181. 	*/
    182. 	ourShader.use();
    183. 	ourShader.setInt("ourTexture0", 0);
    184. 	ourShader.setInt("ourTexture1", 1);
    185.  
    186. 	/*
    187. 	*	渲染循环
    188. 	*	在窗口结束之前，不断绘制图像，并且能够接收用户的输入
    189. 	*/
    190. 	while (!glfwWindowShouldClose(window))
    191. 	{
    192. 		/*输入*/
    193. 		processInput(window);						 
    194. 		/*
    195. 		渲染指令
    196. 		激活,在glUseProgram函数调用之后，每个着色器调用和渲染调用都会使用这个程序对象
    197. 		（也就是之前写的着色器)了。
    198. 		*/
    199. 		glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
    200. 		glClear(GL_COLOR_BUFFER_BIT);
    201.  
    202. 		glBindVertexArray(VAO);					
    203. 		//glDrawArrays(GL_TRIANGLES, 0, 3);
    204. 		glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
    205.  
    206. 		/*检查并调用事件，交换缓冲*/
    207. 		glfwSwapBuffers(window);
    208. 		glfwPollEvents();
    209. 	}
    210.  
    211. 	glDeleteVertexArrays(1, &VAO);
    212. 	glDeleteBuffers(1, &VBO);
    213. 	glDeleteBuffers(1, &EBO);
    214.  
    215. 	glfwTerminate();
    216. 	return 0;
    217. }
    218.  
    219.

    4.1 向量和矩阵

    1，什么是向量？

    2,向量的计算

     

    3，矩阵计算

     

     

     

     注意：建议您在组合矩阵时，先进行缩放操作，然后是旋转，最后才是位移，否则它们会（消极地）互相影响。比如，如果你先位移再缩放，位移的向量也会同样被缩放（译注：比如向某方向移动2米，2米也许会被缩放成1米）！

    应用

    关于旋转，位移，放缩的顺序总结一下就是:

    后者的计算可以影响到前一步的计算

    代码：
    顶点着色器：

    1. #version 330 core
    2. layout (location = 0) in vec3 aPos;
    3. layout (location = 1) in vec3 aColor;
    4. layout (location = 2) in vec2 aTexCoord;
    5.  
    6. out vec3 ourColor;
    7. out vec2 TexCoord;
    8. uniform mat4 transform;
    9. void main()
    10. {
    11.     gl_Position = transform * vec4(aPos, 1.0);
    12.     ourColor = aColor;
    13.     TexCoord = aTexCoord;
    14. }

    片段着色器：

    1. #version 330 core
    2. out vec4 FragColor;
    3.  
    4. in vec3 ourColor;
    5. in vec2 TexCoord;
    6.  
    7. uniform sampler2D ourTexture0;
    8. uniform sampler2D ourTexture1;
    9. uniform float ratio;
    10.  
    11. void main()
    12. {
    13.     FragColor =  mix(texture(ourTexture0, vec2(1-TexCoord.x, TexCoord.y)), texture(ourTexture1,vec2(TexCoord.x, TexCoord.y)), ratio);
    14.  }
    1.  
    2. // sample_1_1_HelloWindow.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
    3. //
    4.  
    5. #include 
    6.  
    7. #include 
    8. #include 
    9. #include "Shader.h"
    10. #define  STB_IMAGE_IMPLEMENTATION
    11. #include "stb_image.h"
    12. #include 
    13. #include 
    14. #include 
    15.  
    16.  
    17. void framebuffer_size_callback(GLFWwindow* window, int width, int height);	/*用户调整窗口大小之后的回调*/
    18. void processInput(GLFWwindow* window);/*实现输入控制*/
    19. int drawRect();/*画一个矩形*/
    20. int drawTriangle();
    21. float ratio = 0.5f;
    22. int main()
    23. {
    24. 	drawRect();
    25. 	return 0;
    26. }
    27.  
    28. //用户调整窗口大小之后的回调
    29. void framebuffer_size_callback(GLFWwindow* window, int width, int height)
    30. {
    31. 	glViewport(0, 0, width, height);
    32. }
    33.  
    34. //实现输入控制
    35. void processInput(GLFWwindow* window)
    36. {
    37. 	if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)//检查用户是否按下了返回键(Esc)
    38. 	{
    39. 		glfwSetWindowShouldClose(window, true);
    40. 	}
    41. 	if (glfwGetKey(window, GLFW_KEY_UP) == GLFW_PRESS)
    42. 	{
    43. 		ratio += 0.01;
    44. 		if (ratio > 1)
    45. 		{
    46. 			ratio = 1;
    47. 		}
    48. 	}
    49. 	if (glfwGetKey(window, GLFW_KEY_DOWN) == GLFW_PRESS)
    50. 	{
    51. 		ratio -= 0.01;
    52. 		if (ratio <0)
    53. 		{
    54. 			ratio = 0;
    55. 		}
    56. 	}
    57.  
    58. }
    59.  
    60. int drawRect()
    61. {
    62. 	glfwInit();																												//初始化GLFW
    63. 	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);									//主版本号(Major)
    64. 	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);									//次版本号(Minor)
    65. 	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);	//核心模式(Core-profile)
    66.  
    67. 	GLFWwindow* window = glfwCreateWindow(800, 600, "learnOpenGL", NULL, NULL);
    68. 	if (window == NULL)
    69. 	{
    70. 		std::cout << "Failed to create GLFW window!\n" << std::endl;
    71. 		glfwTerminate();
    72. 		return -1;
    73. 	}
    74. 	/*创建完窗口我们就可以通知GLFW将我们窗口的上下文设置为当前线程的主上下文了*/
    75. 	glfwMakeContextCurrent(window);
    76.  
    77. 	/*glad:加载所有OpenGL的函数指针*/
    78. 	if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
    79. 	{
    80. 		std::cout << "Failed to initialize GLAD" << std::endl;
    81. 		return -1;
    82. 	}
    83.  
    84. 	/*告诉OpenGL渲染窗口的大小*/
    85. 	glViewport(0, 0, 800, 600);
    86.  
    87. 	/*设置窗口大小变化之后的回调*/
    88. 	glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
    89.  
    90. 	/*着色器*/
    91. 	CShader ourShader("shader.vs", "shader.fs");
    92.  
    93. 	float vertices[] = {
    94. 		     /*---- 位置 ----       ---- 颜色 ----     - 纹理坐标 -*/
    95. 			 0.5f,  0.5f, 0.0f,   1.0f, 0.0f, 0.0f,   1.0f, 1.0f,   // 右上
    96. 			 0.5f, -0.5f, 0.0f,   0.0f, 1.0f, 0.0f,   1.0f, 0.0f,   // 右下
    97. 			-0.5f, -0.5f, 0.0f,   0.0f, 0.0f, 1.0f,   0.0f, 0.0f,   // 左下
    98. 			-0.5f,  0.5f, 0.0f,   1.0f, 1.0f, 0.0f,   0.0f, 1.0f    // 左上
    99. 	};
    100. 	unsigned int indices[] = {		// note that we start from 0!
    101. 	0, 1, 3,										// first Triangle
    102. 	1, 2, 3										// second Triangle
    103. 	};
    104.  
    105. 	/*	使用glGenBuffers函数和一个缓冲ID生成一个VBO对象*/
    106. 	unsigned int VBO = 0;
    107. 	unsigned int VAO = 0;
    108. 	unsigned int EBO = 0;
    109.  
    110. 	glGenVertexArrays(1, &VAO);
    111. 	glGenBuffers(1, &VBO);
    112. 	glGenBuffers(1, &EBO);
    113.  
    114. 	/*
    115. 	*	OpenGL有很多缓冲对象类型，顶点缓冲对象的缓冲类型是GL_ARRAY_BUFFER。
    116. 	*	 OpenGL允许我们同时绑定多个缓冲，只要它们是不同的缓冲类型。我们可以使用
    117. 	*	 glBindBuffer函数把新创建的缓冲绑定到GL_ARRAY_BUFFER目标上
    118. 	*	任何对GL_ARRAY_BUFFER的操作，都是对VBO的操作
    119. 	*	把之前定义的顶点数据复制到缓冲的内存
    120. 	*/
    121. 	glBindVertexArray(VAO);
    122. 	glBindBuffer(GL_ARRAY_BUFFER, VBO);
    123. 	glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
    124. 	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
    125. 	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
    126.  
    127. 	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)0);
    128. 	glEnableVertexAttribArray(0);
    129. 	glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(3 * sizeof(float)));
    130. 	glEnableVertexAttribArray(1);
    131. 	glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(6 * sizeof(float)));
    132. 	glEnableVertexAttribArray(2);
    133.  
    134. 	unsigned int texture0, texture1;
    135. 	glActiveTexture(GL_TEXTURE0);					//激活一个纹理单元
    136. 	glGenTextures(1, &texture0);						//生成纹理
    137. 	glBindTexture(GL_TEXTURE_2D, texture0);	//绑定纹理
    138. 	/*为当前绑定的纹理对象设置环绕、过滤方式*/
    139. 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_LINES);
    140. 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_LINES);
    141. 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINES);
    142. 	/*纹理放大不会使用多级渐远纹理，为放大过滤设置多级渐远纹理的选项会产生一个GL_INVALID_ENUM错误代码。*/
    143. 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    144.  
    145. 	/*加载并生成纹理*/
    146. 	int width, height, nrChannels;
    147. 	/*图像翻转*/
    148. 	stbi_set_flip_vertically_on_load(true);
    149. 	unsigned char* data = stbi_load("awesomeface.png", &width, &height, &nrChannels, 0);
    150. 	if (data)
    151. 	{
    152. 		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
    153. 		/*会为当前绑定的纹理自动生成所有需要的多级渐远纹理*/
    154. 		glGenerateMipmap(GL_TEXTURE_2D);
    155. 	}
    156. 	else
    157. 	{
    158. 		std::cout << "Failed to load texture" << std::endl;
    159. 	}
    160. 	stbi_image_free(data);
    161.  
    162. 	glActiveTexture(GL_TEXTURE1);					//激活一个纹理单元
    163. 	glGenTextures(1, &texture1);						//生成纹理
    164. 	glBindTexture(GL_TEXTURE_2D, texture1);	//绑定纹理
    165. 	/*为当前绑定的纹理对象设置环绕、过滤方式*/
    166. 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_LINES);
    167. 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_LINES);
    168. 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINES);
    169. 	/*纹理放大不会使用多级渐远纹理，为放大过滤设置多级渐远纹理的选项会产生一个GL_INVALID_ENUM错误代码。*/
    170. 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINE);
    171.  
    172. 	/*加载并生成纹理*/
    173. 	data = stbi_load("container.jpg", &width, &height, &nrChannels, 0);
    174. 	if (data)
    175. 	{
    176. 		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
    177. 		/*会为当前绑定的纹理自动生成所有需要的多级渐远纹理*/
    178. 		glGenerateMipmap(GL_TEXTURE_2D);
    179. 	}
    180. 	else
    181. 	{
    182. 		std::cout << "Failed to load texture" << std::endl;
    183. 	}
    184. 	stbi_image_free(data);
    185.  
    186. 	/*
    187. 	* 当目标是GL_ELEMENT_ARRAY_BUFFER的时候，VAO会储存glBindBuffer的函数调用。
    188. 	* 这也意味着它也会储存解绑调用，所以确保你没有在解绑VAO之前解绑索引数组缓冲，否
    189. 	* 则它就没有这个EBO配置了。
    190. 	*/
    191. 	glBindBuffer(GL_ARRAY_BUFFER, 0);
    192. 	glBindVertexArray(0);
    193. 	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
    194.  
    195.  
    196. 	/*画成线条*/
    197. 	//glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
    198.  
    199. 	/*
    200. 	* GLSL有一个供纹理对象使用的内建数据类型，叫做采样器(Sampler)，它以纹理类型作为后缀，比如sampler1D、sampler3D，或在我们的例子中的sampler2D
    201. 	* 告诉OpenGL每个着色器 采样器属于哪个纹理单元。我们只需要设置一次即可，所以这个会放在渲染循环的前面
    202. 	* ourTexture0着色器属于0号纹理单元
    203. 	*/
    204.  
    205. 	ourShader.use();
    206.  
    207. 	ourShader.setInt("ourTexture0", 0);
    208. 	ourShader.setInt("ourTexture1", 1);
    209.  
    210.  
    211. 	/*
    212. 	*	渲染循环
    213. 	*	在窗口结束之前，不断绘制图像，并且能够接收用户的输入
    214. 	*/
    215. 	while (!glfwWindowShouldClose(window))
    216. 	{
    217. 		/*输入*/
    218. 		processInput(window);		
    219. 		ourShader.setFloat("ratio", ratio);
    220.  
    221. 		/*
    222. 		渲染指令
    223. 		激活,在glUseProgram函数调用之后，每个着色器调用和渲染调用都会使用这个程序对象
    224. 		（也就是之前写的着色器)了。
    225. 		*/
    226. 		glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
    227. 		glClear(GL_COLOR_BUFFER_BIT);
    228.  
    229. 		glBindVertexArray(VAO);
    230.  
    231.  
    232. 		/*先缩放，再旋转，最后位移，显示出来就是trans先位移，再旋转，最后缩放	*/
    233. 		glm::mat4 trans = glm::mat4(1.0f);
    234. 		trans = glm::translate(trans, glm::vec3(0.5f, -0.5f, 0.0f));
    235. 		trans = glm::rotate(trans, (float)glfwGetTime(), glm::vec3(0.0, 0.0, 1.0));
    236. 		trans = glm::scale(trans, glm::vec3(0.5, 0.5, 0.5));
    237. 		unsigned int transformLoc = glGetUniformLocation(ourShader.ID, "transform");
    238. 		glUniformMatrix4fv(transformLoc, 1, GL_FALSE, glm::value_ptr(trans));
    239. 		//glDrawArrays(GL_TRIANGLES, 0, 3);
    240. 		glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
    241.  
    242. 		/*第二个三角形*/
    243. 		trans = glm::mat4(1.0f);
    244. 		trans = glm::translate(trans, glm::vec3(-0.5f, 0.5f, 0.0f));
    245. 		//trans = glm::rotate(trans, (float)glfwGetTime(), glm::vec3(0.0, 0.0, 1.0));
    246. 		float scaleValue = glm::sin(glfwGetTime());
    247. 		trans = glm::scale(trans, glm::vec3(scaleValue, scaleValue, scaleValue));
    248. 		transformLoc = glGetUniformLocation(ourShader.ID, "transform");
    249. 		glUniformMatrix4fv(transformLoc, 1, GL_FALSE, glm::value_ptr(trans));
    250. 		//glDrawArrays(GL_TRIANGLES, 0, 3);
    251. 		glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
    252.  
    253.  
    254.  
    255. 		/*检查并调用事件，交换缓冲*/
    256. 		glfwSwapBuffers(window);
    257. 		glfwPollEvents();
    258. 	}
    259.  
    260. 	glDeleteVertexArrays(1, &VAO);
    261. 	glDeleteBuffers(1, &VBO);
    262. 	glDeleteBuffers(1, &EBO);
    263.  
    264. 	glfwTerminate();
    265. 	return 0;
    266. }
    267.  
    268.

    5，系统坐标

    将物体的坐标变换到几个过渡坐标系(Intermediate Coordinate System)的优点在于，在这些特定的坐标系统中，一些操作或运算更加方便和容易，这一点很快就会变得很明显。对我们来说比较重要的总共有5个不同的坐标系统：

    • 局部空间(Local Space，或者称为物体空间(Object Space))
    • 世界空间(World Space)
    • 观察空间(View Space，或者称为视觉空间(Eye Space))
    • 裁剪空间(Clip Space)
    • 屏幕空间(Screen Space)

    它们之间是如何变换的？

    右手坐标系：

    什么叫齐次方程，怎么用？
    什么是齐次坐标? - 知乎

    要明白齐次方程是一个工具，为了解决现实世界两条平行的能够在远处相交的问题。

    glm实现的代码：（注意使用顺序）
    旋转：

     glm::rotate(model, (float)glfwGetTime() * glm::radians(50.0f), glm::vec3(1.0f, 1.0f, 0.0f));

    位移：

    glm::translate(model, cubePositions[i]);

    放缩：

    glm::scale(model, glm::vec3(0.5, 0.5, 0.5));

    透视：

     projection = glm::perspective(glm::radians(70.0f), 800.0f / 600.0f, 0.1f, 100.0f);

    代码：

    顶点着色器：

    1. #version 330 core
    2. layout (location = 0) in vec3 aPos;
    3. layout (location = 1) in vec2 aTexCoord;
    4.  
    5.  
    6. out vec2 TexCoord;
    7. uniform mat4 model;
    8. uniform mat4 view;
    9. uniform mat4 projection;
    10.  
    11. void main()
    12. {
    13.     gl_Position =projection * view * model * vec4(aPos, 1.0);
    14.     TexCoord = aTexCoord;
    15. }

    片段着色器：

    1. #version 330 core
    2. out vec4 FragColor;
    3.  
    4.  
    5. in vec2 TexCoord;
    6.  
    7. uniform sampler2D ourTexture0;
    8. uniform sampler2D ourTexture1;
    9. uniform float ratio;
    10.  
    11. void main()
    12. {
    13.     FragColor =  mix(texture(ourTexture0, vec2(TexCoord.x, TexCoord.y)), texture(ourTexture1,vec2(TexCoord.x, TexCoord.y)), ratio);
    14.  }

    实现：

    1.  
    2. // sample_1_1_HelloWindow.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
    3. //
    4.  
    5. #include 
    6.  
    7. #include 
    8. #include 
    9. #include "Shader.h"
    10. #define  STB_IMAGE_IMPLEMENTATION
    11. #include "stb_image.h"
    12. #include 
    13. #include 
    14. #include 
    15.  
    16.  
    17. void framebuffer_size_callback(GLFWwindow* window, int width, int height);	/*用户调整窗口大小之后的回调*/
    18. void processInput(GLFWwindow* window);/*实现输入控制*/
    19. int drawRect();/*画一个矩形*/
    20. int drawTriangle();
    21. float ratio = 0.5f;
    22. int main()
    23. {
    24. 	drawRect();
    25. 	return 0;
    26. }
    27.  
    28. //用户调整窗口大小之后的回调
    29. void framebuffer_size_callback(GLFWwindow* window, int width, int height)
    30. {
    31. 	glViewport(0, 0, width, height);
    32. }
    33.  
    34. //实现输入控制
    35. void processInput(GLFWwindow* window)
    36. {
    37. 	if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)//检查用户是否按下了返回键(Esc)
    38. 	{
    39. 		glfwSetWindowShouldClose(window, true);
    40. 	}
    41. 	if (glfwGetKey(window, GLFW_KEY_UP) == GLFW_PRESS)
    42. 	{
    43. 		ratio += 0.01;
    44. 		if (ratio > 1)
    45. 		{
    46. 			ratio = 1;
    47. 		}
    48. 	}
    49. 	if (glfwGetKey(window, GLFW_KEY_DOWN) == GLFW_PRESS)
    50. 	{
    51. 		ratio -= 0.01;
    52. 		if (ratio <0)
    53. 		{
    54. 			ratio = 0;
    55. 		}
    56. 	}
    57.  
    58. }
    59.  
    60. int drawRect()
    61. {
    62. 	glfwInit();																												//初始化GLFW
    63. 	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);									//主版本号(Major)
    64. 	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);									//次版本号(Minor)
    65. 	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);	//核心模式(Core-profile)
    66.  
    67. 	GLFWwindow* window = glfwCreateWindow(800, 600, "learnOpenGL", NULL, NULL);
    68. 	if (window == NULL)
    69. 	{
    70. 		std::cout << "Failed to create GLFW window!\n" << std::endl;
    71. 		glfwTerminate();
    72. 		return -1;
    73. 	}
    74. 	/*创建完窗口我们就可以通知GLFW将我们窗口的上下文设置为当前线程的主上下文了*/
    75. 	glfwMakeContextCurrent(window);
    76.  
    77. 	/*glad:加载所有OpenGL的函数指针*/
    78. 	if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
    79. 	{
    80. 		std::cout << "Failed to initialize GLAD" << std::endl;
    81. 		return -1;
    82. 	}
    83.  
    84. 	/*告诉OpenGL渲染窗口的大小*/
    85. 	glViewport(0, 0, 800, 600);
    86.  
    87. 	/*设置窗口大小变化之后的回调*/
    88. 	glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
    89.  
    90. 	/*着色器*/
    91. 	CShader ourShader("shader.vs", "shader.fs");
    92.  
    93. 	float vertices[] = {
    94. 		-0.5f, -0.5f, -0.5f,  0.0f, 0.0f,
    95. 		 0.5f, -0.5f, -0.5f,  1.0f, 0.0f,
    96. 		 0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
    97. 		 0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
    98. 		-0.5f,  0.5f, -0.5f,  0.0f, 1.0f,
    99. 		-0.5f, -0.5f, -0.5f,  0.0f, 0.0f,
    100.  
    101. 		-0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
    102. 		 0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
    103. 		 0.5f,  0.5f,  0.5f,  1.0f, 1.0f,
    104. 		 0.5f,  0.5f,  0.5f,  1.0f, 1.0f,
    105. 		-0.5f,  0.5f,  0.5f,  0.0f, 1.0f,
    106. 		-0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
    107.  
    108. 		-0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
    109. 		-0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
    110. 		-0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
    111. 		-0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
    112. 		-0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
    113. 		-0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
    114.  
    115. 		 0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
    116. 		 0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
    117. 		 0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
    118. 		 0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
    119. 		 0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
    120. 		 0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
    121.  
    122. 		-0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
    123. 		 0.5f, -0.5f, -0.5f,  1.0f, 1.0f,
    124. 		 0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
    125. 		 0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
    126. 		-0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
    127. 		-0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
    128.  
    129. 		-0.5f,  0.5f, -0.5f,  0.0f, 1.0f,
    130. 		 0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
    131. 		 0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
    132. 		 0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
    133. 		-0.5f,  0.5f,  0.5f,  0.0f, 0.0f,
    134. 		-0.5f,  0.5f, -0.5f,  0.0f, 1.0f
    135. 	};
    136. 	unsigned int indices[] = {		// note that we start from 0!
    137. 	0, 1, 3,										// first Triangle
    138. 	1, 2, 3										// second Triangle
    139. 	};
    140.  
    141. 	/*	使用glGenBuffers函数和一个缓冲ID生成一个VBO对象*/
    142. 	unsigned int VBO = 0;
    143. 	unsigned int VAO = 0;
    144. 	unsigned int EBO = 0;
    145.  
    146. 	glGenVertexArrays(1, &VAO);
    147. 	glGenBuffers(1, &VBO);
    148. 	glGenBuffers(1, &EBO);
    149.  
    150. 	/*
    151. 	*	OpenGL有很多缓冲对象类型，顶点缓冲对象的缓冲类型是GL_ARRAY_BUFFER。
    152. 	*	 OpenGL允许我们同时绑定多个缓冲，只要它们是不同的缓冲类型。我们可以使用
    153. 	*	 glBindBuffer函数把新创建的缓冲绑定到GL_ARRAY_BUFFER目标上
    154. 	*	任何对GL_ARRAY_BUFFER的操作，都是对VBO的操作
    155. 	*	把之前定义的顶点数据复制到缓冲的内存
    156. 	*/
    157. 	glBindVertexArray(VAO);
    158. 	glBindBuffer(GL_ARRAY_BUFFER, VBO);
    159. 	glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
    160. 	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
    161. 	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
    162.  
    163. 	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
    164. 	glEnableVertexAttribArray(0);
    165. 	glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
    166. 	glEnableVertexAttribArray(1);
    167.  
    168.  
    169. 	unsigned int texture0, texture1;
    170. 	glActiveTexture(GL_TEXTURE0);					//激活一个纹理单元
    171. 	glGenTextures(1, &texture0);						//生成纹理
    172. 	glBindTexture(GL_TEXTURE_2D, texture0);	//绑定纹理
    173. 	/*为当前绑定的纹理对象设置环绕、过滤方式*/
    174. 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_LINES);
    175. 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_LINES);
    176. 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINES);
    177. 	/*纹理放大不会使用多级渐远纹理，为放大过滤设置多级渐远纹理的选项会产生一个GL_INVALID_ENUM错误代码。*/
    178. 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    179.  
    180. 	/*加载并生成纹理*/
    181. 	int width, height, nrChannels;
    182. 	/*图像翻转*/
    183. 	stbi_set_flip_vertically_on_load(true);
    184. 	unsigned char* data = stbi_load("awesomeface.png", &width, &height, &nrChannels, 0);
    185. 	if (data)
    186. 	{
    187. 		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
    188. 		/*会为当前绑定的纹理自动生成所有需要的多级渐远纹理*/
    189. 		glGenerateMipmap(GL_TEXTURE_2D);
    190. 	}
    191. 	else
    192. 	{
    193. 		std::cout << "Failed to load texture" << std::endl;
    194. 	}
    195. 	stbi_image_free(data);
    196.  
    197. 	glActiveTexture(GL_TEXTURE1);					//激活一个纹理单元
    198. 	glGenTextures(1, &texture1);						//生成纹理
    199. 	glBindTexture(GL_TEXTURE_2D, texture1);	//绑定纹理
    200. 	/*为当前绑定的纹理对象设置环绕、过滤方式*/
    201. 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_LINES);
    202. 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_LINES);
    203. 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINES);
    204. 	/*纹理放大不会使用多级渐远纹理，为放大过滤设置多级渐远纹理的选项会产生一个GL_INVALID_ENUM错误代码。*/
    205. 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINE);
    206.  
    207. 	/*加载并生成纹理*/
    208. 	data = stbi_load("container.jpg", &width, &height, &nrChannels, 0);
    209. 	if (data)
    210. 	{
    211. 		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
    212. 		/*会为当前绑定的纹理自动生成所有需要的多级渐远纹理*/
    213. 		glGenerateMipmap(GL_TEXTURE_2D);
    214. 	}
    215. 	else
    216. 	{
    217. 		std::cout << "Failed to load texture" << std::endl;
    218. 	}
    219. 	stbi_image_free(data);
    220.  
    221. 	/*
    222. 	* 当目标是GL_ELEMENT_ARRAY_BUFFER的时候，VAO会储存glBindBuffer的函数调用。
    223. 	* 这也意味着它也会储存解绑调用，所以确保你没有在解绑VAO之前解绑索引数组缓冲，否
    224. 	* 则它就没有这个EBO配置了。
    225. 	*/
    226. 	glBindBuffer(GL_ARRAY_BUFFER, 0);
    227. 	glBindVertexArray(0);
    228. 	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
    229.  
    230.  
    231. 	/*画成线条*/
    232. 	//glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
    233.  
    234. 	/*
    235. 	* GLSL有一个供纹理对象使用的内建数据类型，叫做采样器(Sampler)，它以纹理类型作为后缀，比如sampler1D、sampler3D，或在我们的例子中的sampler2D
    236. 	* 告诉OpenGL每个着色器 采样器属于哪个纹理单元。我们只需要设置一次即可，所以这个会放在渲染循环的前面
    237. 	* ourTexture0着色器属于0号纹理单元
    238. 	*/
    239.  
    240. 	ourShader.use();
    241.  
    242. 	ourShader.setInt("ourTexture0", 0);
    243. 	ourShader.setInt("ourTexture1", 1);
    244.  
    245.  
    246. 	/*
    247. 	*	渲染循环
    248. 	*	在窗口结束之前，不断绘制图像，并且能够接收用户的输入
    249. 	*/
    250.  
    251. 	/*启用深度测试*/
    252. 	glEnable(GL_DEPTH_TEST);
    253.  
    254. 	glm::vec3 cubePositions[] = {
    255. 		  glm::vec3(0.0f,  0.0f,  0.0f),
    256. 		  glm::vec3(2.0f,  5.0f, -15.0f),
    257. 		  glm::vec3(-1.5f, -2.2f, -2.5f),
    258. 		  glm::vec3(-3.8f, -2.0f, -12.3f),
    259. 		  glm::vec3(2.4f, -0.4f, -3.5f),
    260. 		  glm::vec3(-1.7f,  3.0f, -7.5f),
    261. 		  glm::vec3(1.3f, -2.0f, -2.5f),
    262. 		  glm::vec3(1.5f,  2.0f, -2.5f),
    263. 		  glm::vec3(1.5f,  0.2f, -1.5f),
    264. 		  glm::vec3(-1.3f,  1.0f, -1.5f)
    265. 	};
    266.  
    267. 	while (!glfwWindowShouldClose(window))
    268. 	{
    269. 		/*输入*/
    270. 		processInput(window);		
    271. 		ourShader.setFloat("ratio", ratio);
    272.  
    273. 		/*
    274. 		渲染指令
    275. 		激活,在glUseProgram函数调用之后，每个着色器调用和渲染调用都会使用这个程序对象
    276. 		（也就是之前写的着色器)了。
    277. 		*/
    278. 		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    279. 		glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
    280. 		glClear(GL_COLOR_BUFFER_BIT);
    281.  
    282. 		glBindVertexArray(VAO);
    283.  
    284.  
    285. 		/*先缩放，再旋转，最后位移，显示出来就是trans先位移，再旋转，最后缩放	*/
    286. 		glm::mat4 view = glm::mat4(1.0f);
    287. 		view = glm::translate(view, glm::vec3(1.0f, -0.0f, -3.0f));
    288. 		unsigned int  transformLoc = glGetUniformLocation(ourShader.ID, "view");
    289. 		glUniformMatrix4fv(transformLoc, 1, GL_FALSE, glm::value_ptr(view));
    290.  
    291. 		glm::mat4 projection = glm::mat4(1.0f);
    292. 		projection = glm::perspective(glm::radians(70.0f), 800.0f / 600.0f, 0.1f, 100.0f);
    293. 		transformLoc = glGetUniformLocation(ourShader.ID, "projection");
    294. 		glUniformMatrix4fv(transformLoc, 1, GL_FALSE, glm::value_ptr(projection));
    295.  
    296.  
    297. 		for(unsigned int i = 0; i< 10; i++)
    298. 		{
    299. 			glm::mat4 model = glm::mat4(1.0f);
    300. 			model = glm::translate(model, cubePositions[i]);
    301. 			model = glm::rotate(model, (float)glfwGetTime() * glm::radians(50.0f), glm::vec3(1.0f, 1.0f, 0.0f));
    302. 			//model = glm::scale(model, glm::vec3(0.5, 0.5, 0.5));
    303. 			transformLoc = glGetUniformLocation(ourShader.ID, "model");
    304. 			glUniformMatrix4fv(transformLoc, 1, GL_FALSE, glm::value_ptr(model));
    305. 			glDrawArrays(GL_TRIANGLES, 0, 36);
    306. 		}
    307.  
    308.  
    309. 		//glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
    310.  
    311.  
    312. 		/*检查并调用事件，交换缓冲*/
    313. 		glfwSwapBuffers(window);
    314. 		glfwPollEvents();
    315. 	}
    316.  
    317. 	glDeleteVertexArrays(1, &VAO);
    318. 	glDeleteBuffers(1, &VBO);
    319. 	glDeleteBuffers(1, &EBO);
    320.  
    321. 	glfwTerminate();
    322. 	return 0;
    323. }
    324.  
    325.

    6，摄像机 

    如何构建view矩阵：

    这个图中的坐标是将世界坐标绕y轴旋转了180度

     问：为什么要先乘位移矩阵再乘旋转矩阵呢？

     因旋转矩阵将坐标轴一起旋转额，沿着x轴位移就变成了沿着旋转后的x轴位移了

    view矩阵（观察矩阵）：

    1. glm::mat4 view;
    2. view = glm::lookAt(glm::vec3(0.0f, 0.0f, 3.0f), 
    3.            glm::vec3(0.0f, 0.0f, 0.0f), 
    4.            glm::vec3(0.0f, 1.0f, 0.0f));

    lookat函数的推导：

    [OpenGL] 视图矩阵（View）矩阵与glm::lookAt函数源码解析_Zeehoy的博客-CSDN博客_glm::lookat

    欧拉角：

     滚转角不讨论是因为无论怎么旋转移动，都是z轴正方向对着我们（摄像机）

  • 相关阅读:
    Java-面向对象之（抽象类+接口）
    图像噪声，ISP，ISO与analog gain
    【RabbitMQ 实战】12 镜像队列
    全职独立开发经验分享
    【AIGC调研系列】利用AIGC技术进行DevOps流水线智能排查
    go搭建服务器基础
    独立站的五个免费流量获取方式
    k8s入门之Secret(十)
    tinyxml
    【小波能量BP】基于小波能量系数提取和BP神经网络的检测算法matlab仿真
  • 原文地址：https://blog.csdn.net/asiwxy/article/details/128003837