OpenGL入门

最新推荐文章于 2022-03-26 12:46:41 发布
最新推荐文章于 2022-03-26 12:46:41 发布
阅读量231 收藏
点赞数
分类专栏： OpenGL 文章标签： OpenGL
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dreamcodee/article/details/102832713
版权

OpenGL

  1. 下载2个库；

  2. [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qirK307r-1572488193089)(D:\Study\openGL学习\1.png)]

  3. [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OPyufy5C-1572488193090)(D:\Study\openGL学习\2.png)]

  4. [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XgU4YDd4-1572488193090)(D:\Study\openGL学习\3.png)]

  5. 一个物件一个VAO 顶点数组对象

  6. VBO 顶点缓冲对象；

    1. 使用这些缓冲对象的好处是我们可以一次性的发送一大批数据到显卡上，而不是每个顶点发送一次。从CPU把数据发送到显卡相对较慢，所以只要可能我们都要尝试尽量一次性发送尽可能多的数据。所以我们可以使用glGenBuffers函数和一个缓冲ID生成一个VBO对象

      unsigned int VBO;
glGenBuffers(1, &VBO);

    2. 顶点缓冲对象的缓冲类型是GL_ARRAY_BUFFER。OpenGL允许我们同时绑定多个缓冲，只要它们是不同的缓冲类型。我们可以使用glBindBuffer函数把新创建的缓冲绑定到GL_ARRAY_BUFFER目标上：

      glBindBuffer(GL_ARRAY_BUFFER, VBO);

    3. 从这一刻起，我们使用的任何（在GL_ARRAY_BUFFER目标上的）缓冲调用都会用来配置当前绑定的缓冲(VBO)。然后我们可以调用glBufferData函数，它会把之前定义的顶点数据复制到缓冲的内存中：

      glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

  7. 顶点着色器；

    #version 330 core
layout (location = 0) in vec3 aPos;
void main()
{
    gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0);
}

  8. 编译着色器；

    unsigned int vertexShader;
vertexShader = glCreateShader(GL_VERTEX_SHADER);

glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);
glCompileShader(vertexShader);

  9. 片段着色器；

    #version 330 core
out vec4 FragColor;
void main()
{
    FragColor = vec4(1.0f, 0.5f, 0.2f, 1.0f);
}

  10. 着色器程序；

    unsigned int shaderProgram;
shaderProgram = glCreateProgram();

glAttachShader(shaderProgram, vertexShader);
glAttachShader(shaderProgram, fragmentShader);
glLinkProgram(shaderProgram);

glUseProgram(shaderProgram);
glDeleteShader(vertexShader);
glDeleteShader(fragmentShader);

  11. 链接顶点属性;

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

  12. 顶点数组对象: VAO 去 VBO 挖；

    unsigned int VAO;
glGenVertexArrays(1, &VAO);

// ..:: 初始化代码（只运行一次 (除非你的物体频繁改变)） :: ..
// 1. 绑定VAO
glBindVertexArray(VAO);
// 2. 把顶点数组复制到缓冲中供OpenGL使用
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
// 3. 设置顶点属性指针
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
glEnableVertexAttribArray(0);

[...]

// ..:: 绘制代码（渲染循环中） :: ..
// 4. 绘制物体
glUseProgram(shaderProgram);
glBindVertexArray(VAO);
someOpenGLFunctionThatDrawsOurTriangle();

glUseProgram(shaderProgram);
glBindVertexArray(VAO);
glDrawArrays(GL_TRIANGLES, 0, 3);

  1. OPENGL 是逆时针作为画三角的正面；

    float vertices[] = {
	-0.5f, -0.5f, 0.0f,
	 0.5f, -0.5f, 0.0f,
	 0.0f,  0.5f, 0.0f,

	// 0.5f,-0.5f,0.0f, //顺序错误，逆时针画；这样画出来是背面
	 //0.0f,  0.5f, 0.0f,
	 0.8f,0.8f,0.0f
};
unsigned int indices[] = {  //索引数组；
	0,1,2, //第一个三角形
	2,1,3  //第二个三角形
}

  2. 如果画一个四边形，画两个三角形会多于2个点 占用内存；引入EBO：

    1. EBO：索引缓冲对象

      [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-u8cyo6f8-1572488193091)(D:\Study\openGL学习\4.png)]

    2. unsigned int EBO;  //索引缓冲对象
	glGenBuffers(1, &EBO);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);

    3. 开始画

      		glUseProgram(shaderProgram);
		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
		glBindVertexArray(VAO);
		//glDrawArrays(GL_TRIANGLES, 0, 6);
		glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);

  1. Shade

    #version version_number
