OpenGL---三角形（附带必要基础知识）

最新推荐文章于 2024-08-11 10:13:00 发布
最新推荐文章于 2024-08-11 10:13:00 发布
阅读量1.3k 收藏 6
点赞数
分类专栏： OpenGL 渲染 文章标签： OpenGL
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AvatarForTest/article/details/81149997
版权

！！！这篇文章的目的是教会你如何用OpenGL画一个三角形！！！

===========================================================================================

注：代码请看注释，重要的都写在注释里了。

基础知识：

一.渲染管线（我之前发表的文章）

     

二.顶点的顶点属性

  • 顶点位置（position）
  • 顶点UV坐标（UV1~UV7），一共有七组UV坐标可用
  • 顶点法线（normal）
  • 顶点切线（tangent）
  • 顶点颜色（color）
  • 等等。。。

三.OpenGL中VAO与VBO

  • 顶点数组对象：Vertex Array Object，VAO
  • 顶点缓冲对象：Vertex Buffer Object，VBO

       现在我们来解释一下顶点数组对象（VAO）和顶点缓冲对象（VBO）。

       首先解释VBO，顶点缓冲对象其实就是一块缓冲存储的引用。 可以用来开辟一块存储区间来存储顶点的各顶点属性数据。

       VAO，顶点数组对象其实是用来打包各个顶点属性的。

       比如说我有两组点，第一组点的每个点都有各自的顶点位置属性和颜色属性，第二组点的每个点都有各自的位置，顶点法线和顶点切线。如下图。当然这只是举个栗子VBO可以有多个。

   如图就是VAO和VBO的关系，VAO用于保存属性引用，VBO保存属性的具体数据。有了VAO的好处是，当渲染第一组VAO时，我突然需要渲染第二组VAO而不渲染第一组VAO时，只需解除第一组VAO的绑定，告诉OpenGL绑定第二组VAO。如果没有VAO我们需要分别解除第一组的位置和颜色然后将第二组的位置，法线和切线按需求从VBO获值然后渲染，很不方便。

 

 

===========================================================================================

OpenGL画三角形

          说明：用的是glfw和glad（glfw是用来创建窗口和监听键盘或者鼠标等事件的，glad和glew的作用差不多，都是获得函数接口引用，可以理解成glad是glew的升级版，这样我们就可以用OpenGL的API了），具体·请参考OpenGL配置。这里我们跳过配置。

第一步：初始化窗口

#include<glad\glad.h>
#include<GLFW\glfw3.h>
#include<iostream>
using namespace std;
int main()
{
	glfwInit();//初始化
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);//配置GLFW
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);//配置GLFW
	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);//使用OpenGL核心配置
	glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);

	GLFWwindow* window = glfwCreateWindow(800, 600, "OpenGL", nullptr, nullptr);//设置初始化的窗口长宽，显示名称，屏幕接口，第五个不知道干啥的


	if (window == nullptr)
	{
		cout << "Failed to create GLFW window" << endl;
		glfwTerminate();//terminate the glfw(end the glfw)
		return -1;
	}

	glfwMakeContextCurrent(window);//设置当前openGL上下文


	if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))//初始化GLAD
	{
		cout << "Failed to initialize GLAD" << endl;
		return -1;
	}

	while (!glfwWindowShouldClose(window))//渲染
	{

		glClearColor(0.27f, 0.27f, 0.27f, 1.0f);//覆盖颜色
		glClear(GL_COLOR_BUFFER_BIT);//覆盖

		glfwSwapBuffers(window);//双缓冲（替换窗口的每一个像素值）
	}
	glfwTerminate();
	return 0;

}

初始化一个窗口没啥，固定的。

 

第二步：顶点着色器（vertex shader），片元着色器（fragment shader）

  •           顶点着色器（vertex shader）
const GLchar* vertexShader_Code = 
"#version 330 core\n"//使用OpenGL3.3版本（支持可编程渲染管线版本）
"layout(location=0) in vec3 aPos;\n"//输入一个三元向量aPos（顶点位置数据），编号为0（这个数可以自己设，只要跟OpenGL中的传值得编号对应上就行，后面会讲）
"void main()\n"
"{\n"
"gl_Position=vec4(aPos.x,aPos.y,aPos.z,1.0);\n"//变成四元，这样做的目的是方便做变换，比如齐次矩阵乘法变换
"}";

 

  • 片元着色器（fragment shader）
