OpenGL学习笔记——纹理

Dear 丶 2023-01-13 10:52 267阅读 0赞

文章目录

  • 一、简介
  • 二、代码实现
    • 2.1单个纹理对象与单元
    • 2.2多个纹理单元与对象

一、简介

如果我们的程序单纯的只是一些颜色什么的，未免不够真实和有趣，但是如果让我们为每一个像素都手动的分配更为真实的颜色值，又过于繁杂而不切实际，因此在OpenGL中也就有了纹理映射这一过程（或者说是为我们的图形进行贴图）。

纹理映射的过程其实非常类似于缓冲区分配的过程，都是在设置OpenGL的状态：
1、创建一个纹理对象。
2、激活纹理单元，并绑定相应的纹理对象。
3、为纹理对象设置相应的参数并将数据传递给纹理对象。
4、在着色器程序中利用纹理采样器（simple2D或者是其他类型），根据纹理坐标以及纹理对象实现对颜色的采样。这一工作主要集中在片元着色器中。
5、绘制出相应的纹理图案。

二、代码实现

2.1单个纹理对象与单元

shader.h

  1. #ifndef SHADER_H
  2. #define SHADER_H
  3. #include <glad/glad.h> // include glad to get all the required OpenGL headers
  5. #include"glm\glm.hpp" //矩阵部分头文件
  6. #include"glm\gtc\matrix_transform.hpp"
  7. #include"glm\gtc\type_ptr.hpp"
  9. #include <string>
  10. #include <fstream>
  11. #include <sstream>
  12. #include <iostream>
  15. class Shader
  16. { 
  17. public:
  18.     // the program ID
  19.     unsigned int ID;
  21.     // constructor reads and builds the shader
  22.     Shader(const char* vertexPath, const char* fragmentPath);
  23.     // use/activate the shader
  24.     void use();
  25.     // utility uniform functions
  26.     void setBool(const std::string &name, bool value) const;
  27.     void setInt(const std::string &name, int value) const;
  28.     void setFloat(const std::string &name, float value) const;
  29.     void setVec2(const std::string &name, const glm::vec2 &value) const;
  30.     void setVec2(const std::string &name, float x, float y) const;
  31.     void setVec3(const std::string &name, const glm::vec3 &value) const;
  32.     void setVec3(const std::string &name, float x, float y, float z) const;
  33.     void setVec4(const std::string &name, const glm::vec4 &value) const;
  34.     void setVec4(const std::string &name, float x, float y, float z, float w) const;
  35.     void setMat2(const std::string &name, const glm::mat2 &mat) const;
  36.     void setMat3(const std::string &name, const glm::mat3 &mat) const;
  37.     void setMat4(const std::string &name, const glm::mat4 &mat) const;
  39. private:
  40.     void checkCompileErrors(GLuint shader, std::string type);
  42. };
  44. Shader::Shader(const char * vertexPath, const char * fragmentPath)
  45. { 
  46.     // 1. retrieve the vertex/fragment source code from filePath
  47.     std::string vertexCode;
  48.     std::string fragmentCode;
  49.     std::ifstream vShaderFile;
  50.     std::ifstream fShaderFile;
  51.     // ensure ifstream objects can throw exceptions:
  52.     vShaderFile.exceptions(std::ifstream::failbit | std::ifstream::badbit);
  53.     fShaderFile.exceptions(std::ifstream::failbit | std::ifstream::badbit);
  54.     try
  55.     { 
  56.         // open files
  57.         vShaderFile.open(vertexPath);
  58.         fShaderFile.open(fragmentPath);
  59.         std::stringstream vShaderStream, fShaderStream;
  60.         // read file's buffer contents into streams
  61.         vShaderStream << vShaderFile.rdbuf();    //重定向方法，读取文件数据
  62.         fShaderStream << fShaderFile.rdbuf();    //将文件内容通过缓冲区传递给stringstream对象
  63.                                                 // close file handlers
  64.         vShaderFile.close();
  65.         fShaderFile.close();
  66.         // convert stream into string，将stringstream对象转换为string对象
  67.         vertexCode = vShaderStream.str();
  68.         fragmentCode = fShaderStream.str();
  69.     }
  70.     catch (std::ifstream::failure e)
  71.     { 
  72.         std::cout << "ERROR::SHADER::FILE_NOT_SUCCESFULLY_READ" << std::endl;
  73.     }
  74.     const char* vShaderCode = vertexCode.c_str();
  75.     const char* fShaderCode = fragmentCode.c_str();
  77.     // 2. compile shaders
  78.     unsigned int vertex, fragment;
  79.     int success;
  80.     char infoLog[512];
  82.     // vertex Shader
  83.     vertex = glCreateShader(GL_VERTEX_SHADER);
  84.     glShaderSource(vertex, 1, &vShaderCode, NULL);        //将源码传递给顶点着色器对象
  85.     glCompileShader(vertex);    //运行时动态编译着色器源码，并生成着色器对象
  87.     // print compile errors if any
  88.     glGetShaderiv(vertex, GL_COMPILE_STATUS, &success);
  89.     if (!success)
  90.     { 
  91.         glGetShaderInfoLog(vertex, 512, NULL, infoLog);
  92.         std::cout << "ERROR::SHADER::VERTEX::COMPILATION_FAILED\n" << infoLog << std::endl;
  93.     };
  95.     // similiar for Fragment Shader
  96.     // fragment Shader
  97.     fragment = glCreateShader(GL_FRAGMENT_SHADER);
  98.     glShaderSource(fragment, 1, &fShaderCode, NULL);
  99.     glCompileShader(fragment);
  100.     //checkCompileErrors(fragment, "FRAGMENT");
  102.     // shader Program
  103.     ID = glCreateProgram();        //创建一个程序对象
  104.     glAttachShader(ID, vertex);        //将着色器对象添加到程序对象之中
  105.     glAttachShader(ID, fragment);
  106.     glLinkProgram(ID);        //链接为真正的着色器程序
  107.     // print linking errors if any
  108.     glGetProgramiv(ID, GL_LINK_STATUS, &success);
  109.     if (!success)
  110.     { 
  111.         glGetProgramInfoLog(ID, 512, NULL, infoLog);
  112.         std::cout << "ERROR::SHADER::PROGRAM::LINKING_FAILED\n" << infoLog << std::endl;
  113.     }
  115.     // delete the shaders as they're linked into our program now and no longer necessary
  116.     glDeleteShader(vertex);        //在生成真正的着色器程序之后，则着色器对象将没有用处
  117.     glDeleteShader(fragment);
  118. }
  120. void Shader::use() { 
  121.     glUseProgram(ID);
  122. }
  124. void Shader::setBool(const std::string & name, bool value) const
  125. { 
  126.     glUniform1i(glGetUniformLocation(ID, name.c_str()), (int)value);
  127. }
  129. void Shader::setInt(const std::string & name, int value) const
  130. { 
  131.     glUniform1i(glGetUniformLocation(ID, name.c_str()), value);
  132. }
  134. void Shader::setFloat(const std::string & name, float value) const
  135. { 
  136.     glUniform1f(glGetUniformLocation(ID, name.c_str()), value);
  137. }
  139. void Shader::setVec2(const std::string & name, const glm::vec2 & value) const
  140. { 
  141.     glUniform2fv(glGetUniformLocation(ID, name.c_str()), 1, &value[0]);
  142. }
  144. void Shader::setVec2(const std::string & name, float x, float y) const
  145. { 
  146.     glUniform2f(glGetUniformLocation(ID, name.c_str()), x, y);
  147. }
  149. void Shader::setVec3(const std::string & name, const glm::vec3 & value) const
  150. { 
  151.     glUniform3fv(glGetUniformLocation(ID, name.c_str()), 1, &value[0]);
  152. }
  154. void Shader::setVec3(const std::string & name, float x, float y, float z) const
  155. { 
  156.     glUniform3f(glGetUniformLocation(ID, name.c_str()), x, y, z);
  157. }
  159. void Shader::setVec4(const std::string & name, const glm::vec4 & value) const
  160. { 
  161.     glUniform4fv(glGetUniformLocation(ID, name.c_str()), 1, &value[0]);
  162. }
  164. void Shader::setVec4(const std::string & name, float x, float y, float z, float w) const
  165. { 
  166.     glUniform4f(glGetUniformLocation(ID, name.c_str()), x, y, z, w);
  167. }
  169. void Shader::setMat2(const std::string & name, const glm::mat2 & mat) const
  170. { 
  171.     glUniformMatrix2fv(glGetUniformLocation(ID, name.c_str()), 1, GL_FALSE, &mat[0][0]);
  172. }
  174. void Shader::setMat3(const std::string & name, const glm::mat3 & mat) const
  175. { 
  176.     glUniformMatrix3fv(glGetUniformLocation(ID, name.c_str()), 1, GL_FALSE, &mat[0][0]);
  177. }
  179. void Shader::setMat4(const std::string & name, const glm::mat4 & mat) const
  180. { 
  181.     glUniformMatrix4fv(glGetUniformLocation(ID, name.c_str()), 1, GL_FALSE, &mat[0][0]);
  182. }
  184. void Shader::checkCompileErrors(GLuint shader, std::string type)
  185. { 
  186.     GLint success;
  187.     GLchar infoLog[1024];
  188.     if (type != "PROGRAM")
  189.     { 
  190.         glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
  191.         if (!success)
  192.         { 
  193.             glGetShaderInfoLog(shader, 1024, NULL, infoLog);
  194.             std::cout << "ERROR::SHADER_COMPILATION_ERROR of type: " << type << "\n" << infoLog << "\n -- --------------------------------------------------- -- " << std::endl;
  195.         }
  196.     }
  197.     else
  198.     { 
  199.         glGetProgramiv(shader, GL_LINK_STATUS, &success);
  200.         if (!success)
  201.         { 
  202.             glGetProgramInfoLog(shader, 1024, NULL, infoLog);
  203.             std::cout << "ERROR::PROGRAM_LINKING_ERROR of type: " << type << "\n" << infoLog << "\n -- --------------------------------------------------- -- " << std::endl;
  204.         }
  205.     }
  206. }
  208. #endif