in type in_variable_name;
in type in_variable_name;

out type out_variable_name;

uniform type uniform_name; //主要做时钟

int main()
{
  // 处理输入并进行一些图形操作
  ...
  // 输出处理过的结果到输出变量
  out_variable_name = weird_stuff_we_processed;
}

  2. 顶点着色器的 out 属性 必须和片段着色器 in对应

    //顶点着色器
const char* vertexShaderSource = 
"#version 330 core                                       \n	   "
"layout(location = 0) in vec3 aPos;                     \n	   "
"out vec4 vertexColor;									\n"//this
"void main() {\n											   "
"		gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0);	\n"
"		vertexColor = vec4(1.0,0,0,1.0);		\n"
"}\n	   ";
//片段着色器  ，对每一个像素着色
const char* fragmentShaderSource =
"#version 330 core                              \n	  "
"in vec4 vertexColor;							\n" //this 接收
"out vec4 FragColor;                            \n	  "
"void main() {\n									  "
"		FragColor = vertexColor;} \n ";  //使用变量

  3. uniform 从CPU直接向GPU灌数据； 从外部

    //片段着色器  ，对每一个像素着色
const char* fragmentShaderSource =
"#version 330 core                              \n	  "
"in vec4 vertexColor;							\n"
"uniform vec4 ourColor;							\n"   //this
"out vec4 FragColor;                            \n	  "
"void main() {\n									  "
"		FragColor = ourColor;} \n ";  //this

    CPU:

    float timeValue = glfwGetTime();
float greenValue = (sin(timeValue) / 2.0f) + 0.5f;//动态改变颜色
int vertexColorLocation = glGetUniformLocation(shaderProgram, "ourColor");
glUseProgram(shaderProgram);
glUniform4f(vertexColorLocation, 0.0f, greenValue, 0.0f, 1.0f);

  4. 插值：更多的颜色，往顶点数组新增3个属性，RGB；

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KEqbV06z-1572488193091)(D:\Study\openGL学习\5.png)]

    修改挖顶点偏移量和步长

    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)0);  //挖顶点   但是增加了颜色后 步长要变；
glEnableVertexAttribArray(0);

glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*) (3*sizeof(float)));  //挖颜色  步长变，起始偏移变
glEnableVertexAttribArray(1);

    //顶点着色器
const char* vertexShaderSource = 
"#version 330 core                                       \n	   "
"layout(location = 0) in vec3 aPos;                     \n	   "
"layout(location = 1) in vec3 aColor;                     \n	   "//this
"out vec4 vertexColor;									\n"
"void main() {\n											   "
"		gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0);	\n"
"		vertexColor = vec4(aColor.x, aColor.y, aColor.z, 1.0);\n " // this
"}\n	   ";

C++文件流读取着色器内容：

做一个shader类：

  1. .h类似于接口（此接口还可以实现方法？？？） .cpp继承类；

  2. 别的文件调用接口方法就行 用双引号引本项目下的接口；三角括号给系统用的;

    #include "Shader.h"

  3. 若用 new 产生的类，必须用*接受，而且用方法得 ->;

  4. 如果直接 产生的类 ，用.就能使用方法；

C++文件流

  1. [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GyG8j9jl-1572488193091)(D:\Study\openGL学习\6.png)]

  2. #include<fstream>
std::ifstream vertexFile;  
std::ifstream fragmentFile;      //定义流
vertexFile.open(vertexPath);    //打开文件 ，只是注册并不是读入内存；
fragmentFile.open(fragmentPath);

std::stringstream vertextSStream; // 定义string接收;
std::stringstream fragmentSStream; // 定义string接收;

