OpenGL VAO+VBO+EBO+GLSL练习

最新推荐文章于 2023-06-04 13:55:09 发布
最新推荐文章于 2023-06-04 13:55:09 发布
阅读量683 收藏 2
点赞数
分类专栏： OpenGL 文章标签： opengl
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011760195/article/details/88556961
版权

OpenGL VAO+VBO+EBO+GLSL练习

一、VAO，VBO，EBO之间的关系

废话不多说，直接上图
在这里插入图片描述
也就是说：

  • 每个个VAO管理着数个VBO，同时可以拥有一个EBO（EBO，索引数据，可以没有，此时直接用顶点数据绘制）

  • 每个VBO用来存放数组数据，这个数据可以由你自己定义顺序

在绑定了VAO之后，后面绑定的VBO和EBO归属到这个VAO中

	// 创建VAO对象
	glGenVertexArrays(1, &_array);
	glBindVertexArray(_array);

	// 绑定顶点缓冲对象
	glGenBuffers(1, &_vertex);
	glBindBuffer(GL_ARRAY_BUFFER, _vertex);
	glBufferData(GL_ARRAY_BUFFER, sizeof(vertex), vertex, GL_STATIC_DRAW);
	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
	glEnableVertexAttribArray(0);

	// 绑定颜色缓冲对象
	glGenBuffers(1, &_color);
	glBindBuffer(GL_ARRAY_BUFFER, _color);
	glBufferData(GL_ARRAY_BUFFER, sizeof(color), color, GL_STATIC_DRAW);
	glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, 0, 0);
	glEnableVertexAttribArray(1);

	// 绑定法线缓冲对象
	glGenBuffers(1, &_normal);
	glBindBuffer(GL_ARRAY_BUFFER, _normal);
	glBufferData(GL_ARRAY_BUFFER, sizeof(normal), normal, GL_STATIC_DRAW);
	glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, 0, 0);
	glEnableVertexAttribArray(2);

	// 绑定索引缓冲对象
	glGenBuffers(1, &_index);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _index);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(index), index, GL_STATIC_DRAW);

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

你可以用
glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, 0, 0);
来指定VBO中数据的安排方式
同时用glEnableVertexAttribArray(2);
来告诉glsl传入数据的位置

例如对上面的VAO，顶点着色器这样写：

#version 440

uniform mat4 _model_view;
uniform mat4 _projection;

uniform vec4 _light0_position;

layout (location = 0) in vec3 v;
layout (location = 1) in vec4 c;
layout (location = 2) in vec3 n;

struct v2f{
	vec4 c;

};

out v2f vert_out;

void main(){
	vert_out.c = c;
	gl_Position = _projection * _model_view * vec4(v,1);
}

通过 layout (location = 1) in vec4 c; 来取得VAO中的glEnableVertexAttribArray(1);的数据

二、代码

先放效果图:
在这里插入图片描述
geomtery

class geomtery {
public:
	geomtery();
	~geomtery();
	geomtery(vec3 center, GLfloat w, GLfloat h,vec4 c);
	void draw(void);
private:
	GLuint _array;
	GLuint _vertex;
	GLuint _color;
	GLuint _normal;
	GLuint _index;
};