const GLchar* fragmentShader_Code = 
"#version 330 core\n"
"out vec4 FragColor;\n"//以一个颜色值作为输出（像素的颜色）
"void main()\n"
"{\n"
"FragColor=vec4(1.0f, 0.5f, 0.2f, 1.0f);\n"//返回颜色，个分量的值取值范围[0,1]，和[0,255]一回事，就是映射范围不一样
"}";

第三步：编译着色器

//data
	int isSuccess;
	char infoLog[512];

	


	//vertexShader data
	unsigned int vertexShader;//声明一个顶点着色器的引用
	vertexShader = glCreateShader(GL_VERTEX_SHADER);//将引用指向一个顶点着色器（相当于面向对象中 new VertexShader（））
	glShaderSource(vertexShader, 1,&vertexShader_Code, NULL);//加载之前写的顶点着色器
	glCompileShader(vertexShader);//编译

	/*编译是否通过*/
	glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &isSuccess);
	if (!isSuccess)
	{
		glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);
		cout << "ERROR::VertexShader::Compile_failed" << infoLog << endl;
	}
	else
	{
		cout << "SUCCESS::VertexShader" << endl;
	}


/*片元着色器编译原理同上*/
	//fragmentShader Data
	unsigned int fragmentShader;
	fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
	glShaderSource(fragmentShader, 1, &fragmentShader_Code, NULL);
	glCompileShader(fragmentShader);
	/*编译是否通过*/
	glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &isSuccess);
	if (!isSuccess)
	{
		glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);
		cout << "ERROR::FragmentShader::Compile_failed" << infoLog << endl;
	}
	else
	{
		cout << "SUCCESS::FragmentShader" << endl;
	}

 

第四步：组装渲染管线

//Shader Pragram
	unsigned int shaderProgram;//声明一个管线的引用（理解成着色器的系统也没问题）
	shaderProgram = glCreateProgram();//引用指向一个管线（相当于面向对象中 new shaderProgram（））
	glAttachShader(shaderProgram, vertexShader);//组装顶点着色器
	glAttachShader(shaderProgram, fragmentShader);//组装片元着色器
	glLinkProgram(shaderProgram);//链接各个着色器成渲染管线

/*链接是否成功*/
	glGetProgramiv(shaderProgram, GL_LINK_STATUS, &isSuccess);
	if (!isSuccess)
	{
		glGetShaderInfoLog(shaderProgram, 512, NULL, infoLog);
		cout << "ERROR::ShaderProgram::Link_failed" << infoLog << endl;
	}
	else
	{
		cout << "SUCCESS::ShaderProgram" << endl;
		glUseProgram(shaderProgram);//使用当前的管线渲染
		glDeleteShader(vertexShader);//着色器已经加载到显卡得内存中了，cpu管理的内存中的着色器没用了，删除
		glDeleteShader(fragmentShader);着色器已经加载到显卡得内存中了，cpu管理的内存中的着色器没用了，删除
	}

 

第五步：给顶点着色器赋初值

      1.首先是三角形的三个顶点:

//三角顶点
	float vertices[] = 
	{
		-0.5f,-0.5f,0.0f,//左下角
		 0.5f,-0.5f,0.0f,//右下角
		 0.0f, 0.5f,0.0f//顶端角
	};

注意这里的所有顶点分量都是[-1,1]，这是归一化坐标，这是应为我们只是写了个最简单的画三角形的方法，跳过了物体空间坐标到世界空间坐标到视觉空间坐标到裁剪空间坐标，直接给归一化坐标空间的坐标。具体请参考渲染管线。

      2.赋值

首先先解释什么是绑定？

OpenGL中的绑定类似于将当前对象绑定后，之后的所有相关的命令都将作用于此对象。这和常见的面向对象有点区变。

就像一块画板，你绑一张画纸在上面，然后画画。画完了，将画纸解绑拿下来，原先画上的数据保留在了纸上。之后再画别的，再拿一张画纸。