vertexFile.exceptions(std::ifstream::fail||std::ifstream::badbit); //逻辑错误或者文件损坏
fragmentFile.exceptions(std::ifstream::fail || std::ifstream::badbit);
try    //异常处理
	{
		if (!vertexFile.is_open()||!fragmentFile.is_open())
		{
			throw std::exception("open file error");
		}
   		 vertextSStream << vertexFile.rdbuf(); //从硬盘读入内存的stringbuffer
		fragmentSStream << fragmentFile.rdbuf(); //从硬盘读入内存
    ---------------------------
   		 vertextString = vertextSStream.str(); //把stringbuffer里面的内容转为String塞入变量；
		fragmentString = fragmentSStream.str();
    -----------------------------
    	vertexSource = vertextString.c_str();// string转为 字符数组 塞入变量；
		fragmentSource = fragmentString.c_str();
    
    ---------------------------------
        unsigned int vertex, fragment;

		vertex = glCreateShader(GL_VERTEX_SHADER);  //顶点着色器
		glShaderSource(vertex, 1, &vertexSource, NULL);
 	glCompileShader(vertex);// 把shader从源代码转为二进制；
		checkCompileErrors(vertex, "VERTEX");

		fragment = glCreateShader(GL_FRAGMENT_SHADER); //片段着色器
		glShaderSource(fragment, 1, &fragmentSource, NULL);
		glCompileShader(fragment);
		checkCompileErrors(fragment, "FRAGMENT");

		ID = glCreateProgram(); //二进制的链接   着色器程序
		glAttachShader(ID, vertex);
		glAttachShader(ID, fragment);
		glLinkProgram(ID);
		checkCompileErrors(ID, "PROGRAM");
		glDeleteShader(vertex);   //已经连接到程序中 不在需要；
		glDeleteShader(fragment);
	}
	catch (const std::exception& ex)
	{
		printf(ex.what());
	}

void Shader::use() {
	glUseProgram(ID);
}

void Shader::checkCompileErrors(unsigned int ID, std::string type) {
	int success;
	char infoLog[512];
	if (type != "PROGRAM")
	{
		glGetShaderiv(ID, GL_COMPILE_STATUS, &success);
		if (!success) {
			glGetShaderInfoLog(ID, 512, NULL, infoLog);
			std::cout << "shader compile error:" << infoLog << std::endl;
		}
	}
	else
	{
		glGetProgramiv(ID, GL_LINK_STATUS,&success);
		if (!success) {
			glGetProgramInfoLog(ID, 512, NULL, infoLog);
			std::cout << "program linking error:" << infoLog << std::endl;
		}
	}
}

纹理：textures

  1. 使用#include “stb_image.h” 库；

  2. U,V坐标 （0-1）[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kBSbGrWS-1572488193091)(D:\Study\openGL学习\7.png)]

  3. 纹理环绕方式：

    1. repeat:重复图像 ，超过1自动重复；
    2. clamp:采边缘点 蔓延出去；
    3. mirror : 偶数次翻转

  4. 纹理过滤： 如相机离很远的时候

    1. 邻近过滤（默认）

    2. 线性过滤 ： 更平滑

    3. 多级渐远纹理 ： 距离超过一定的阈值，不计算了 直接换

      两个不同级别的多级渐远纹理层之间会产生不真实的生硬边界。就像普通的纹理过滤一样，切换多级渐远纹理级别时你也可以在两个不同多级渐远纹理级别之间使用NEAREST和LINEAR过滤。

  5. 代码

    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(6 * sizeof(float))); //挖纹理 注意步长和起始偏移
glEnableVertexAttribArray(2);

#version 330 core                                         
layout(location = 0) in vec3 aPos;                       
layout(location = 1) in vec3 aColor;     
layout(location = 2) in vec2 aTexCoord;     //this
out vec4 vertexColor;	
out vec2 TexCoord;   //this
void main() {										   
		gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0);
		vertexColor = vec4(aColor.x, aColor.y, aColor.z, 1.0);	
		TexCoord = aTexCoord;  //this
}
//然后去fragment接收
#version 330 core                 
in vec4 vertexColor;	
in vec2 TexCoord   //this

uniform sample2D ourTexture;  //this   传入的纹理号；默认0

out vec4 FragColor;               
void main() {					
		//FragColor = vertexColor;
		FragColor = texture(ourTexture,TexCoord);  //this 此方法
}

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lgFwMa9h-1572488193092)(D:\Study\openGL学习\8.png)]

  6. 绑定图片

    // 绑定图片
unsigned int TexBuffer;
	glGenTextures(1, &TexBufferA);
	glBindTexture(GL_TEXTURE_2D, TexBufferA);

int width, height, nrChannel;
unsigned char* data = stbi_load("test.jpg", &width, &height, &nrChannel, 0);
if (data) {
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
    glGenerateMipmap(GL_TEXTURE_2D);   //多级纹理
}
else {
    std::cout << "load image failed." << std::endl;
}
stbi_image_free(data);
---------------------------------
while:glBindTexture(GL_TEXTURE_2D, TexBuffer);

  7. 开启贴2张图：

    1. [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zq7wHCO9-1572488193094)(D:\Study\openGL学习\9.png)]

    2. unsigned int TexBufferA;