geomtery::geomtery(vec3 c, GLfloat w, GLfloat h,vec4 cl) {

	GLfloat half_w = w / 2.0f, half_h = h / 2.0;
	GLfloat vertex[12];
	vertex[0] = c.x - half_w;	vertex[1] = c.y + half_h; vertex[2] = c.z;
	vertex[3] = c.x - half_w;	vertex[4] = c.y - half_h; vertex[5] = c.z;
	vertex[6] = c.x + half_w;	vertex[7] = c.y - half_h; vertex[8] = c.z;
	vertex[9] = c.x + half_w;	vertex[10] = c.y + half_h; vertex[11] = c.z;

	GLfloat color[4];
	color[0] = cl.x; color[1] = cl.y; color[2] = cl.z; color[3] = cl.w;

	vec3 v1, v2, n;
	v1 = vec3(vertex[6], vertex[7], vertex[8]) - vec3(vertex[0], vertex[1], vertex[2]);
	v2 = vec3(vertex[9], vertex[10], vertex[11]) - vec3(vertex[3], vertex[4], vertex[5]);
	n =  cross(v1, v2);
	n = normalize(n);
	GLfloat normal[3];
	normal[0] = n.x; normal[1] = n.y; normal[2] = n.z;

	GLuint index[6];
	index[0] = 0; index[1] = 1; index[2] = 2; index[3] = 0; index[4] = 2; index[5] = 3;

	// 创建VAO对象
	glGenVertexArrays(1, &_array);
	glBindVertexArray(_array);

	// 绑定顶点缓冲对象
	glGenBuffers(1, &_vertex);
	glBindBuffer(GL_ARRAY_BUFFER, _vertex);
	glBufferData(GL_ARRAY_BUFFER, sizeof(vertex), vertex, GL_STATIC_DRAW);
	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
	glEnableVertexAttribArray(0);

	// 绑定颜色缓冲对象
	glGenBuffers(1, &_color);
	glBindBuffer(GL_ARRAY_BUFFER, _color);
	glBufferData(GL_ARRAY_BUFFER, sizeof(color), color, GL_STATIC_DRAW);
	glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, 0, 0);
	glEnableVertexAttribArray(1);

	// 绑定法线缓冲对象
	glGenBuffers(1, &_normal);
	glBindBuffer(GL_ARRAY_BUFFER, _normal);
	glBufferData(GL_ARRAY_BUFFER, sizeof(normal), normal, GL_STATIC_DRAW);
	glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, 0, 0);
	glEnableVertexAttribArray(2);

	// 绑定索引缓冲对象
	glGenBuffers(1, &_index);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _index);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(index), index, GL_STATIC_DRAW);

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

}

void geomtery::draw(void) {

	glBindVertexArray(_array);
	glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, NULL);
	glBindVertexArray(0);
}

main


#include <iostream>
#include <fstream>

#include <GL/glew.h>

#ifdef _WIN32
#define FREEGLUT_STATIC
#include <GL/glut.h>
#endif

#include <sstream>
#include <cmath>
#include "common.h"
#include "geomtery.h"

using namespace std;

#include <vector>

GLuint shader_vert;
GLuint shader_geom;
GLuint shader_frag;

GLuint shader_program;

geomtery * g = nullptr;

GLfloat proj[16];
GLfloat mv[16];

GLuint g_WorldMatrixUniformIndex;
GLuint g_ProjMatrixUniformIndex;

GLfloat light_0_position[4];
GLfloat light_0_ambient[4];
GLfloat light_0_diffuse[4];
GLfloat light_0_specular[4];
GLuint g_LightSource_0_position_Index;
GLuint g_LightSource_0_ambient_Index;
GLuint g_LightSource_0_diffuse_Index;
GLuint g_LightSource_0_specular_Index;



