OpenGL中的VBO与VAO的使用

最新推荐文章于 2024-04-01 13:26:11 发布
最新推荐文章于 2024-04-01 13:26:11 发布
阅读量4.3k 收藏 4
点赞数 2
分类专栏： OpenGL 文章标签： opengl vao vbo
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013706695/article/details/40076973
版权

此代码来自《OpenGL编程指南》，最近所写程序中需要使用到VBO与VAO，故将其在自己的机器上跑起来，并对此做了注释，方便日后查看


vbo.cpp

#include <stdlib.h>
#include <GL/glew.h>
#include <GL/glut.h>

#pragma comment( lib, "glew32.lib") 

// 使用此宏来简化偏移量的表达形式
#define BUFFER_OFFSET(bytes) ((GLubyte*) NULL + (bytes))
#define VERTICES 0
#define INDICES 1
#define NUM_BUFFERS 2
GLuint buffers[NUM_BUFFERS];

GLfloat vertices[][3] = {
	{-1.0f,-1.0f,-1.0f},
	{1.0f,-1.0f,-1.0f},
	{1.0f,1.0f,-1.0f},
	{-1.0f,1.0f,-1.0f},
	{-1.0f,-1.0f,1.0f},
	{1.0f,-1.0f,1.0f},
	{1.0f,1.0f,1.0f},
	{-1.0f,1.0f,1.0f}
};
GLubyte indices[][4] = {
	{0,1,2,3},
	{4,7,6,5},
	{0,4,5,1},
	{3,2,6,7},
	{0,3,7,4},
	{1,5,6,2}
};

GLfloat* bdata;

void changeSize(int w, int h)
{
	glViewport(0,0,(GLsizei)w,(GLsizei)h);
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluPerspective(45.0,(double)w/(double)h,0.01,30);
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
}

void keyDown(unsigned char key, int x, int y)
{
	switch (key)
	{
	case 'b':
		// 返回一个缓冲区对象的指针（指向与GL_ARRAY_BUFFER相关联的当前绑定缓冲区对象的数据存储），可以在这个缓冲区对象中写入新值，就像对数组赋值一样
		// GL_READ_WRITE 表示可以对数据进行读写操作
		bdata = (GLfloat*)glMapBuffer(GL_ARRAY_BUFFER, GL_READ_WRITE);
		for (int i = 0; i < 24; i++)
		{
			*(bdata + i) *=1.1f;
		}
		glUnmapBuffer(GL_ARRAY_BUFFER);
		glutPostRedisplay();
		break;
	case 's':
		bdata = (GLfloat*)glMapBuffer(GL_ARRAY_BUFFER, GL_READ_WRITE);
		for (int i = 0; i < 24; i++)
		{
			*(bdata + i) *= 0.9f;
		}
		glUnmapBuffer(GL_ARRAY_BUFFER);
		glutPostRedisplay();
		break;
	}
}

void mouse(int button, int state, int x, int y)
{

}

void display(void)
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glLoadIdentity();
	glTranslatef(0.0f, 0.0f, -5.0f);
	glRotatef(45.0f, 1.0f, 1.0f, 0.0f);

	// GL_QUADS 创建图元的类型
	// 24 使用24个元素定义一个几何图元序列
	// GL_UNSIGNED_BYTE 数组数据类型
	// BUFFER_OFFSET(0) 偏移量
	glDrawElements(GL_QUADS, 24, GL_UNSIGNED_BYTE, BUFFER_OFFSET(0));

	glutSwapBuffers();
}

void init(void)
{
	glClearColor(0.0f,0.0f,0.0f,0.0f);
	glShadeModel(GL_FLAT);
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glewInit();
	// 创建2个缓冲区对象
	glGenBuffers(NUM_BUFFERS, buffers);
	glBindBuffer(GL_ARRAY_BUFFER, buffers[VERTICES]);
	// GL_ARRAY_BUFFER 表示顶点数据
	// sizeof(vertices) 表示存储相关数据所需要的内存数量
	// vertices 指向数据所存储的内存的指针，用于初始化缓冲区对象
	// GL_DYNAMIC_DRAW 提示数据在分配之后将如何进行读取和写入
	glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_DYNAMIC_DRAW);
	// 指定了需要访问的空间坐标数据
	// 3 表示每个顶点的坐标数量
	// GL_FLOAT 指定数组中每个坐标的数据类型
	// 0 跨距
	// BUFFER_OFFSET(0) 是数组包含的第一个顶点的第一个坐标的内存地址
	glVertexPointer(3, GL_FLOAT, 0, BUFFER_OFFSET(0));
	// 启用数组
	glEnableClientState(GL_VERTEX_ARRAY);

	// GL_ELEMENT_ARRAY_BUFFER（表示索引数据），用索引数据初始化缓冲区对象
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffers[INDICES]);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
}