glGenTextures(1, &TexBufferA);
glBindTexture(GL_TEXTURE_2D, TexBufferA);
int width, height, nrChannel;
unsigned char* data = stbi_load("test.jpg", &width, &height, &nrChannel, 0);

unsigned int TexBufferB;
glGenTextures(1, &TexBufferB);
glBindTexture(GL_TEXTURE_2D, TexBufferB);
unsigned char* data2 = stbi_load("test1.jpg", &width, &height, &nrChannel, 0);

while:
glActiveTexture(GL_TEXTURE0);//开启0号匝位；
glBindTexture(GL_TEXTURE_2D, TexBufferA);
glActiveTexture(GL_TEXTURE3);//开启3号匝位；
glBindTexture(GL_TEXTURE_2D, TexBufferB);

myShader->use();
glUniform1i(glGetUniformLocation(myShader->ID,"ourTexture"),0);
glUniform1i(glGetUniformLocation(myShader->ID, "ourFace"), 3); // 手动设置

Source:
#version 330 core                                         
layout(location = 0) in vec3 aPos;        //layout就是挖               
layout(location = 1) in vec3 aColor;     
layout(location = 2) in vec2 aTexCoord;   this

out vec4 vertexColor;	
out vec2 TexCoord;
void main() {										   
		gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0);
		vertexColor = vec4(aColor.x, aColor.y, aColor.z, 1.0);	
		TexCoord = aTexCoord; this
}

#version 330 core      
out vec4 FragColor; 
in vec4 vertexColor;	
in vec2 TexCoord;

uniform sampler2D ourTexture;  this 
uniform sampler2D ourFace; this
        
void main() {					
		//FragColor = vertexColor;
		FragColor = texture(ourTexture,TexCoord)* texture(ourFace,TexCoord) ;
}

矩阵变换：

  1. 向量点乘：dot(a,b)[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pFCGkv5l-1572488193096)(D:\Study\openGL学习\10.png)]

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BafokWbn-1572488193098)(D:\Study\openGL学习\11.png)]点乘就是拿来计算夹角的；

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1dy1Tx2U-1572488193098)(D:\Study\openGL学习\12.png)]反三角

  2. 向量叉乘：cross(a,b) 可以得到同事垂直于这两个向量的向量；正交于这两个向量

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZZmEo103-1572488193099)(D:\Study\openGL学习\13.png)]

  3. 向量 乘以 矩阵 把向量看成一维矩阵！~ (实则是 矩阵乘以向量(右边))

  4. GLSL的 vec4 ***** vec4 是逐元乘法； **************

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hUDTTVGW-1572488193099)(D:\Study\openGL学习\14.png)]

  5. 向量缩放用变换矩阵的对角线即可；

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bADb3M5y-1572488193099)(D:\Study\openGL学习\15.png)]

  6. 向量位移：第四列最上面的3个值；这就是4x4的好处； 如果是位置w补1，速度补0

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JpNWf5kK-1572488193099)(D:\Study\openGL学习\16.png)]

  7. 弧度转角度：角度 = 弧度 * (180.0f / PI)

  8. 角度转弧度：弧度 = 角度 * (PI / 180.0f)

  9. 旋转[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gSHMWUel-1572488193099)(D:\Study\openGL学习\17.png)]

  10. 引入glm头文件；

    #include <glm/glm/glm.hpp>
#include <glm/glm/gtc/matrix_transform.hpp>
#include <glm/glm/gtc/type_ptr.hpp>
	glm::vec4 vec(1.0f, 0, 0, 1.0f);
	glm::mat4 trans; //单位4x4矩阵
	trans = glm::translate(trans, glm::vec3(2.0f, 0, 0));//把向量转为位移矩阵
	vec = trans * vec;

    要做旋转矩阵

    uniform mat4 transform; //在vertexSource里面;
gl_Position = transform * vec4(aPos.x, aPos.y, aPos.z, 1.0);