//vectices data
	unsigned int VAO;//声明一个VAO对象
	unsigned int VBO;//声明一个VBO对象

	glGenVertexArrays(1, &VAO);//获得一个顶点数组对象
        glGenBuffers(1, &VBO);//获得一个顶点缓冲对象
	glBindVertexArray(VAO);//绑定一个顶点数组对象
	glBindBuffer(GL_ARRAY_BUFFER, VBO);//绑定缓冲对象
	glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);//将之前定义的所有顶点数据装进缓冲中
	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);//！！！注意！！！给vertexshader赋初值。
	glEnableVertexAttribArray(0);//激活此编号数据

	glBindBuffer(GL_ARRAY_BUFFER,0);//解除VBO绑定
	glBindVertexArray(0);//解除VAO绑定

注意！！！这行代码！！！

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

还记得顶点着色器中那个layout吗？

layout(location=0) in vec3 aPos;

glVertexAttribPointer()

  • 第一个参数指定我们要配置的顶点属性。还记得我们在顶点着色器中使用layout(location = 0)定义了顶点的位置值吗？它可以把顶点属性的位置值设置为0。因为我们希望把数据传递到这一个顶点属性中，所以这里我们传入0。
  • 第二个参数指定顶点属性的大小。顶点属性是一个vec3，它由3个值组成，所以大小是3。
  • 第三个参数指定数据的类型，这里是GL_FLOAT(GLSL中vec*都是由浮点数值组成的)。
  • 下个参数定义我们是否希望数据被标准化(Normalize)。如果我们设置为GL_TRUE，所有数据都会被映射到0（对于有符号型signed数据是-1）到1之间。我们把它设置为GL_FALSE。
  • 第五个参数叫做步长(Stride)，它告诉我们在连续的顶点属性组之间的间隔。由于下个组位置数据在3个float之后，我们把步长设置为3 * sizeof(float)。要注意的是由于我们知道这个数组是紧密排列的（在两个顶点属性之间没有空隙）我们也可以设置为0来让OpenGL决定具体步长是多少（只有当数值是紧密排列时才可用）。一旦我们有更多的顶点属性，我们就必须更小心地定义每个顶点属性之间的间隔，我们在后面会看到更多的例子（译注: 这个参数的意思简单说就是从这个属性第二次出现的地方到整个数组0位置之间有多少字节）。
  • 最后一个参数的类型是void*，所以需要我们进行这个奇怪的强制类型转换。它表示位置数据在缓冲中起始位置的偏移量(Offset)。由于位置数据在数组的开头，所以这里是0。

 

第六步：渲染

while (!glfwWindowShouldClose(window))
		{
			glfwPollEvents();//检查有没有触发事件

			glClearColor(0.27f, 0.27f, 0.27f, 1.0f);//覆盖颜色
			glClear(GL_COLOR_BUFFER_BIT);//覆盖


			glUseProgram(shaderProgram);//使用我们之前组装的渲染管线
			glBindVertexArray(VAO);//绑定我们的VAO（就像将之前画完的画重新绑在画板上，给别人看或使用）

			glDrawArrays(GL_TRIANGLES, 0, 3);//以三角模式（面覆盖），画三角形，从第0个开始，画三角形的三个点


			glfwSwapBuffers(window);//双缓冲（替换窗口的每一个像素值）
		}

除了GL_TRIANGLES外还有GL_POINTS和GL_LINE_STRIP。

  • GL_POINT，点模式绘制，请加入下面的语句，要不然太小基本看不清，想要练眼神的小伙伴请忽略！！！。
  • glPointSize(10.0f);//设置点大小

    GL_LINE_STRIP，线模式绘制，请加入下面的语句，要不然太细基本看不清，想要练眼神的小伙伴请忽略！！！

  • glLineWidth(10.0f);//设置线宽

     

最后：别忘了结束后关闭窗口

glfwTerminate();
return 0;

 

===========================================================================================

全部代码：

#include<glad\glad.h>
#include<GLFW\glfw3.h>
#include<iostream>
using namespace std;

static void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
{
	if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS)
	{
		glfwSetWindowShouldClose(window, GL_TRUE);
	}

}

//vertex shader
const GLchar* vertexShader_Code =
"#version 330 core\n"
"layout(location=0) in vec3 aPos;\n"
"void main()\n"
"{\n"
"gl_Position=vec4(aPos.x,aPos.y,aPos.z,1.0);\n"
"}";


const GLchar* fragmentShader_Code =
"#version 330 core\n"
"out vec4 FragColor;\n"
"void main()\n"
"{\n"
"FragColor=vec4(1.0f, 0.5f, 0.2f, 1.0f);\n"
"}";