main.cpp

  1. #include<glad\glad.h>
  2. #include<GLFW\glfw3.h>
  3. #include"shader.h"
  5. #define STB_IMAGE_IMPLEMENTATION
  6. #include "stb_image.h"
  8. #include<iostream>
  10. int main() { 
  11.     glfwInit();
  13.     glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
  14.     glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
  15.     glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
  17.     GLFWwindow *window = glfwCreateWindow(800, 600, "Texture", 0, 0);
  18.     if (window == NULL) { 
  19.         std::cout << "创建窗口失败" << std::endl;
  20.         glfwTerminate();        //释放glfw相关资源
  21.         return -1;
  22.     }
  24.     glfwMakeContextCurrent(window);        //为特定的窗口创建一个上下文
  26.     if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {         //加载相关的函数地址
  27.         std::cout << "GLAD初始化失败，函数地址无法被加载" << std::endl;
  28.         return -1;
  29.     }
  31.     //设置视口，类似于现实生活中的窗户
  32.     /*int viewWidth, viewHeight; glfwGetFramebufferSize(window, &viewWidth, &viewHeight); glViewport(0, 0, 800, 600);*/
  34.     //初始化我们的着色器
  35.     Shader ourShader("../Shader/shader_texture.vs", "../Shader/shader_texture.fs");
  37.     //数据部分
  38.     static float vertices[] = { 
  39.         // positions // colors // texture coords
  40.         0.5f,  0.5f, 0.0f,   1.0f, 0.0f, 0.0f,   1.0f, 1.0f,   // top right
  41.         0.5f, -0.5f, 0.0f,   0.0f, 1.0f, 0.0f,   1.0f, 0.0f,   // bottom right
  42.         -0.5f, -0.5f, 0.0f,   0.0f, 0.0f, 1.0f,   0.0f, 0.0f,   // bottom left
  43.         -0.5f,  0.5f, 0.0f,   1.0f, 1.0f, 0.0f,   0.0f, 1.0f    // top left 
  44.     };
  46.     unsigned int indices[] = {         //由于OpenGL的基础图元只有三种：点、线以及三角形，所以我们这里使用两个三角形来构建一个矩形
  47.         0, 1, 3, // first triangle
  48.         1, 2, 3  // second triangle
  49.     };
  51.     //GPU部分
  52.     unsigned int VBO, VAO, EBO;        //这些变量有点类似于我们经常使用的文件描述符，也可以说是“句柄”，主要是用来管理GPU分配的内存
  53.     glGenVertexArrays(1, &VAO);        //创建一个顶点数组对象名字,类似于声明
  54.     glGenBuffers(1, &VBO);            //创建一个缓冲区对象名字
  55.     glGenBuffers(1, &EBO);            
  57.     glBindVertexArray(VAO);            //绑定顶点数组对象，并为其分配内存空间
  58.     glBindBuffer(GL_ARRAY_BUFFER, VBO);        //将VBO绑定到一个目标上，不同的目标代表这不同的用途
  59.     glBufferData(GL_ARRAY_BUFFER,sizeof(vertices),vertices,GL_STATIC_DRAW);        //将数据传给GL_ARRAY_BUFFER目标上的VBO缓冲对象
  61.     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
  62.     glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
  64.     //指定顶点数据属性不同部分的意义
  65.     //位置，第一部分
  66.     glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)0);
  67.     glEnableVertexAttribArray(0);        //启用这一部分属性数组
  69.     //颜色，第二部分
  70.     glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(3 * sizeof(float)));
  71.     glEnableVertexAttribArray(1);
  73.     //纹理，第三部分
  74.     glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(6 * sizeof(float)));
  75.     glEnableVertexAttribArray(2);
  77.     //设置纹理,类似于上面缓冲区的设置过程
  78.     unsigned int texture;
  79.     glGenTextures(1, &texture);
  80.     //glActiveTexture(GL_TEXTURE0); //默认是激活的，所以可以不写
  81.     glBindTexture(GL_TEXTURE_2D, texture);
  82.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);        //设置我们想要的坐标轴S、T
  83.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
  84.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);    //图像分辨率大但是窗口小时，所采用的策略
  85.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  87.     //加载图像
  88.     int width, height, nrChannels;
  89.     unsigned char *data = stbi_load("container.jpg", &width, &height, &nrChannels, 0);
  90.     if (data)
  91.     { 
  92.         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);        //将图像传递给纹理对象
  93.         glGenerateMipmap(GL_TEXTURE_2D);    //为当前绑定的纹理自动生成所有需要的多级渐远纹理
  94.     }
  95.     else
  96.     { 
  97.         std::cout << "Failed to load texture" << std::endl;
  98.     }
  99.     stbi_image_free(data);        //释放加载进来的图像数据内存
  100.     //glBindTexture(GL_TEXTURE_2D, 0); //解绑纹理对象
  102.     ourShader.use();
  103.     while (!glfwWindowShouldClose(window))
  104.     { 
  105.         //渲染
  106.         glClearColor(0.2f, 0.3f, 0.3f, 1.0f);        //指定了清除缓冲区所用的颜色
  107.         glClear(GL_COLOR_BUFFER_BIT);
  109.         glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);    //使用GL_ELEMENT_ARRAY_BUFFER目标上的对象绘制两个三角形以达到四边形的效果
  111.         glfwSwapBuffers(window);
  112.         glfwPollEvents();        //检测所有的事件(键盘、鼠标或者一些窗口的状态等)是否被触发
  113.     }
  115.     glDeleteVertexArrays(1, &VAO);
  116.     glDeleteBuffers(1, &VBO);
  117.     glDeleteBuffers(1, &EBO);
  119.     glfwTerminate();
  121.     return 0;
  122. }