//在while里面；
glm::mat4 trans;
glUniformMatrix4fv(glGetUniformLocation(myShader->ID, "transform"), 1, GL_FALSE, glm::value_ptr(trans));
//while 外面:写在while里面就是动态的;
glm::mat4 trans;
trans = glm::translate(trans, glm::vec3(-1.0f, 0, 0));//位移  参数相加
trans = glm::rotate(trans, glm::radians(45.0f), glm::vec3(0, 0, 1.0f));//旋转角度与轴
trans = glm::rotate(trans,(float)glfwGetTime(), glm::vec3(0, 0, 1.0f));
//硬是把时间强转为弧度量一直转；
trans = glm::scale(trans, glm::vec3(2.0f, 2.0f, 2.0f));//放大 参数为倍数

    矩阵的组合：把多个动作组合到一起； 代码先缩放，再旋转，最后是位移；规定！

    但是：矩阵的运算方式是从右到左，所以顺序相反；

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tc1CIeno-1572488193099)(D:\Study\openGL学习\18.png)]

坐标系统：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XrfD0K8o-1572488193100)(D:\Study\openGL学习\19.png)]

  1. LocalSpace 局部空间 ：以物体中心为原点的坐标；当需要对物体进行修改的时候;

  2. WorldSpace 世界空间 ：希望将物体分散在世界上摆放,该变换是由模型矩阵(Model Matrix)实现的

  3. ViewSpace 观察空间 ：将世界空间坐标转化为用户视野前方的坐标而产生的结果,

    由观察矩阵(View Matrix),它被用来将世界坐标变换到观察空间;

  4. ClipSpace 裁剪空间 ： 只渲染镜头前的，其余的cut调；看不见的裁剪掉;

    为了将顶点坐标从观察变换到裁剪空间，我们需要定义一个投影矩阵(Projection Matrix)

    一旦所有顶点被变换到裁剪空间,最终的操作——透视除法(Perspective Division)将会执行，在这个过程中我们将位置向量的x，y，z分量分别除以向量的齐次w分量.

  5. ScreenSpace 屏幕空间 :透视投影矩阵,这个投影矩阵将给定的平截头体范围映射到裁剪空间，除此之外还修改了每个顶点坐标的w值，从而使得离观察者越远的顶点坐标w分量越大。

    顶点坐标的每个分量都会除以它的w分量，距离观察者越远顶点坐标就会越小。

    opengl会进行自动除法和裁剪：

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-z3UcjjdL-1572488193100)(D:\Study\openGL学习\20.png)]这是也是w分量非常重要的另一个原因;

    glm::mat4 obj = 
    glm::perspective(glm::radians(45.0f), (float)width/(float)height, 0.1f, 100.0f); 
//参数1：FOV，视角通常设置为45.0f；参数2:宽高比;参数34：近和远平面

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XyeoSDoH-1572488193100)(D:\Study\openGL学习\21.png)]

  6. 操作3矩阵：代码：

    //while外定义
glm::mat4 modelMat;
modelMat = glm::rotate(modelMat, glm::radians(-55.0f), glm::vec3(1.0f, 0, 0));
glm::mat4 viewMat;
viewMat = glm::translate(viewMat, glm::vec3(0, 0, -3.0f));
glm::mat4 projMat;
projMat = glm::perspective(glm::radians(45.0f), (float)800.0f / 600.0f, 0.1f, 100.0f);
//vertexSOurce写逻辑
uniform mat4 modelMat;
uniform mat4 viewMat;
uniform mat4 projMat;

gl_Position =projMat * viewMat * modelMat * vec4(aPos.x, aPos.y, aPos.z, 1.0);
//while中塞入
glUniformMatrix4fv(glGetUniformLocation(myShader->ID, "modelMat"), 1, GL_FALSE, glm::value_ptr(modelMat));
glUniformMatrix4fv(glGetUniformLocation(myShader->ID, "viewMat"), 1, GL_FALSE, glm::value_ptr(viewMat));
glUniformMatrix4fv(glGetUniformLocation(myShader->ID, "projMat"), 1, GL_FALSE, glm::value_ptr(projMat));

  7. 缩放[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-s6OkIMIc-1572488193100)(D:\Study\openGL学习\23.png)]

  8. 转换完要保存一个深度信息；–Z缓冲

    glEnable(GL_DEPTH_TEST);//开启深度缓冲，防止后画的画覆盖前面画的画；、
//while里面
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);//清颜色缓存+更新深度缓冲

  9. 画10个就for10次draw；

Camera:

  1. pitch 吐痰 yaw摇头 一般不会旋转摄像头

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kbp2jq9Y-1572488193101)(D:\Study\openGL学习\25.png)]

  2. 描述相机位置的四个参数

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sn79t8Yc-1572488193101)(D:\Study\openGL学习\26.png)]

  3. 通过摄像机获得ViewMatrix

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dOd2tEq4-1572488193102)(D:\Study\openGL学习\27.png)]

  4. 代码

    1. 添加Camera类

      class Camera
{
public:
	Camera(glm::vec3 position, glm::vec3 target, glm::vec3 worldup);
	~Camera();