int main()
{
	//三角顶点
	float vertices[] =
	{
		-0.5f,-0.5f,0.0f,//左下角
		0.5f,-0.5f,0.0f,//右下角
		0.0f, 0.5f,0.0f//顶端角
	};
	glfwInit();//初始化
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);//配置GLFW
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);//配置GLFW
	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);//
	glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);

	GLFWwindow* window = glfwCreateWindow(800, 600, "OpenGL", nullptr, nullptr);
	glfwSetKeyCallback(window, key_callback);


	if (window == nullptr)
	{
		cout << "Failed to create GLFW window" << endl;
		glfwTerminate();//terminate the glfw(end the glfw)
		return -1;
	}

	glfwMakeContextCurrent(window);//设置当前openGL上下文


	if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
	{
		cout << "Failed to initialize GLAD" << endl;
		return -1;
	}

	//data
	int isSuccess;
	char infoLog[512];




	//vertexShader data
	unsigned int vertexShader;
	vertexShader = glCreateShader(GL_VERTEX_SHADER);
	glShaderSource(vertexShader, 1, &vertexShader_Code, NULL);
	glCompileShader(vertexShader);
	/*编译是否通过*/
	glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &isSuccess);
	if (!isSuccess)
	{
		glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);
		cout << "ERROR::VertexShader::Compile_failed" << infoLog << endl;
	}
	else
	{
		cout << "SUCCESS::VertexShader" << endl;
	}

	//fragmentShader Data
	unsigned int fragmentShader;
	fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
	glShaderSource(fragmentShader, 1, &fragmentShader_Code, NULL);
	glCompileShader(fragmentShader);
	/*编译是否通过*/
	glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &isSuccess);
	if (!isSuccess)
	{
		glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);
		cout << "ERROR::FragmentShader::Compile_failed" << infoLog << endl;
	}
	else
	{
		cout << "SUCCESS::FragmentShader" << endl;
	}

	//Shader Pragram
	unsigned int shaderProgram;
	shaderProgram = glCreateProgram();
	glAttachShader(shaderProgram, vertexShader);
	glAttachShader(shaderProgram, fragmentShader);
	glLinkProgram(shaderProgram);

	glGetProgramiv(shaderProgram, GL_LINK_STATUS, &isSuccess);
	if (!isSuccess)
	{
		glGetShaderInfoLog(shaderProgram, 512, NULL, infoLog);
		cout << "ERROR::ShaderProgram::Link_failed" << infoLog << endl;
	}
	else
	{
		cout << "SUCCESS::ShaderProgram" << endl;
		glUseProgram(shaderProgram);
		glDeleteShader(vertexShader);
		glDeleteShader(fragmentShader);
	}

	//vectices data
	unsigned int VAO;
	unsigned int VBO;

	glGenVertexArrays(1, &VAO);//获得一个顶点数组对象
	glBindVertexArray(VAO);
	glGenBuffers(1, &VBO);
	glBindBuffer(GL_ARRAY_BUFFER, VBO);
	glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
	glEnableVertexAttribArray(0);

	glBindBuffer(GL_ARRAY_BUFFER, 0);
	glBindVertexArray(0);

	while (!glfwWindowShouldClose(window))
	{
		glfwPollEvents();//检查有没有触发事件

		glClearColor(0.27f, 0.27f, 0.27f, 1.0f);
		glClear(GL_COLOR_BUFFER_BIT);

		glUseProgram(shaderProgram);
		glBindVertexArray(VAO);

		glDrawArrays(GL_TRIANGLES, 0, 3);


		glfwSwapBuffers(window);//双缓冲（替换窗口的每一个像素值）
	}
	glfwTerminate();
	return 0;

}

 

运行结果：

结果

 

 

至此，三角形就画在了屏幕上！！！可喜可贺！！！祝小伙伴们学习愉快！！！

 

 

 

 

 

 

 

 

 