long load_shader(void) {

	GLuint *vert = &shader_vert;
	GLuint *frag = &shader_frag;
	GLuint *program = &shader_program;

	*vert = glCreateShader(GL_VERTEX_SHADER);
	*frag = glCreateShader(GL_FRAGMENT_SHADER);


	fstream in("_vertex.vert");
	if (!in.is_open()) {
		return -1;
	}

	ostringstream buff;
	buff << in.rdbuf();
	string t = std::move(buff.str());
	const GLchar * pbuff =t.c_str();

	glShaderSource(*vert, 1,&pbuff,NULL);

	in.close();
	in.open("_fragment.frag");
	if (!in.is_open()) {
		return -1;
	}

	ostringstream buff2;
	buff2 << in.rdbuf();
	string t2 = std::move(buff2.str());
	pbuff = t2.c_str();

	glShaderSource(*frag, 1, &pbuff, NULL);

	in.close();


	glCompileShader(*vert);
	glCompileShader(*frag);

	int l;
	int cw;

	char* log;
	glGetShaderiv(*vert, GL_INFO_LOG_LENGTH, &l);
	if (l > 0) {

		log = new char[l];
		glGetShaderInfoLog(*vert, l, &cw, log);

		cout << log << endl;
		delete log;

	}

	glGetShaderiv(*frag, GL_INFO_LOG_LENGTH, &l);
	if (l > 0) {

		log = new char[l];
		glGetShaderInfoLog(*frag, l, &cw, log);

		cout << log << endl;
		delete log;

	}


	*program = glCreateProgram();

	glAttachShader(*program, *vert);
	glAttachShader(*program, *frag);

	glLinkProgram(*program);
	glGetProgramiv(*program, GL_INFO_LOG_LENGTH, &l);
	if (l > 0) {

		log = new char[l];
		glGetProgramInfoLog(*program, l, &cw, log);

		cout << log << endl;
		delete log;

	}
	glUseProgram(*program);


	g_WorldMatrixUniformIndex = glGetUniformLocation(*program, "_model_view");
	g_ProjMatrixUniformIndex = glGetUniformLocation(*program, "_projection");

	glGetFloatv(GL_PROJECTION_MATRIX, proj);
	glGetFloatv(GL_MODELVIEW_MATRIX, mv);

	glUniformMatrix4fv(g_WorldMatrixUniformIndex, 1, GL_FALSE, mv);
	glUniformMatrix4fv(g_ProjMatrixUniformIndex, 1, GL_FALSE, proj);

	g_LightSource_0_position_Index = glGetUniformLocation(*program, "_light0_position");
	glUniform4fv(g_LightSource_0_position_Index, 1, light_0_position);

	g_LightSource_0_ambient_Index = glGetUniformLocation(*program, "_light0_ambient");
	glUniform4fv(g_LightSource_0_ambient_Index, 1, light_0_ambient);

	g_LightSource_0_diffuse_Index = glGetUniformLocation(*program, "_light0_diffuse");
	glUniform4fv(g_LightSource_0_diffuse_Index, 1, light_0_diffuse);

	g_LightSource_0_specular_Index = glGetUniformLocation(*program, "_light0_specular");
	glUniform4fv(g_LightSource_0_specular_Index, 1, light_0_specular);


}

void changed_size(int w, int h) {
	// 修改视窗size
	glViewport(0, 0, w, h);

	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();

	gluPerspective(45.0f, double(w) / double(h), 1.0f, 1000.0f);

	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	
	gluLookAt(0.0f, 0.0f, 3.0f,
		0.0f, 0.0f, 0.0f,
		0.0f, 1.0f, 0.0f);


	glGetFloatv(GL_PROJECTION_MATRIX, proj);
	glGetFloatv(GL_MODELVIEW_MATRIX, mv);

	glUniformMatrix4fv(g_WorldMatrixUniformIndex, 1, GL_FALSE, mv);
	glUniformMatrix4fv(g_ProjMatrixUniformIndex, 1, GL_FALSE, proj);

	return;
}

// 初始化渲染环境
void init_render_context() {

	// 蓝色背景
	glClearColor(0.f, 0.f, .3f, 1.f);
	
	//glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);

	glEnable(GL_CULL_FACE);

	glEnable(GL_LIGHTING);
	glEnable(GL_LIGHT0);

	make_vec4(light_0_ambient , .3f,.3f,.3f,1.f );
	make_vec4(light_0_diffuse, .7f, .7f, .7f, 1.f);
	make_vec4(light_0_specular, .5f, .5f, .5f, 1.f);

	glLightfv(GL_LIGHT0, GL_AMBIENT, light_0_ambient);
	glLightfv(GL_LIGHT0, GL_DIFFUSE, light_0_diffuse);
	glLightfv(GL_LIGHT0, GL_SPECULAR, light_0_specular);

	make_vec4(light_0_position, 2.0f, 2.0f, 2.f, 1.f);
	glLightfv(GL_LIGHT0, GL_POSITION, light_0_position);

	//glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, 1);
	//glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, 0);
	//glLightf(GL_LIGHT0, GL_QUADRATIC_ATTENUATION, 0);

}

// 渲染
void render(void) {

	// 清除颜色缓冲、深度缓冲、模板缓冲
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);


	if (g != nullptr) {

		g->draw();

	}
	// 交换缓冲区
	glutSwapBuffers();
}