着色器部分：

shader_texture.vs

  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;
  6. out vec3 ourColor;
  7. out vec2 TexCoord;
  9. void main()
  10. { 
  11.     gl_Position = vec4(aPos, 1.0);
  12.     ourColor = aColor;
  13.     TexCoord = aTexCoord;
  14. }

shader_texture.fs

  1. #version 330 core
  2. out vec4 FragColor;
  4. in vec3 ourColor;
  5. in vec2 TexCoord;
  7. uniform sampler2D ourTexture;
  8. //uniform sampler2D texture1;
  9. //uniform sampler2D texture2;
  11. void main()
  12. { 
  13.     FragColor = texture(ourTexture, TexCoord);
  14.     //FragColor = texture(ourTexture, TexCoord)*vec4(ourColor, 1.0);
  15.     //FragColor = mix(texture(texture1, TexCoord), texture(texture2, TexCoord), 0.2);
  16. }

实现效果：
在这里插入图片描述

在这里要特别注意着色器中ourTexture这个uniform变量，它并没有在CPU端被修改，但是它仍然正常工作了，这是因为OpenGL总是会默认激活一个纹理单元GL_TEXTURE0，这个纹理单元已经与texture纹理对象进行了关联，所以变量ourTexture会默认利用纹理坐标来对texture纹理对象进行颜色的采样。