	glm::vec3 Position;
	glm::vec3 Forward;
	glm::vec3 Right;
	glm::vec3 Up;
	glm::vec3 WorldUp;
	float Pitch;
	float Yaw;
    float SenseX = 0.01f; //灵敏度
	float SenseY = 0.01f;
    float speedZ = 0; //定义相机移动
	glm::mat4 GetViewMatrix();
    void ProcessMouseMovement(float deltaX, float deltaY);//更新坐标
  private:
	void UpdateCameraVectors();//更新相机
};
-----------------------------------------------------------------------
 //普通
    Camera::Camera(glm::vec3 position, glm::vec3 target, glm::vec3 worldup) {
	Position = position;
	WorldUp = worldup;
	Forward = glm::normalize(target - position);
	Right =glm::normalize(glm::cross(Forward, WorldUp));// 叉乘,并初始化为单位向量
	Up = glm::normalize(glm::cross(Forward, Right));
	
}
-----------------------------------------------------------------------
    Camera::Camera(glm::vec3 position, float pitch, float yaw, glm::vec3 worldup) {//欧拉角版本
	Position = position;
	WorldUp = worldup;
    Pitch = pitch;
	Yaw = yaw;
	Forward.x = glm::cos(pitch) * glm::sin(yaw);
	Forward.y = glm::sin(pitch);
	Forward.z = glm::cos(pitch) * glm::cos(yaw);
	Right = glm::normalize(glm::cross(Forward, WorldUp));// 叉乘,并初始化为单位向量
	Up = glm::normalize(glm::cross(Forward, Right));
}
------------------------------
glm::mat4 Camera::GetViewMatrix() {  //用lookat获得viewmatrix；
	return glm::lookAt(Position, Position + Forward, WorldUp);
}
void Camera::UpdateCameraVectors(){
	Forward.x = glm::cos(Pitch) * glm::sin(Yaw);
	Forward.y = glm::sin(Pitch);
	Forward.z = glm::cos(Pitch) * glm::cos(Yaw);
	Right = glm::normalize(glm::cross(Forward, WorldUp));// 叉乘,并初始化为单位向量
	Up = glm::normalize(glm::cross(Forward, Right));
}
void Camera::ProcessMouseMovement(float deltaX, float deltaY) {//用于更新坐标
	Pitch -= deltaY * SenseY;//*灵敏度

    Yaw -= deltaX * SenseX;
    UpdateCameraVectors();//更新参数；
    }

    
main中使用：

```c++
//宣告摄像头
Camera camera(glm::vec3(0, 0, 3.0f), glm::vec3(0, 0, 0), glm::vec3(0, 1.0f, 0));
viewMat = camera.GetViewMatrix();
----------------------------

//宣告欧拉摄像头 中间两个单位为度数
Camera camera(glm::vec3(0, 0, 3.0f), glm::radians(-44.0f), glm::radians(180.0f), glm::vec3(0, 1.0f, 0));
viewMat = camera.GetViewMatrix();


--------------



读取鼠标输入

```c++
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);//关掉鼠标显示

float lastX;//定义前一次的坐标；
float lastY;
bool firstMouse = true; //第一次运行
void mouse_callback(GLFWwindow* window, double xpos, double ypos) {
 if (firstMouse == true) {
 	lastX = xPos;
 	lastY = yPos;
 	firstMouse = false;
 }
 float deltaX, deltaY;
 deltaX = xpos - lastX;//差值
 deltaY = ypos - lastY;
 lastX = xpos;
 lastY = ypos;
 camera.ProcessMouseMovement(deltaX,deltaY);//更新坐标
}
glfwSetCursorPosCallback(window, mouse_callback);//注册回调函数

----------------------------------------------------------------
while 回圈：
viewMat = camera.GetViewMatrix();//动态更新相机

移动相机：

camera.h
float speedZ = 0; //相机移动；
void UpdateCameraPos();
-------------------------------------
camera.cpp
void Camera::UpdateCameraPos() {
	Position += Forward * speedZ * 0.001f;
}
----------------------------------
main.cpp
void processInput(GLFWwindow* window) {
	if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS) {
		glfwSetWindowShouldClose(window, true);
	}
	if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS) {
		camera.speedZ = 1.0f;
	}
	else if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS) {
		camera.speedZ = -1.0f;
	}
	else {
		camera.speedZ = 0;
	}
}