int main(int argc, char* argv[])
{
	glutInit(&argc, argv);
	glutInitDisplayMode(GL_DOUBLE | GLUT_RGBA | GLUT_DEPTH);
	glutInitWindowSize(600, 600);
	glutCreateWindow("VBO");
	glutReshapeFunc(changeSize);
	glutMouseFunc(mouse);
	glutKeyboardFunc(keyDown);
	glutDisplayFunc(display);
	init();
	glutMainLoop();
	return 0;
}

以下运行结果分别为未缩放，放大，缩小之后的截图




vao.cpp

#include <windows.h>
#include <GL/glew.h>
#include <GL/glut.h>
#include <math.h>
#include <iostream>

#include <stdio.h>

#pragma comment (lib, "glew32.lib")

using namespace std;

#define M_PI 3.1415926f

// 使用此宏来简化偏移量的表达形式
#define BUFFER_OFFSET(offset)  ((GLvoid*)offset)
#define NumberOf(array)        (sizeof(array)/sizeof(array[0])) //求数组大小

typedef struct {
	GLfloat x, y, z;
} vec3;


typedef struct {
	vec3     xlate;   //glTranslatef参数
	GLfloat  angle;
	vec3     axis;	  //glRotatef参数
} xform;

enum { Cube, Cone, NumVAOs };   //{0, 1, 2}
GLuint   VAO[NumVAOs];          //顶点数组对象
GLenum   primType[NumVAOs];     //图元类型
GLsizei  numElements[NumVAOs];	//索引数据
xform    xForm[NumVAOs] = {
	{ { -3.0, 0.0, 0.0 }, 45.0, { 1.0, 1.0, 1.0 } },
	{ {  0.0, 0.0, 3.0 }, 0.0, { 1.0, 1.0, 1.0 } }
};
GLfloat  Angle = 0.0;

