纹理
由于坐标差异，读取图像后要反转y轴，读取后发到显存后记得把内存里的图片对象释放掉
之后生成纹理激活绑定，纹理数据传输到显存
根据uv坐标去采样，设置uv数据，传入vbo，加入描述数据
设置采样器，纹理对象-纹理单元-采样器。采样器用uniform变量，适用texture函数调用
sampler通过int传递，设置
最后设置纹理过滤方式和包裹方式
main.cpp
#include <iostream>
#include "glframework/core.h"
#include "glframework/shader.h"
#include <string>
#include <assert.h>//断言
#include "wrapper/checkError.h"
#include "application/Application.h"
#define STB_IMAGE_IMPLEMENTATION
#include "application/stb_image.h"
/*
*┌────────────────────────────────────────────────┐
*│ 目 标： 纹理与采样
*│ 讲 师： 赵新政(Carma Zhao)
*│ 拆分目标：
* 1 创建纹理对象
-图片读取-StbImage
-创建纹理对象（texture）
-绑定纹理单元（1、激活纹理单元 2、bind纹理对象）
-传输图片数据(描述、内容数据)
* 2 设置纹理过滤方式
* -当需要的像素 > 图片的像素 Linear
* -当需要的像素 < 图片的像素 Nearest
* 3 设置纹理包裹方式（Wrapping）
* -Repeat Mirror ClampToEdge ClampToBorder
* 4 采样器与采样
* -加入uv属性数据，并且单独开辟一个vbo
* -vs中加入uv属性的获取以及向下个阶段的传输，fs加入获取uv数值
* -fs中加入采样器，并且通过采样器采样颜色
* -将采样器与某一个纹理单元绑定
*└────────────────────────────────────────────────┘
*/
GLuint vao;
GLuint texture;
Shader* shader = nullptr;
void OnResize(int width, int height) {
GL_CALL(glViewport(0, 0, width, height));
std::cout << "OnResize" << std::endl;
}
void OnKey(int key, int action, int mods) {
std::cout << key << std::endl;
}
void prepareVAO() {
//1 准备positions colors
float positions[] = {
-0.5f, -0.5f, 0.0f,
0.5f, -0.5f, 0.0f,
0.0f, 0.5f, 0.0f,
};
float colors[] = {
1.0f, 0.0f,0.0f,
0.0f, 1.0f,0.0f,
0.0f, 0.0f,1.0f
};
float uvs[] = {
0.0f, 0.0f,
1.0f, 0.0f,
0.5f, 1.0f,
};
unsigned int indices[] = {
0, 1, 2
};
//2 VBO创建
GLuint posVbo, colorVbo, uvVbo;
glGenBuffers(1, &posVbo);
glBindBuffer(GL_ARRAY_BUFFER, posVbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(positions), positions, GL_STATIC_DRAW);
glGenBuffers(1, &colorVbo);
glBindBuffer(GL_ARRAY_BUFFER, colorVbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(colors), colors, GL_STATIC_DRAW);
glGenBuffers(1, &uvVbo);
glBindBuffer(GL_ARRAY_BUFFER, uvVbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(uvs), uvs, GL_STATIC_DRAW);
//3 EBO创建
GLuint ebo;
glGenBuffers(1, &ebo);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
//4 VAO创建
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
//5 绑定vbo ebo 加入属性描述信息
//5.1 加入位置属性描述信息
glBindBuffer(GL_ARRAY_BUFFER, posVbo);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 3, (void*)0);
//5.2 加入颜色属性描述数据
glBindBuffer(GL_ARRAY_BUFFER, colorVbo);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 3, (void*)0);
//5.3 加入uv属性描述数据
glBindBuffer(GL_ARRAY_BUFFER, uvVbo);
glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 2, (void*)0);
//5.4 加入ebo到当前的vao
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
glBindVertexArray(0);
}
void prepareShader() {
shader = new Shader("assets/shaders/vertex.glsl","assets/shaders/fragment.glsl");
}
void prepareTexture() {
//1 stbImage 读取图片
int width, height, channels;
//--反转y轴
stbi_set_flip_vertically_on_load(true);
unsigned char* data = stbi_load("assets/textures/goku.jpg", &width, &height, &channels, STBI_rgb_alpha);
//2 生成纹理并且激活单元绑定
glGenTextures(1, &texture);
//--激活纹理单元--
glActiveTexture(GL_TEXTURE0);
//--绑定纹理对象--
glBindTexture(GL_TEXTURE_2D, texture);
//3 传输纹理数据,开辟显存
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
//***释放数据
stbi_image_free(data);
//4 设置纹理的过滤方式
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
//5 设置纹理的包裹方式
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);//u
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);//v
}
void render() {
//执行opengl画布清理操作
GL_CALL(glClear(GL_COLOR_BUFFER_BIT));
//绑定当前的program
shader->begin();
shader->setInt("sampler", 0);
//绑定当前的vao
GL_CALL(glBindVertexArray(vao));
//发出绘制指令
GL_CALL(glDrawElements(GL_TRIANGLES, 3, GL_UNSIGNED_INT, 0));
GL_CALL(glBindVertexArray(0));
shader->end();
}
int main() {
if (!app->init(800, 600)) {
return -1;
}
app->setResizeCallback(OnResize);
app->setKeyBoardCallback(OnKey);
//设置opengl视口以及清理颜色
GL_CALL(glViewport(0, 0, 800, 600));
GL_CALL(glClearColor(0.2f, 0.3f, 0.3f, 1.0f));
prepareShader();
prepareVAO();
prepareTexture();
while (app->update()) {
render();
}
app->destroy();
return 0;
}
fragment.glsl
#version 460 core
out vec4 FragColor;
in vec3 color;
in vec2 uv;
uniform sampler2D sampler;
void main()
{
FragColor = texture(sampler, uv);
}
shader.cpp
#include"shader.h"
#include"../wrapper/checkError.h"
#include<string>
#include<fstream>
#include<sstream>
#include<iostream>
Shader::Shader(const char* vertexPath, const char* fragmentPath) {
//声明装入shader代码字符串的两个string
std::string vertexCode;
std::string fragmentCode;
//声明用于读取vs跟fs文件的inFileStream
std::ifstream vShaderFile;
std::ifstream fShaderFile;
//保证ifstream遇到问题的时候可以抛出异常
vShaderFile.exceptions(std::ifstream::failbit | std::ifstream::badbit);
fShaderFile.exceptions(std::ifstream::failbit | std::ifstream::badbit);
try {
//1 打开文件
vShaderFile.open(vertexPath);
fShaderFile.open(fragmentPath);
//2 将文件输入流当中的字符串输入到stringStream里面
std::stringstream vShaderStream, fShaderStream;
vShaderStream << vShaderFile.rdbuf();
fShaderStream << fShaderFile.rdbuf();
//3 关闭文件
vShaderFile.close();
fShaderFile.close();
//4 将字符串从stringStream当中读取出来，转化到code String当中
vertexCode = vShaderStream.str();
fragmentCode = fShaderStream.str();
}
catch (std::ifstream::failure& e) {
std::cout << "ERROR: Shader File Error: " << e.what() << std::endl;
}
const char* vertexShaderSource = vertexCode.c_str();
const char* fragmentShaderSource = fragmentCode.c_str();
//1 创建Shader程序（vs、fs）
GLuint vertex, fragment;
vertex = glCreateShader(GL_VERTEX_SHADER);
fragment = glCreateShader(GL_FRAGMENT_SHADER);
//2 为shader程序输入shader代码
glShaderSource(vertex, 1, &vertexShaderSource, NULL);
glShaderSource(fragment, 1, &fragmentShaderSource, NULL);
//3 执行shader代码编译
glCompileShader(vertex);
//检查vertex编译结果
checkShaderErrors(vertex, "COMPILE");
glCompileShader(fragment);
//检查fragment编译结果
checkShaderErrors(fragment, "COMPILE");
//4 创建一个Program壳子
mProgram = glCreateProgram();
//6 将vs与fs编译好的结果放到program这个壳子里
glAttachShader(mProgram, vertex);
glAttachShader(mProgram, fragment);
//7 执行program的链接操作，形成最终可执行shader程序
glLinkProgram(mProgram);
//检查链接错误
checkShaderErrors(mProgram, "LINK");
//清理
glDeleteShader(vertex);
glDeleteShader(fragment);
}
Shader::~Shader() {
}
void Shader::begin() {
GL_CALL(glUseProgram(mProgram));
}
void Shader::end() {
GL_CALL(glUseProgram(0));
}
void Shader::setFloat(const std::string& name, float value) {
//1 通过名称拿到Uniform变量的位置Location
GLint location = GL_CALL(glGetUniformLocation(mProgram, name.c_str()));
//2 通过Location更新Uniform变量的值
GL_CALL(glUniform1f(location, value));
}
void Shader::setVector3(const std::string& name, float x, float y, float z) {
//1 通过名称拿到Uniform变量的位置Location
GLint location = GL_CALL(glGetUniformLocation(mProgram, name.c_str()));
//2 通过Location更新Uniform变量的值
GL_CALL(glUniform3f(location, x, y, z));
}
//重载 overload
void Shader::setVector3(const std::string& name, const float* values) {
//1 通过名称拿到Uniform变量的位置Location
GLint location = GL_CALL(glGetUniformLocation(mProgram, name.c_str()));
//2 通过Location更新Uniform变量的值
//第二个参数：你当前要更新的uniform变量如果是数组，数组里面包括多少个向量vec3
GL_CALL(glUniform3fv(location, 1, values));
}
void Shader::setInt(const std::string& name, int value) {
//1 通过名称拿到Uniform变量的位置Location
GLint location = GL_CALL(glGetUniformLocation(mProgram, name.c_str()));
//2 通过Location更新Uniform变量的值
glUniform1i(location, value);
}
void Shader::checkShaderErrors(GLuint target, std::string type) {
int success = 0;
char infoLog[1024];
if (type == "COMPILE") {
glGetShaderiv(target, GL_COMPILE_STATUS, &success);
if (!success) {
glGetShaderInfoLog(target, 1024, NULL, infoLog);
std::cout << "Error: SHADER COMPILE ERROR" << "\n" << infoLog << std::endl;
}
}
else if (type == "LINK") {
glGetProgramiv(target, GL_LINK_STATUS, &success);
if (!success) {
glGetProgramInfoLog(target, 1024, NULL, infoLog);
std::cout << "Error: SHADER LINK ERROR " << "\n" << infoLog << std::endl;
}
}
else {
std::cout << "Error: Check shader errors Type is wrong" << std::endl;
}
}
Comments NOTHING