while 回圈：
viewMat = camera.GetViewMatrix();//动态更新相机


--------------------------------------------

移动相机：

```c++
camera.h
float speedZ = 0; //相机移动；
void UpdateCameraPos();
-------------------------------------
camera.cpp
void Camera::UpdateCameraPos() {
	Position += Forward * speedZ * 0.001f;
}
----------------------------------
main.cpp
void processInput(GLFWwindow* window) {
	if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS) {
		glfwSetWindowShouldClose(window, true);
	}
	if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS) {
		camera.speedZ = 1.0f;
	}
	else if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS) {
		camera.speedZ = -1.0f;
	}
	else {
		camera.speedZ = 0;
	}
}
逆风微笑的魔法师
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言项目实战：《球球大作战》零基础项目，185 行源代码示例
yx5666的博客
04-14 3205
这篇文章主要为大家详细介绍了C语言实现——《球球大作战项目》，文中示例代码介绍的非常详细，具有一定的参考价值,感兴趣的小伙伴们可以参考一下，在室友面前秀一下岂不是美滋滋 游戏介绍： 这是一个大球吃小球的世界，玩家的目标是要努力吃成最大的球球。在游戏一开始，玩家出现在地图上随机位置，地图里洒满了小彩豆，玩家吃掉小彩豆体积就会增大，当增大到比别人的球大时，就可以吃别人的球啦，当然也得躲避更大的球。小球速度快，大球速度慢。球球到达一定重量后，可以分身，一个球变成等大的两个球，可以再次分身，但是最多可以拥有
LearnOpenGL：Shader（下）写shader
Moreland0424的博客
04-14 1016
我们使用C++文件流（file stream）读取着色器内容，储存到几个string对象里 右键源文件 新建添加 新建项 选择C++类 名字改为Shader 这样之后，会出现Shader.h和Shader.cpp两个文件 在c++中 如果不宣告并定义的话 你将无法在main中使用这个函数 现在这个 .h*与 .cpp*的分页的意义是 把所有的宣告 全部都放入到.h*的文档里 .cpp*里只用写程式码不用考虑是否有宣告过 首先来看一下shader 的宣告 在h文件中，最开始会是这样，..
OpenGL学习笔记（二）-着色器-纹理
Catog的博客
03-26 1257
参考网址：LearnOpenGL 中文版 哔哩哔哩教程 第一章 入门 1.3 着色器 1.3.1 基本结构 利用着色器语言编写着色器，以顶点着色器和片段着色器为例，在着在顶点着色器中输出颜色变量vertexColor，在片段着色器中输入变量vertexColor作为图案的颜色。 #version 330 core layout (location = 0) in vec3 aPos; // 位置变量的属性位置值为0 out vec4 vertexColor; // 为片段着色器指定一个颜色输出 void m
openGL 入门——摄像机类+Shader类
ghhong1988的专栏
03-24 255
#pragma once #include <glm/glm.hpp> #include <glm/gtc/matrix_transform.hpp> class Cameral { public: Cameral(glm::vec3 position, glm::vec3 target, glm::vec3 worldup); Cameral(glm::ve...
OPENGL学习笔记之十四
Sean要加油
03-12 410
#OPENGL学习笔记之十三 2019/3/12 阅读材料来自learnopengl.com以及learnopengl-cn.github.io 这节的主要内容是增加光源的属性及相应的效果变化。 现实世界中有很多种类的光照，我们把将光投射(Cast)到物体的光源叫做投光物(Light Caster)。投光物我们分为以下三种： 定向光(Directional Light) 点光源(Point ...
OpenGL入门教程(精).pdf
01-27
OpenGL入门教程(精).pdfOpenGL入门教程(精).pdfOpenGL入门教程(精).pdfOpenGL入门教程(精).pdfOpenGL入门教程(精).pdfOpenGL入门教程(精).pdfOpenGL入门教程(精).pdfOpenGL入门教程(精).pdfOpenGL入门教程(精)....
opengl入门
06-06
OpenGL入门是针对初学者的一门课程，旨在引导学习者放弃旧的图形接口，例如TC中的`<graphics.h>`，转而使用更为先进和强大的OpenGL。OpenGL作为一种主流的图形应用程序接口(API)，具有诸多优势，比如： 1. **与...
openGL入门
12-12
OpenGL入门是计算机图形学领域一个重要的学习主题，它是一个跨语言、跨平台的编程接口，用于渲染2D、3D矢量图形。这份课件针对初学者，旨在提供全面的OpenGL基础知识，帮助新接触者快速掌握这个强大的图形库。下面...
OpenGL入门OSX版
06-30
本课程是OpenGL入门篇，主要是针对零基础人群，OpenGL系列课程的下一部为：OpenGL进阶。只有牢固的基础，才能提升到更高的层次 苹果端的一切OpenGL都会被苹果提示为：这些API都已经被遗弃了，请小心使用哦~。
OPENGL 作品 花儿
12-06
用OPENGL画的花儿，很有感觉，很不一样
OpenGL极速入门宝典.rar_opengl_opengl入门
09-19
本资源“OpenGL极速入门宝典”旨在为初学者提供一个快速掌握OpenGL基础知识的途径，帮助他们步入图形编程的世界。 OpenGL是一个跨语言、跨平台的编程接口，它的主要任务是管理图形硬件，如显卡，以便高效地绘制复杂...
OpenGL入门例子
01-22
OpenGL入门例子是一个针对初学者设计的教程集合，主要在Visual Studio 2010环境下进行。OpenGL是一个跨语言、跨平台的图形库，用于渲染2D、3D矢量图形，广泛应用于游戏开发、科学可视化、虚拟现实等领域。在这个教程...
opengl 入门代码C++
03-22
本教程的“OpenGL入门代码C++”旨在帮助初学者掌握OpenGL的基础知识，通过C++语言实现。在GitHub上可以找到更多的学习资源和社区支持。 一、OpenGL基础 OpenGL是一个跨语言、跨平台的应用程序编程接口（API），它...
OpenGL入门教程共95页.doc
最新发布
03-28
OpenGL入门教程共95页.doc OpenGL作为当前主流的图形API之一，它在一些场合具有比DirectX更优越的特性。 1、与C语言紧密结合。 OpenGL命令最初就是用C语言函数来进行描述的，对于学习过C语言的人来讲，OpenGL是容易...
OpenGL光照篇--多光源--14
weixin_41155760的博客
05-09 236
参考：多光源 整合多种光源类型在一个场景。 注：设置值的时候检查字符串和shader里的字符串是否对应。 如： cubeShader.setFloat("spotLight.outerCutoff", glm::cos(glm::radians(10.0f))); 多种光源需要在shader里计算所有类型的光照，叠加。 程序代码： //顺序不能错 #include <glad/glad.h> #include <GLFW/glfw3.h> #include <stb_im
OpenGL教程翻译 第九课 插值
Vcube的专栏
07-26 1246
OpenGL教程翻译 第九课 插值 原文地址：http://ogldev.atspace.co.uk/（源码请从原文主页下载） Background 本章讲述三维渲染管线中的一个非常重要的部分——插值，它是光栅器对从顶点着色器输出的变量所做的操作。正如你已经看到的，为了在屏幕上得到一些有意义的东西，你需要指定VS输出变量中的一个为“gl_Position”。这是一个四维向
linux clamp函数,OpenGL函数库，常用函数总结
weixin_29620579的博客
05-10 246
(一)库函数开发基于OpenGL的应用程序，必须先了解OpenGL的库函数。它采用C语言风格，提供大量的函数来进行图形的处理和显示。OpenGL图形库一共有100多个函数，它们分别属于OpenGL的基本库、实用库、辅助库等不同的库。1、核心库，包含的函数有115个，它们是最基本的函数，其前缀是gl；这部分函数用于常规的、核心的图形处理，由gl.dll来负责解释执行。核心库中的函数可以进一步分为以下...
OpenGL学习脚印:光源类型和使用多个光源(Light source and multiple lights)
热门推荐
王定桥的专栏
07-09 1万+
写在前面 上一节光照中使用材质和lighting maps介绍了使用材质属性和lighting maps使物体的光照效果能反映物体的材料特性，看起来更逼真。在前面的章节中使用的实际上都是一个点光源，本节将学习其他几种光源类型，以及在场景中使用多个光源。本节代码均可以在我的github下载。 本节内容整理自: 1.www.learnopengl.com light caste
OpenGL入门学习
10-21
对于那些对OpenGL感兴趣的初学者来说，《OpenGL入门学习》系列文章无疑是一篇非常好的学习资料。这个系列文章以通俗易懂的语言，详细介绍了OpenGL的基础知识和使用方法。通过这些文章，读者可以了解OpenGL的发展历程...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值