void init()
{
	//初始化glew
	GLenum err = glewInit();
	if (GLEW_OK != err)
	{
		fprintf(stderr, "GLEW初始化失败！\n");
		exit(EXIT_FAILURE);
	}
	enum { vertices, colors, elements, NumVBOs };   //{0, 1, 2, 3}
	//缓冲区对象,包含顶点坐标，顶点颜色，顶点索引
	GLuint  buffers[NumVBOs];
	//生成顶点数组对象，本代码中只画了两个图形
	glGenVertexArrays(NumVAOs, VAO);

	{
		//顶点坐标
		GLfloat  cubeVerts[][3] = {
			{ -1.0, -1.0, -1.0 },
			{ -1.0, -1.0,  1.0 },
			{ -1.0,  1.0, -1.0 },
			{ -1.0,  1.0,  1.0 },
			{  1.0, -1.0, -1.0 },
			{  1.0, -1.0,  1.0 },
			{  1.0,  1.0, -1.0 },
			{  1.0,  1.0,  1.0 }
		};
		//顶点颜色
		GLfloat  cubeColors[][3] = {
			{  0.0,  0.0,  0.0 },
			{  0.0,  0.0,  1.0 },
			{  0.0,  1.0,  0.0 },
			{  0.0,  1.0,  1.0 },
			{  1.0,  0.0,  0.0 },
			{  1.0,  0.0,  1.0 },
			{  1.0,  1.0,  0.0 },
			{  1.0,  1.0,  1.0 }
		};
		//顶点索引
		GLubyte  cubeIndices[] = {
			0, 1, 3, 2,
			4, 6, 7, 5,
			2, 3, 7, 6,
			0, 4, 5, 1,
			0, 2, 6, 4,
			1, 5, 7, 3
		};

		//绑定激活第一个顶点数组对象
		glBindVertexArray(VAO[Cube]);
		//修改缓冲对象里的数据
		glGenBuffers(NumVBOs, buffers);
		glBindBuffer(GL_ARRAY_BUFFER, buffers[vertices]);
		glBufferData(GL_ARRAY_BUFFER, sizeof(cubeVerts), cubeVerts, GL_STATIC_DRAW);
		glVertexPointer(3, GL_FLOAT, 0, BUFFER_OFFSET(0));
		glEnableClientState(GL_VERTEX_ARRAY);

		glBindBuffer(GL_ARRAY_BUFFER, buffers[colors]);
		glBufferData(GL_ARRAY_BUFFER, sizeof(cubeColors), cubeColors, GL_STATIC_DRAW);
		glColorPointer(3, GL_FLOAT, 0, BUFFER_OFFSET(0));
		glEnableClientState(GL_COLOR_ARRAY);

		// GL_ELEMENT_ARRAY_BUFFER（表示索引数据），用索引数据初始化缓冲区对象
		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffers[elements]);
		glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(cubeIndices), cubeIndices, GL_STATIC_DRAW);

		primType[Cube] = GL_QUADS;      //图元类型，4个点画一个矩形
		numElements[Cube] = NumberOf(cubeIndices);
	}

	{
		int i, index;
		float  dTheta;

#define NumConePoints  36   //圆锥底面有36个点

		//增加一个顶点作为圆锥的尖端顶点（作为第一个顶点）
		GLfloat  coneVerts[NumConePoints+1][3] = {
			{0.0, 0.0, 10.0}     //相当于给数组赋了第一个顶点
		};
		GLfloat  coneColors[NumConePoints+1][3] = {
			{1.0, 1.0, 1.0}     //第一个顶点的颜色
		};
		GLubyte  coneIndices[NumConePoints+1];  //默认初始化0,即索引到第一个顶点

		dTheta = 2*M_PI / (NumConePoints - 1);  //所要绘制的三角形的夹角
		index = 1;
		for (i = 0; i < NumConePoints; ++i, ++index)
		{
			//这里的顶点坐标很好分析，画一个顶点在坐标原点的圆，36个顶点分别在圆上
			float theta = i*dTheta;
			coneVerts[index][0] = cos(theta);
			coneVerts[index][1] = sin(theta);
			coneVerts[index][2] = 0.0;

			coneColors[index][0] = cos(theta);
			coneColors[index][1] = sin(theta);
			coneColors[index][2] = 0.0;

			coneIndices[index] = index;

			cout << "( " << coneVerts[index][0] << ", " << coneVerts[index][1] << ")" << endl;
		}
		//激活绑定第二个顶点数组对象
		glBindVertexArray(VAO[Cone]);
		glGenBuffers(NumVBOs, buffers);
		glBindBuffer(GL_ARRAY_BUFFER, buffers[vertices]);
		glBufferData(GL_ARRAY_BUFFER, sizeof(coneVerts), coneVerts, GL_STATIC_DRAW);
		glVertexPointer(3, GL_FLOAT, 0, BUFFER_OFFSET(0));
		glEnableClientState(GL_VERTEX_ARRAY);

		glBindBuffer(GL_ARRAY_BUFFER, buffers[colors]);
		glBufferData(GL_ARRAY_BUFFER, sizeof(coneColors), coneColors, GL_STATIC_DRAW);
		glColorPointer(3, GL_FLOAT, 0, BUFFER_OFFSET(0));
		glEnableClientState(GL_COLOR_ARRAY);

		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffers[elements]);
		glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(coneIndices), coneIndices, GL_STATIC_DRAW);

		primType[Cone] = GL_TRIANGLE_FAN;       //以圆锥顶点为公共顶点画三角形
		numElements[Cone] = NumberOf(coneIndices);
	}

	glEnable(GL_DEPTH_TEST);
}

void display()
{
	int  i;

	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glColor3f(1.0, 0.0, 0.0);
	glPushMatrix();
	glRotatef(Angle, 0.0, 1.0, 0.0);    //初始旋转角度以及旋转轴
	gluLookAt(0.0, 0.0, 10.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);    //设置相机

	for (i = 0; i < NumVAOs; ++i) {
		glPushMatrix();
		glTranslatef(xForm[i].xlate.x, xForm[i].xlate.y, xForm[i].xlate.z);
		glRotatef(xForm[i].angle, xForm[i].axis.x, xForm[i].axis.y, xForm[i].axis.z);
		glBindVertexArray(VAO[i]);  //对相应的数组对象解引用
		glDrawElements(primType[i], numElements[i], GL_UNSIGNED_BYTE, BUFFER_OFFSET(0));
		glPopMatrix();
	}

	glPopMatrix();
	glutSwapBuffers();
}