2.2多个纹理单元与对象

OpenGL中存在大约16个纹理单元，因此其可以同时利用多个纹理对象来绘制一些比较有趣图案。

修改上述纹理部分的代码，如下所示：

  1. //设置纹理,类似于上面缓冲区的设置过程
  2.         unsigned int texture1, texture2;
  3.         glGenTextures(1, &texture1);
  4.         //glActiveTexture(GL_TEXTURE0); //默认是激活的，所以可以不写
  5.         glBindTexture(GL_TEXTURE_2D, texture1);
  6.         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);        //设置我们想要的坐标轴S、T
  7.         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
  8.         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);    //图像分辨率大但是窗口小时，所采用的策略
  9.         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  11.         //加载图像
  12.         int width, height, nrChannels;
  13.         unsigned char *data = stbi_load("container.jpg", &width, &height, &nrChannels, 0);
  14.         if (data)
  15.         { 
  16.             std::cout << "container:" << nrChannels << std::endl;
  17.             glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);        //将图像传递给纹理对象
  18.             glGenerateMipmap(GL_TEXTURE_2D);    //为当前绑定的纹理自动生成所有需要的多级渐远纹理
  19.         }
  20.         else
  21.         { 
  22.             std::cout << "Failed to load texture" << std::endl;
  23.         }
  24.         stbi_image_free(data);        //释放加载进来的图像数据内存
  25.         //glBindTexture(GL_TEXTURE_2D, 0); //解绑纹理对象
  27.         //设置第二个纹理对象
  28.         glGenTextures(1, &texture2);
  29.         glBindTexture(GL_TEXTURE_2D, texture2);
  30.         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);        //设置我们想要的坐标轴S、T
  31.         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
  32.         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);    //图像分辨率大但是窗口小时，所采用的策略
  33.         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  35.         data = stbi_load("awesomeface.png", &width, &height, &nrChannels, 0);
  36.         if (data)
  37.         { 
  38.             std::cout << "awesomeface:" << nrChannels<<std::endl;
  39.             glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);        //将图像传递给纹理对象
  40.             glGenerateMipmap(GL_TEXTURE_2D);    //为当前绑定的纹理自动生成所有需要的多级渐远纹理
  41.         }
  42.         else
  43.         { 
  44.             std::cout << "Failed to load texture" << std::endl;
  45.         }
  46.         stbi_image_free(data);        //释放加载进来的图像数据内存
  47.         //glBindTexture(GL_TEXTURE_2D, 0); //解绑纹理对象
  49.         ourShader.use();
  50.         glUniform1i(glGetUniformLocation(ourShader.ID, "texture1"), 0);
  51.         ourShader.setInt("texture2", 1);
  53.         //绑定相应的纹理对象
  54.         glActiveTexture(GL_TEXTURE0);
  55.         glBindTexture(GL_TEXTURE_2D, texture1);
  56.         glActiveTexture(GL_TEXTURE1);
  57.         glBindTexture(GL_TEXTURE_2D, texture2);