int main(int argc, char**argv) {

	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH | GLUT_STENCIL);
	glutInitWindowSize(800, 600);
	glutCreateWindow("OpenGL");
	glutReshapeFunc(changed_size);
	glutDisplayFunc(render);
	glutIdleFunc(render);

	GLenum err = glewInit();
	if (GLEW_OK != err) {
		std::cerr << "GLEW Error : " << glewGetErrorString(err) << std::endl;
		return 1;
	}

	init_render_context();


	/* ========================== */
	/*
	*			shader	
	*/

	load_shader();

	g= new geomtery(vec3(0.0, 0.0, 0.0), 1.0, 1.0, vec4(1.0, 1.0, 1.0, 1.0));

	glutMainLoop();

	return 0;
}

_vertex.vert

#version 440

uniform mat4 _model_view;
uniform mat4 _projection;

uniform vec4 _light0_position;

layout (location = 0) in vec3 v;
layout (location = 1) in vec4 c;
layout (location = 2) in vec3 n;

struct v2f{
	vec4 c;

};

out v2f vert_out;

void main(){
	vert_out.c = c;
	gl_Position = _projection * _model_view * vec4(v,1);
}

_fragment.frag

#version 440

uniform vec4 _light0_position;
uniform vec4 _light0_ambient;
uniform vec4 _light0_diffuse;

out vec4 o;

struct v2f{
	vec4 c;

};

in v2f vert_out;

void main() {
	o = vert_out.c;
}

glmath


class vec3 {
public:
	vec3();
	~vec3();
	vec3(GLfloat _x,GLfloat _y,GLfloat _z);
	GLfloat x,y,z;
};

class vec4:public vec3 {
public:
	vec4();
	~vec4();
	vec4(GLfloat _x, GLfloat _y, GLfloat _z,GLfloat _w );
	GLfloat w;
};

vec3 cross(vec3 &v1, vec3 &v2) {
	vec3 r;
	r.x = (v1.y * v2.z) - (v1.z * v2.y);
	r.y = (v1.z * v2.x) - (v1.x * v2.z);
	r.z = (v1.x * v2.y) - (v1.y * v2.x);

	return r;
}

vec3 normalize(vec3 &v) {
	vec3 r;
	GLfloat a = 1.0 / sqrt(v.x*v.x + v.y*v.y + v.z*v.z);
	r.x = static_cast<GLfloat>(a*v.x);
	r.y = static_cast<GLfloat>(a*v.y);
	r.z = static_cast<GLfloat>(a*v.z);

	return r;
}


vec3 operator+(const vec3& l, const vec3& r) {
	vec3 ret;
	ret.x = l.x + r.x;
	ret.y = l.y + r.y;
	ret.z = l.z + r.z;

	return ret;
}

vec4 operator+(const vec4& l, const vec4& r) {
	vec4 ret;
	ret.x = l.x + r.x;
	ret.y = l.y + r.y;
	ret.z = l.z + r.z;
	ret.w = l.w + r.w;
	return ret;
}

vec3 operator-(const vec3& l, const vec3& r) {
	vec3 ret;
	ret.x = l.x - r.x;
	ret.y = l.y - r.y;
	ret.z = l.z - r.z;

	return ret;
}