void reshape(GLsizei w, GLsizei h)
{
	if(h == 0)
		h = 1;

	glViewport(0, 0, w, h);

	GLfloat fAspect = (GLfloat)w / (GLfloat)h;

	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();//将当前的用户坐标系的原点移动到了屏幕中心，类似一个复位操作

	gluPerspective(45.0f, fAspect, 1.0f, 100.0f);

	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();

}

int main(int args, char* argv[])
{
	glutInit(&args, argv);
	glutInitWindowPosition(200, 200);
	glutInitWindowSize(600, 600);
	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
	//glewInit();//此初始化函数在init()函数中进行了调用
	glutCreateWindow("VAO");
	glutDisplayFunc(display);
	glutReshapeFunc(reshape);
	init();
	glutMainLoop();

	return 0;
}



以下为程序的运行结果：



那张旧唱片的旋律
关注
专栏目录
【Opengl概念01】VBO和VAO到底是个啥关系？
gongdiwudu的专栏
03-15 2149
对于Opengl中的VBO和VAO相信很多人都熟悉这2个名字，但是有时候缺容易混淆2个概念或者说不理解这2个概念的作用是什么。本文对这2个概念做了对比和参照。
OpenGL使用VBO+VAO绘制三角形
m0_60352504的博客
07-20 212
使用glew库和freeglut库。
采用VBO技术的真正的多线程多窗口OpenGL程序
01-13
采用VBO技术的真正的多线程多窗口OpenGL程序 vs2008编译通过。
OpenGL VBO学习
weixin_41623673的博客
06-22 758
OpenGL Vertex Buffer Object (VBO) GL_ARB_vertex_buffer_object扩展旨在通过提供顶点数组和显示列表的有点来增强 OpenGL 的性能，同时避免它们实现的缺点。顶点缓冲对象 (VBO) 允许顶点数组数据存储在服务器端的高性能图形内存中，并促进高效的数据传输。如果缓冲区对象用于存储像素数据，则称为像素缓冲区对象（PBO）。 使用顶点数组可以减少函数调用次数和共享顶点的冗余使用。但是，顶点数组的缺点是顶点数组函数处于客户端状态，每次引用数组中的数据都必须重
VBO的使用
snail_hunan的专栏
05-26 1209
VBO的定义VBO，全称Vertex Buffer Object，中文名叫顶点缓冲区对象，是位于显卡中的一块内存区，这个内存区存放的是顶点相关的数据，比如坐标、颜色、法向量等。相关概念Buffer Object，缓冲区对象，即显卡中的一块内存区。这个内存区可以存放不同的东西，当存放顶点相关的数据时，就是上面的顶点缓冲区对象VBO。当这个内存区存放Uniform变量的时候，就叫统一缓冲区对象（Unif
position的属性值有哪些_面试中经常被问到的 OpenGL ES 对象，你知道的有哪些？...
weixin_39743423的博客
12-04 276
面试中经常被问到的 OpenGL ES 对象，你知道的有哪些？VBO 和 EBOVBO(Vertex Buffer Object)是指顶点缓冲区对象，而 EBO(Element Buffer Object)是指图元索引缓冲区对象，VBO 和 EBO 实际上是对同一类 Buffer 按照用途的不同称呼。OpenGL ES 2.0 编程中，用于绘制的顶点数组数据首先保存在 CPU 内存，在调...
Qt+OpenGL入门教程（四）——VBO、VAO和EBO
最新发布
bmseven的博客
04-01 782
在OpenGL中，VAO（Vertex Array Object）、VBO（Vertex Buffer Object）和EBO（Element Buffer Object）是三个核心概念。
OpenGL中VAO和VBO的区别和用法
rourouwanzi1992的博客
09-06 337
OpenGl VAO VBO 区别
cpp-opengl-vbo-vao-shaders
05-09
cpp-opengl-vbo-vao着色器 用法： git submodule init git submodule update mkdir build cd build cmake .. make ./triangle 在Linux，MacOS和Windows上进行了测试。
初学OpenGL之VBO、VAO、EBO\IBO
qq_35038618的博客
12-25 1524
初学OpenGL之VBO、VAO、EBO\IBO
C# opengl vao vbo ebo 结合GLSL 语言 渲染器实例
09-19
C# opengl vao vbo ebo 结合GLSL 语言 渲染器实例 有备注有说明,看蓝宝书一头雾水的可以看下,代码为OPENGL 加VS2015
学习笔记(05):OpenGL基础教程-VBO和显示列表绘制图形
u012861978的专栏
03-22 361
市面上的OpenGL教程不够系统，知识比较零碎，有的太难，有的又太简单，本课程从一线编程实践经验出发，0基础学习OpenGL底层知识, 讲解重要常用的知识点和整个框架体系，便于学员掌握，并且提供了大量的实际代码案例，便于学习。...
【C++ OpenGL ES 2.0编程笔记】8: 使用VBO和IBO绘制立方体
Small Flows
01-07 4217
本文介绍了OpenGL ES 2.0 中的顶点缓冲对象(VBO: Vertex Buffer Object)和索引缓冲对象(IBO: Indice Buffer Object)的用法， 在之前的文章中图元的绘制没用使用VBO, 要绘制的顶点数据是以顶点数组的形式保存在客户端的内存中的，在每次调用`glDrawArrays`或者`glDrawElements`的时候，顶点数组都会被从客户端内存copy到显卡内存。
OpenGL开发关于VAO和VBO的理解
xyh的博客
10-24 7356
先创建窗口： public class Demo01_open_window { public static void main(String[] args){ glfwInit();//初始化 glfwWindowHint(GLFW_VISIBLE, GL_FALSE);//设置窗口的可见性为false glfwWindow...
是人都能懂，通俗解释VBO和VAO在OpenGL中的作用
kiss_the_rian的博客
07-29 2362
一切都是从顶点数据开始的。 OpenGl只有当坐标在[-1,1]的范围内才处理它，所以我们传入的顶点数据要在这个范围之内。 我们定义一个double数组： float vertices[] = { -0.5f, -0.5f, 0.0f, 0.5f, -0.5f, 0.0f, 0.0f, 0.5f, 0.0f }; 这一段数组有点让人莫名其妙，因为他完全可以写成： float vertices[] = { -0.5f, -0.5f, 0.0f, 0.5f, -0.5f.
VAO VBO EBO
artisans的专栏
05-29 737
GLuint VBO, VA0, EBO; { GLfloat pts[] = { 0.5f, 0.5f, 0.0f, 1, 0, 0, // 右上角 0.5f, -0.5f, 0.0f, 0, 1, 0, // 右下角 -0.5f, -0.5f, 0.0f, 0, 0, 1, //
OpenGL 入门（二）— 顶点数组对象（VAO）和顶点缓冲对象（VBO）
qq_40120946的博客
01-29 1830
顶点数组对象(Vertex Array Object，VAO)： 存储缓冲区和顶点属性状态。顶点缓冲对象(Vertex Buffer Object，VBO)： 一个调用显存并存储所有顶点数据供显卡使用的缓冲对象。元素缓冲对象(Element Buffer Object，EBO)：也叫索引缓冲对象(Index Buffer Object，IBO)： 一个存储元素索引供索引化绘制使用的缓冲对象。标准化设备坐标(Normalized Device Coordinates, NDC)
OpenGL ES：理解VBO和VAO
风起云涌
10-10 435
OpenGL ES：理解VBO和VAO
正确理解 opengl 的 vao（知乎）
lixiaoguang20的博客
11-29 3804
作者：禾惠 链接：https://www.zhihu.com/question/30095978/answer/87995822 来源：知乎 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 OpenGL在画画的时候，要用到很多的信息，如顶点的坐标、纹理、颜色等等.... 假如一个顶点包含了坐标和颜色的信息，那么这个顶点处的数据格式可能如下： x, y,
opengl vao vbo
06-10
OpenGL中的VAO和VBO都是用于提高渲染效率的一种技术。VAO（Vertex Array Object）是用来存储顶点属性状态的对象，而VBO（Vertex Buffer Object）则是用来存储顶点数据的对象。 在使用VAO和VBO时，首先需要生成它们的ID，然后绑定到OpenGL上下文中。接着，就可以将顶点数据存储在VBO中，并将顶点属性指针绑定到VAO上。最后，使用glDrawArrays或glDrawElements函数进行渲染。 使用VAO和VBO的好处是可以尽量减少OpenGL状态的切换，从而提高渲染效率。同时，也方便了代码的管理和维护。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值