运行效果如下所示：
在这里插入图片描述

不过因为纹理坐标的坐标系统与图片的坐标系统有点不一样（y轴不同），导致图片相对于窗口是倒置的，要想解决这个问题我们可以用书中提到的两个小方法：
1、翻转y值，也就是用1减去y值。
2、可以经着色器中的aTexCoord替换为vec2(aTexCoord.x, 1.0f - aTexCoord.y)。
我这里是使用了第一种方法，将顶点数据中的纹理坐标修改为下面的这种形式就正常了：

  1. static float vertices[] = { 
  2.             // positions // colors // texture coords
  3.             0.5f,  0.5f, 0.0f,   1.0f, 0.0f, 0.0f,   1.0f, 0.0f,   // top right
  4.             0.5f, -0.5f, 0.0f,   0.0f, 1.0f, 0.0f,   1.0f, 1.0f,   // bottom right
  5.             -0.5f, -0.5f, 0.0f,   0.0f, 0.0f, 1.0f,   0.0f, 1.0f,   // bottom left
  6.             -0.5f,  0.5f, 0.0f,   1.0f, 1.0f, 0.0f,   0.0f, 0.0f    // top left 
  7.         };

在这里插入图片描述

参考资料：《Learning OpenGL》 《OpenGL编程指南》

发表评论

表情：
评论列表 （有 0 条评论，267人围观）

还没有评论，来说两句吧...

相关阅读

    相关 OpenGL纹理置换编程

    在OpenGL中，纹理贴图是一种常用的技术，用于将图像或图案应用到3D模型表面上。然而，有时仅仅使用静态纹理贴图可能会显得单调，无法达到想要的效果。在这种情况下，使用纹理置换技

    逃离我推掉我的手逃离我推掉我的手/ 0 赞/ 164 阅读

    相关 openGL纹理

    纹理压缩技术已经广泛应用在各种3D游戏之中，它们包括：DXTC（Direct X Texture Compress，DirectX纹理压缩，以S3TC为基础）、S3TC（S3

    野性酷女野性酷女/ 0 赞/ 370 阅读

    相关 OpenGL纹理贴图

    1.纹理贴图的步骤 1）创建纹理对象，并为它指定一个纹理。 glGenTextures() glGenerateMipmap() 2）确定纹理如何应用到每个像素上 g

    墨蓝墨蓝/ 0 赞/ 436 阅读