vec4 operator-(const vec4& l, const vec4& r) {
	vec4 ret;
	ret.x = l.x - r.x;
	ret.y = l.y - r.y;
	ret.z = l.z - r.z;
	ret.w = l.w - r.w;
	return ret;
}
_luna
关注
专栏目录
OpenGL ES VAO、VBO、EBO、FBO、PBO、TBO、UBO
字节流动
01-08 2万+
面试中经常被问到的 OpenGL ES 对象，你知道的有哪些？ 该原创文章首发于微信公众号：字节流动 VBO 和 EBO VBO（Vertex Buffer Object）是指顶点缓冲区对象，而 EBO（Element Buffer Object）是指图元索引缓冲区对象，VAO 和 EBO 实际上是对同一类 Buffer 按照用途的不同称呼。 OpenGL ES 2.0 编程中，用于绘制的顶点数组数据首先保存在 CPU 内存，在调用 glDrawArrays 或者 glDrawElements 等进行绘
Qt OpenGL（二十二）——Qt OpenGL 核心模式-VAO和VBO
ifeng12358的博客
11-19 1944
你只需要记住现在这些步骤就行。在调用VAO的时候，使用的函数glVertexAttribPointer函数，Attrib就是属性的意思，这个函数就是指定输入数据的哪一个部分对应顶点着色器的哪一个顶点属性。所以，VBO的作用就是在CPU和GPU之间充当一个桥梁的作用，当我们把顶点数据存到VBO，VBO就会把数据自动的送到GPU，我们不需要关心他怎么送过去的，我们只要负责往VBO中送数据就行了（使用函数实现）。上面是我们需要绘制的顶点，同时也包含顶点颜色数据，也有可能会包含纹理数据，这个以后会介绍。
OpenGL进阶--VAO，VBO, EBO
11-02
我们通过所谓的 **顶点缓冲对象 （VBO）**，可以在GPU的内存中存储大量的顶点。使用这些缓冲区对象的好处是，我们可以一次将大批数据全部发送到图形卡，如果还有足够的内存，则可以将其保存在此处，而不必一次发送一个顶点。从CPU将数据发送到图形卡的速度相对较慢，因此我们尽可能尝试一次发送尽可能多的数据。数据存储在图形卡的内存中之后，顶点着色器几乎可以立即访问顶点，因此速度非常快。
VBO与VAO
wanglang3081的专栏
04-02 8082
VBO与VAO (2012-07-09 17:57:36) 转载▼ 标签： 杂谈 分类：OpenGL 我想大家都已经熟悉VBO了吧。在GL3.0时代的VBO大体还是处于最重要的地位，但是与此同时也出现了不少新的用法和辅助役，其中一个就是VAO。本文大致小记一下这两者的联系，帮助大家理解一下这个角色。—— 原文地址：http://www.
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, //
VAO VBO EBO（1）
weixin_30315723的博客
09-15 189
刚学习OpenGL不久，就遇到了VAO VBO EBO(IBO)这类难题，这里写个blog来讲解一下这三个东西的概念，理清思路。 由于篇幅问题，本篇先写最简单的VBO。 在讲解之前，有些预备知识需要了解一下：OpenGL中的缓冲区既是所谓的显存，开始工作的时候缓冲区内的数据会通过AGP总线传输到GPU中。 VBO(vertex buffer object ：顶点缓冲对象） V...
OpenGL & GLSL训练(二）
lzqlsm19的博客
04-15 217
Exercise 2： 纹理 文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 提示：以下是本篇文章正文内容，下面案例可供参考 一、在练习1的基础上，绘制一个带纹理的三角形 1.首先是纹理图像的载入 void LoadBMP() { FILE* pfile = fopen("brick.bmp", "rb"); if (pfile == 0) exit(0); //读取图像大小 fseek(pfile, 0x0012..
C# opengl vao vbo ebo 结合GLSL 语言 渲染器实例
09-19
C# opengl vao vbo ebo 结合GLSL 语言 渲染器实例 有备注有说明,看蓝宝书一头雾水的可以看下,代码为OPENGL 加VS2015
Android基于OpenGL ES 3.0的VBO,VAO,EBO的使用(NDK开发）
JabamiYu的博客
05-27 1593
有过一点OpenGL开发经验的人就知道每次绘图之前都会绑定顶点数组，每次将一个顶点传到GPU进行绘制。但是从CPU传数据到GPU的效率并不高，所以我们就需要使用VBO顶点缓存对象来一次性传递多个顶点到GPU，而VAO是3.0以后的版本才有的功能，它允许我们保存对于顶点的配置信息，我们配置好之后就只需要绑定对应的VAO，然后直接绘制即可。索引缓冲对象EBO和VBO类似也就是保存下标的缓冲。 - ...
OpenGL 创建窗口/三角形VAO、VBO、EBO
可爱的猪窝
06-20 994
Day 1 使用OpenGL创建三角形 程序运行效果 VAO vertex array object 顶点数组对象 VBO vertex buffer object 顶点缓冲对象 EBO element(index) buffer object 索引缓冲对象 VBO and VAO Data Flow from CPU to GPU Vertex Buffer Object (VBO) VBO...
练习时的GLSL程序
03-28
本资源没什么用，不要下载，只是看视频时GLSL的代码，主要是跟着B站视频学习的OPenGL着色器的基础。没有实际作用，仅供自己回看方便使用。
VAO与VBO
和尚的专栏
09-12 5790
VAO 1.创建代码
OpenGL &amp； GLSL训练(四）
lzqlsm19的博客
04-23 223
前言 这次的作业比较简单，是在三的基础上为每个茶壶添加不同的贴图纹理 一、在练习3的基础中为每个茶壶加入不同的材质 void LoadBMP() { glGenTextures(3, texName); for (int i = 0; i < 3; i++) { FILE* pfile = fopen(picName[i], "rb"); if (pfile == 0) exit(0); //读取图像大小 fseek(pfile, 0x0012, SEEK_S...
VAO、VBO、EBO简介
希望能帮助大家，希望大家多多支持，你们的支持是我前进的动力。
06-04 1101
使用这些缓冲对象的好处是我们可以一次性的发送一大批数据到显卡上，而不是每个顶点发送一次。GPU内的这块显存区域里是紧密连续的一个个数据，我们需要告诉OpenGL，从哪里到哪里是一个顶点的数据，从哪里到哪里是这个顶点的RGB值（如果有的话）等。同样，和VBO类似，我们会把这些函数调用放在绑定和解绑函数调用之间，只不过这次我们把缓冲的类型定义为GL_ELEMENT_ARRAY_BUFFER。我们使用的任何（在GL_ARRAY_BUFFER目标上的）缓冲调用都会用来配置当前绑定的缓冲(VBO)。
VAO VBO EBO（2）
weixin_30315723的博客
09-15 182
本篇blog讲的是VAO，想看VBO参照上一篇blog。 VAO(vertex array object,顶点数组对象），不得不说......这个名字起得真是鬼畜，名字和功能八竿子打不着。 吐槽归吐槽，该写还是要写的。 我们知道，VBO保存了一个模型的顶点属性信息，每次绘制模型之前我们需要绑定所有的这些信息，对于单个模型来说，这个操作本身无可厚非，但是，当绘制量很大且有大量重复...
OpenGL的VAO-VBO-EBO
春夜喜雨的专栏
07-23 907
这几个单词和大体的描述： VAO: Vertex Array Object：顶点数组对象，存储了一组绑定信息的数据，例如使用哪个VBO的哪个部分，VBO对象绑定了哪些变量供使用。绘制时，只需要切换VAO，就可以完成VBO和绑定变量的切换，从而直接调用绘制函数。
OpenGLES（三）VAO、VBO、EBO
麦芽的博客
01-14 515
OpengGLES VAO、VBO、EBO 的使用
openGL之API学习（五十一）VAO VBO EBO
hankern的专栏
04-26 342
在现代OpenGL（3.0+）的体系里，VAO和VBO已经是个很基本的概念了，是学习GL必须要理解的一个点。 1、顶点数组对象（Vertex Arrary Object，VAO） VBO保存了一个模型的顶点属性信息，每次绘制模型之前需要绑定顶点的所有信息，当数据量很大时，重复这样的动作变得非常麻烦。VAO可以把这些所有的配置都存储在一个对象中，每次绘制模型时，只需要绑定这个VAO对象就可以...
[OpenGL] VAO、VBO、EBO
weixin_44179561的博客
04-19 4910
一、BO（Buffer Object，缓冲对象） 缓冲对象是OpenGL管理的一段内存，为了与我们CPU的内存区分开，一般称OpenGL管理的内存为：显存。 显存，也就是显卡里的内存。显卡访问显存比较快，而Buffer Object，就是由OpenGL维护的一块显存区域。比如说在一块显存为2G的显卡里，分配了128K大小的内存区域给OpenGL使用，这个128K大小的内存区域，就叫一个Buffer Object。 由于显卡访问显存，比访问内存（CPU里的内存区域）要快很多。而且显卡做运算，一般都是访问显存的
opengl vao vbo ebo
最新发布
06-28
OpenGL中的VAO、VBO和EBO是三种重要的缓存对象，用于存储和管理顶点数据和索引数据。 VAO（Vertex Array Object）是顶点数组对象，用于存储顶点数据的属性信息，如顶点坐标、颜色、法向量等。VAO可以将多个VBO绑定...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值