FuXiii
关注
专栏目录
OpenGL开发-第2章-绘制三角形
weixin_58040686的博客
08-17 702
1. 现实中我们如何精确的绘制一个有颜色的三角形？ 1.1 确定三个顶点的位置 1.2.连接三个顶点，成三角形状 1.3.涂上颜色 通过以上三步，我们可以轻松的绘制一个三角形。那么在OpenGL中如何做呢？ 2. OpenGL的工作流程 首先看一张图： 这也可以称为简洁版的OpenGL的渲染管线(Graphics PipeLine)，但也完全可以说明问题。 从图中可以看出，OpenGL的也是接受顶点，组成形状，染上颜色，最终输出到屏幕上。 从头开始看： 2.1 顶点数据 ，这部分由我们的代码(通常
如何判断一点在三角形内
weixin_30902251的博客
07-31 899
假定在右手坐标系中的三角形3点坐标为A，B，C，判断P是否在ABC之内 ( 主要来自 3D引擎研发QQ群（38224573 ）的各位朋友的讨论 ，我仅仅算做个总结吧，特别感谢各位朋友的热情支持。 ） 方法1：三个Perplane的方法 设AB，BC，AC边上的垂直平面为Perplane[3]，垂直朝向内侧的法向为n[3] 1）先根...
OpenGL入门一：基础知识及概念
最新发布
轻口味的专栏
08-11 1024
OpenGL：open graphic library，即开发图形库。它被定义为“图形硬件的一种软件接口”。实质上是3D图形和模型库，它具有高度可移植性，并且具有非常快的速度。可以创建优雅漂亮的3D图形，具有出色的视觉质量。并且速度远快于光线追踪仪或软件渲染引擎。本文介绍了OpenGL相关的知识：OpenGL历史、OpenGL发展、OpenGL应用等，并且介绍了OpenGL需要掌握的知识，OpenGL变换原理及投影成像原理。
OpenGL（二）第一个OpenGL程序绘制三角形
小飞飞的博客
12-02 5359
一、代码 #include #include #include GLBatch batch; //批处理 GLShaderManager shaderManager; //着色器管理 void ChangeSize(int width, int height) { glViewport(0, 0, width, height); //改变窗口大小 } void SetupRc(v
OpenGL学习（三）第一个三角形
zhouyelihua
07-02 1520
前言学习opencv英文网址：https://learnopengl.com/#!Getting-started/Hello-Triangle中文翻译：https://learnopengl-cn.github.io/01%20Getting%20started/04%20Hello%20Triangle/相关代码：https://github.com/JoeyDeVries/LearnOpenGL
opengl三角面片构成
02-27
通过离散的点构建三角面片，并实现贴图功能
OpenGL--基础知识（1）
用01改变世界
05-17 321
1.基础渲染管线 在OpenGL中，最基础的元素就是点，一些点组合在一起，按照预定的方式连线，另外加上光照、贴图、颜色等就组成了我们在屏幕上所看到的图形图像。例如，一个顶点的基础就是一个点，只是这个顶点包含位置、颜色等属性；一个三角形的基础就是三个点，按照预定的方式进行连线。我们来看一个大致的渲染流程图(摘自OpenGL SuperBible)： 这是一个简化版本，我们可以看到，渲染管线把三个顶...
OpenGL超级宝典（第7版）笔记22 原子计数器 清单5.31-5.34
qq_44016525的博客
06-04 632
OpenGL超级宝典（第7版）笔记22 原子计数器 清单5.31-5.34 文章目录OpenGL超级宝典（第7版）笔记22 原子计数器 清单5.31-5.34前言1 原子计数器初介绍1.1 原子计数器的声明1.2 原子计数器准备缓冲1.3 使用原子计数器计数3 总结 前言 上一篇我们介绍了着色器存储区块的相关内容（包括了和uniform块的对比），还介绍了原子内存操作和屏障的实用问题。这一篇我们将介绍原子计数器，我们将通过它来进行计数，并通过它计算图形的面积。 1 原子计数器初介绍 原子计数器是一种特殊
visualize-object-model-3d 开线程显示3D点云
01-09
在IT领域，尤其是在计算机图形学和可视化技术中，"visualize-object-model-3d 开线程显示3D点云"这个主题涉及到多个重要的知识点。3D点云是一种数据结构，它由大量的三维坐标点组成，通常用于表示物体或场景的表面。...
OpenGL安装包
02-27
10. **学习资源**：安装包可能附带一些教程和文档，帮助初学者了解OpenGL的基础知识和编程模式。在线资源，如OpenGL官方文档、Stack Overflow和各种教程网站，也是学习和解决问题的重要渠道。 总的来说，OpenGL...
opengl从画三角形到画一个立方体（二）
小孔明的专栏
10-12 2760
前一节内容，如果读者能够坚持看到最后，并且能够将立方体画出来，我相信还是有一点点的成就感的，毕竟我们从点、到三角形、再到立方体、再到立方体的旋转一步一步的走，而且学会了VBO、VAO、EBO的数据传输、shader的使用等等最最基本的知识，这一步好艰难，但是毕竟走过来了。 那么下面我们将继续征途，本小节的内容，相对短一点，而且很容易明白。 本小节的主要内容，就是为前一小节的立方体，贴上一张图，使
OpenGL中设置顶点属性（Vertex Attribute）
klscer的博客
02-25 2305
我们首先明确一点，顶点（Vertex）不单单指位置，它还包含纹理位置，法线等属性。顶点的位置坐标仅仅是顶点的一个属性。 在中OpenGL中的顶点缓冲区(Vertex Buffer)我们已经探究了如何利用顶点缓冲区向GPU传递数据用来绘制图形，但GPU并不知道这些数据代表什么，如何利用这些数据。它只知道这些是数据，因此我们需要设置顶点属性，告诉GPU “嗨，这一部分数据代表顶点的位置信息，那一块数据是纹理坐标...”。而OpenGL给我们提供了具有这样功能的API——glVertexAttribPointe
LearnOpenGL学习笔记——OpenGL绘制三角形
VIPCCJ的博客
09-03 530
绘制三角形 绘制三角形之前：需要理解一下几件事情 1.顶点输入 顶点数组对象：Vertex Array Object，VAO 顶点缓冲对象：Vertex Buffer Object，VBO 索引缓冲对象：Element Buffer Object，EBO或Index Buffer Object，IBO 为什么使用VAO和VBO. 请看以下代码，opengl渲染一堆数据的时候，我们使用一个顶点缓冲对象将顶点数据初始化至缓冲中，建立了一个顶点和一个片段着色器，并告诉了OpenGL如何把顶点数据链接到顶点着色器的
使用opengl 绘制镂空三角形
yang_205的博客
03-22 1987
使用opengl绘制镂空三角形 绘制镂空三角形 代码实现： #include <GL/glut.h> GLfloat v[3][2] = { {0.0,0.0}, {2.0,0.0}, {1.0, 1.7} }; int n; void triangle(GLfloat *a, GLfloat *b, GLfloat *c) { glColor3f(1.0, 0.0, 0.0); gl...
【OpenGL】理解VAO、VBO、EBO和 shader中vertex、fragment交互。
qq_18718337的博客
07-04 758
总结一下【OpenGL】理解VAO、VBO、EBO和 shader中vertex、fragment交互
小白入门opengl（二）画出三角形
shine10076的博客
09-19 7193
在opengl中任何事物都在3D空间中，而屏幕与窗口确实2D的，由3D坐标转化为2D的处理过程是opengl的图形渲染管线管理的。可以被划分为两个主要部分，第一部分把你的3D坐标转化为2D坐标，第二部分则是把2D坐标转化为有颜色的像素。 在图形渲染管线上运行各自的小程序，从而图形渲染管线鲁艾苏处理你的数据，这样的小程序叫做着色器。 有些着色器允许开发者自己配置，可以让我们更加细致的...
OpenGL学习（五）坐标
仰望星空
02-15 260
中文OpenGL学习网站：https://learnopengl-cn.github.io 一、局部空间-（模型矩阵）-世界空间-（观察矩阵）-观察空间-（投影矩阵）-裁剪空间 1.1代码 #include <glad/glad.h> #include <GLFW/glfw3.h> #include <glm/glm.hpp> #include <...
openGL 第四篇：绘制一个三角形（使用顶点数组对象 绘制）
z1067832450_的专栏
01-18 675
重要知识点： 1，顶点数组对象：VAO 2，顶点缓冲对象 总结： 使用顶点数据初始化 顶点缓冲对象，然后 顶点数组对象通过 顶点缓冲对象 获取 顶点数据（通过位置layout (location = 0)），把数据存放在 顶点数组对象的好处是 当配置好了顶点属性指针的时候，你只需要使用VAO即可 不需要再次去配置 顶点属性指针 /** 1，顶点数组对象： VAO 2，顶点缓冲对象：CBO 3，索引缓冲对象：EBO 图形渲染管线：就是把数据 流程： 1，顶点着色器：接受一组3D数据，..
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值