OpenGL入门学习笔记（一）——OpenGL使用glMapBuffer或glBufferSubData动态修改EBO

已于 2023-09-26 16:43:33 修改
阅读量1.3k 收藏 3
点赞数
分类专栏： OpenGL 文章标签： c++ 图形渲染 3d
于 2023-02-05 16:57:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45523399/article/details/128891430
版权

最近在尝试使用OpenGL实现四叉树LOD，一个思路是动态修改Buffer的数据以实现动态绘制。
查找到可以用glMapBuffer或者glBufferSubData来修改数据，在此对使用方式做个记录。

1、使用glMapBuffer
glMapBuffer是获取Buffer的指针地址，注意，在通过指针修改Buffer后需要调用glUnmapBuffer进行提交。

const int N = 128 + 1;
const int layerNum = std::log2(N - 1);

int dynamicDraw();

int dynamicDraw()
{
	auto window = initWindow();

	Ogle::Shader* drawShader = new Ogle::Shader("./01_DynamicDraw.vert", "./01_DynamicDraw.frag");

	float* vertices = new float[N * N * 3];
	float sX = -N / 2.0;
	float sZ = N / 2.0;
	for (int i = 0; i < N; i++)
	{
		for (int j = 0; j < N; j++)
		{
			vertices[i * N * 3 + j * 3] = sX;
			vertices[i * N * 3 + j * 3 + 1] = 0.0;
			vertices[i * N * 3 + j * 3 + 2] = sZ;

			sX += 1.0;
		}
		sX = -N / 2.0;
		sZ -= 1.0;
	}

	int layerGrid[8] = { 1,2,4,8,16,32,64,128 };

	//1×1
	int divide = (N - 1) / layerGrid[0];
	unsigned int* layer_1 = new unsigned int[layerGrid[0] * layerGrid[0] * 6];
	for (int i = 0; i < layerGrid[0]; i++)
	{
		for (int j = 0; j < layerGrid[0]; j++)
		{
			layer_1[i * layerGrid[0] * 6 + j * 6] = i * divide * N + j * divide;
			layer_1[i * layerGrid[0] * 6 + j * 6 + 1] = divide + i * divide * N + j * divide;
			layer_1[i * layerGrid[0] * 6 + j * 6 + 2] = divide * N + i * divide * N + j * divide;
			layer_1[i * layerGrid[0] * 6 + j * 6 + 3] = divide + i * divide * N + j * divide;
			layer_1[i * layerGrid[0] * 6 + j * 6 + 4] = divide * N + i * divide * N + j * divide;
			layer_1[i * layerGrid[0] * 6 + j * 6 + 5] = divide * (N + 1) + i * divide * N + j * divide;
		}
	}

	//2×2
	divide = (N - 1) / layerGrid[1];
	unsigned int* layer_2 = new unsigned int[layerGrid[1] * layerGrid[1] * 6];
	for (int i = 0; i < layerGrid[1]; i++)
	{
		for (int j = 0; j < layerGrid[1]; j++)
		{
			layer_2[i * layerGrid[1] * 6 + j * 6] = i * divide * N + j * divide;
			layer_2[i * layerGrid[1] * 6 + j * 6 + 1] = divide + i * divide * N + j * divide;
			layer_2[i * layerGrid[1] * 6 + j * 6 + 2] = divide * N + i * divide * N + j * divide;
			layer_2[i * layerGrid[1] * 6 + j * 6 + 3] = divide + i * divide * N + j * divide;
			layer_2[i * layerGrid[1] * 6 + j * 6 + 4] = divide * N + i * divide * N + j * divide;
			layer_2[i * layerGrid[1] * 6 + j * 6 + 5] = divide * (N + 1) + i * divide * N + j * divide;
		}
	}

	//4×4
	divide = (N - 1) / layerGrid[2];
	unsigned int* layer_3 = new unsigned int[layerGrid[2] * layerGrid[2] * 6];
	for (int i = 0; i < layerGrid[2]; i++)
	{
		for (int j = 0; j < layerGrid[2]; j++)
		{
			layer_3[i * layerGrid[2] * 6 + j * 6] = i * divide * N + j * divide;
			layer_3[i * layerGrid[2] * 6 + j * 6 + 1] = divide + i * divide * N + j * divide;
			layer_3[i * layerGrid[2] * 6 + j * 6 + 2] = divide * N + i * divide * N + j * divide;
			layer_3[i * layerGrid[2] * 6 + j * 6 + 3] = divide + i * divide * N + j * divide;
			layer_3[i * layerGrid[2] * 6 + j * 6 + 4] = divide * N + i * divide * N + j * divide;
			layer_3[i * layerGrid[2] * 6 + j * 6 + 5] = divide * (N + 1) + i * divide * N + j * divide;
		}
	}

	//8×8
	divide = (N - 1) / layerGrid[3];
	unsigned int* layer_4 = new unsigned int[layerGrid[3] * layerGrid[3] * 6];
	for (int i = 0; i < layerGrid[3]; i++)
	{
		for (int j = 0; j < layerGrid[3]; j++)
		{
			layer_4[i * layerGrid[3] * 6 + j * 6] = i * divide * N + j * divide;
			layer_4[i * layerGrid[3] * 6 + j * 6 + 1] = divide + i * divide * N + j * divide;
			layer_4[i * layerGrid[3] * 6 + j * 6 + 2] = divide * N + i * divide * N + j * divide;
			layer_4[i * layerGrid[3] * 6 + j * 6 + 3] = divide + i * divide * N + j * divide;
			layer_4[i * layerGrid[3] * 6 + j * 6 + 4] = divide * N + i * divide * N + j * divide;
			layer_4[i * layerGrid[3] * 6 + j * 6 + 5] = divide * (N + 1) + i * divide * N + j * divide;
		}
	}

	//16×16
	divide = (N - 1) / layerGrid[4];
	unsigned int* layer_5 = new unsigned int[layerGrid[4] * layerGrid[4] * 6];
	for (int i = 0; i < layerGrid[4]; i++)
	{
		for (int j = 0; j < layerGrid[4]; j++)
		{
			layer_5[i * layerGrid[4] * 6 + j * 6] = i * divide * N + j * divide;
			layer_5[i * layerGrid[4] * 6 + j * 6 + 1] = divide + i * divide * N + j * divide;
			layer_5[i * layerGrid[4] * 6 + j * 6 + 2] = divide * N + i * divide * N + j * divide;
			layer_5[i * layerGrid[4] * 6 + j * 6 + 3] = divide + i * divide * N + j * divide;
			layer_5[i * layerGrid[4] * 6 + j * 6 + 4] = divide * N + i * divide * N + j * divide;
			layer_5[i * layerGrid[4] * 6 + j * 6 + 5] = divide * (N + 1) + i * divide * N + j * divide;
		}
	}

	//32×32
	divide = (N - 1) / layerGrid[5];
	unsigned int* layer_6 = new unsigned int[layerGrid[5] * layerGrid[5] * 6];
	for (int i = 0; i < layerGrid[5]; i++)
	{
		for (int j = 0; j < layerGrid[5]; j++)
		{
			layer_6[i * layerGrid[5] * 6 + j * 6] = i * divide * N + j * divide;
			layer_6[i * layerGrid[5] * 6 + j * 6 + 1] = divide + i * divide * N + j * divide;
			layer_6[i * layerGrid[5] * 6 + j * 6 + 2] = divide * N + i * divide * N + j * divide;
			layer_6[i * layerGrid[5] * 6 + j * 6 + 3] = divide + i * divide * N + j * divide;
			layer_6[i * layerGrid[5] * 6 + j * 6 + 4] = divide * N + i * divide * N + j * divide;
			layer_6[i * layerGrid[5] * 6 + j * 6 + 5] = divide * (N + 1) + i * divide * N + j * divide;
		}
	}

	//64×64
	divide = (N - 1) / layerGrid[6];
	unsigned int* layer_7 = new unsigned int[layerGrid[6] * layerGrid[6] * 6];
	for (int i = 0; i < layerGrid[6]; i++)
	{
		for (int j = 0; j < layerGrid[6]; j++)
		{
			layer_7[i * layerGrid[6] * 6 + j * 6] = i * divide * N + j * divide;
			layer_7[i * layerGrid[6] * 6 + j * 6 + 1] = divide + i * divide * N + j * divide;
			layer_7[i * layerGrid[6] * 6 + j * 6 + 2] = divide * N + i * divide * N + j * divide;
			layer_7[i * layerGrid[6] * 6 + j * 6 + 3] = divide + i * divide * N + j * divide;
			layer_7[i * layerGrid[6] * 6 + j * 6 + 4] = divide * N + i * divide * N + j * divide;
			layer_7[i * layerGrid[6] * 6 + j * 6 + 5] = divide * (N + 1) + i * divide * N + j * divide;
		}
	}

	//128×128
	divide = (N - 1) / layerGrid[7];
	unsigned int* layer_8 = new unsigned int[layerGrid[7] * layerGrid[7] * 6];
	for (int i = 0; i < layerGrid[7]; i++)
	{
		for (int j = 0; j < layerGrid[7]; j++)
		{
			layer_8[i * layerGrid[7] * 6 + j * 6] = i * divide * N + j * divide;
			layer_8[i * layerGrid[7] * 6 + j * 6 + 1] = divide + i * divide * N + j * divide;
			layer_8[i * layerGrid[7] * 6 + j * 6 + 2] = divide * N + i * divide * N + j * divide;
			layer_8[i * layerGrid[7] * 6 + j * 6 + 3] = divide + i * divide * N + j * divide;
			layer_8[i * layerGrid[7] * 6 + j * 6 + 4] = divide * N + i * divide * N + j * divide;
			layer_8[i * layerGrid[7] * 6 + j * 6 + 5] = divide * (N + 1) + i * divide * N + j * divide;
		}
	}

	unsigned int VAO;
	glGenVertexArrays(1, &VAO);
	glBindVertexArray(VAO);
	int i = sizeof(&vertices);
	unsigned int VBO;
	glGenBuffers(1, &VBO);
	glBindBuffer(GL_ARRAY_BUFFER, VBO);
	glBufferData(GL_ARRAY_BUFFER, N * N * 3 * 4, vertices, GL_STATIC_DRAW);

	unsigned int EBO;
	glGenBuffers(1, &EBO);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, (N - 1) * (N - 1) * 6 * 4, layer_8, GL_STATIC_DRAW);

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

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

	glEnable(GL_DEPTH_TEST);

	while (!glfwWindowShouldClose(window))
	{
		float currentFrame = static_cast<float>(glfwGetTime());
		deltaTime = currentFrame - lastFrame;
		lastFrame = currentFrame;

		processInput(window);

		glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);//同时清楚深度缓冲区

		glUseProgram(drawShader->id);

		glm::mat4 model = glm::mat4(1.0);
		glm::mat4 view = glm::mat4(1.0);
		glm::mat4 projection = glm::mat4(1.0);
		view = camera.GetViewMatrix();
		projection = glm::perspective(glm::radians(camera.Zoom), 800.0f / 600.0f, 0.1f, 100.0f);
		glUniformMatrix4fv(glGetUniformLocation(drawShader->id, "model"), 1, GL_FALSE, glm::value_ptr(model));
		glUniformMatrix4fv(glGetUniformLocation(drawShader->id, "view"), 1, GL_FALSE, glm::value_ptr(view));
		glUniformMatrix4fv(glGetUniformLocation(drawShader->id, "projection"), 1, GL_FALSE, glm::value_ptr(projection));

		glBindVertexArray(VAO);

		int mN = 0;
		if (camera.Position.y < 2)
		{
			auto p = glMapBuffer(GL_ELEMENT_ARRAY_BUFFER, GL_WRITE_ONLY);
			memcpy(p, layer_8, 128 * 128 * 6 * 4);
			bool update = glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);
			mN = 128;
		}
		else if (camera.Position.y >= 2 && camera.Position.y < 4)
		{
			auto p = glMapBuffer(GL_ELEMENT_ARRAY_BUFFER, GL_WRITE_ONLY);
			memcpy(p, layer_7, 64 * 64 * 6 * 4);
			bool update = glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);
			mN = 64;
		}
		else if (camera.Position.y >= 4 && camera.Position.y < 6)
		{
			auto p = glMapBuffer(GL_ELEMENT_ARRAY_BUFFER, GL_WRITE_ONLY);
			memcpy(p, layer_6, 32 * 32 * 6 * 4);
			bool update = glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);
			mN = 32;
		}
		else if (camera.Position.y >= 6 && camera.Position.y < 8)
		{
			auto p = glMapBuffer(GL_ELEMENT_ARRAY_BUFFER, GL_WRITE_ONLY);
			memcpy(p, layer_5, 16 * 16 * 6 * 4);
			bool update = glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);
			mN = 16;
		}
		else if (camera.Position.y >= 8 && camera.Position.y < 10)
		{
			auto p = glMapBuffer(GL_ELEMENT_ARRAY_BUFFER, GL_WRITE_ONLY);
			memcpy(p, layer_4, 8 * 8 * 6 * 4);
			bool update = glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);
			mN = 8;
		}
		else if (camera.Position.y >= 10 && camera.Position.y < 12)
		{
			auto p = glMapBuffer(GL_ELEMENT_ARRAY_BUFFER, GL_WRITE_ONLY);
			memcpy(p, layer_3, 4 * 4 * 6 * 4);
			bool update = glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);
			mN = 4;
		}
		else if (camera.Position.y >= 12 && camera.Position.y < 14)
		{
			auto p = glMapBuffer(GL_ELEMENT_ARRAY_BUFFER, GL_WRITE_ONLY);
			memcpy(p, layer_2, 2 * 2 * 6 * 4);
			bool update = glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);
			mN = 2;
		}
		else if (camera.Position.y >= 14 && camera.Position.y < 16)
		{
			auto p = glMapBuffer(GL_ELEMENT_ARRAY_BUFFER, GL_WRITE_ONLY);
			memcpy(p, layer_1, 1 * 1 * 6 * 4);
			bool update = glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);
			mN = 1;
		}

		glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
		glDrawElements(GL_TRIANGLES, mN * mN * 6, GL_UNSIGNED_INT, (void*)0);

		glfwSwapBuffers(window);
		glfwPollEvents();
	}

	glDeleteVertexArrays(1, &VAO);
	glDeleteBuffers(1, &VBO);
	glDeleteBuffers(1, &EBO);
	glDeleteProgram(drawShader->id);

	glfwTerminate();
	return 0;
}

2、使用glBufferSubData
将上面代码如下面一一做修改。

		else if (camera.Position.y >= 2 && camera.Position.y < 4)
		{
			/*auto p = glMapBuffer(GL_ELEMENT_ARRAY_BUFFER, GL_WRITE_ONLY);
			memcpy(p, layer_7, 64 * 64 * 6 * 4);
			bool update = glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);*/
			glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, 0, 64 * 64 * 6 * 4, layer_7);
			mN = 64;
		}

注意：修改的内容量不可超过Buffer初始化时的大小（初始化时的大小由glBufferData的设置决定），也就是说不可在设置的最大大小的基础上增加数据。

运行效果：
随着视角拉远，网格逐渐减少。

在这里插入图片描述

真的是好麻烦啊！
关注
专栏目录
OpenGL学习归纳 -- buffer的使用总结
lihei12345的专栏
07-04 7349
1. FrameBuffer是其他Renderbuffer的管理者，
OpenGL编程指南-->OpenGL缓冲区对象
j123kaishichufa的专栏
07-07 1252
OpenGL 缓冲区对象     今天学习了一下缓冲区对象.....    OpenGL是按照客户机-服务器模式设计的，在OpenGL需要数据的时候，都必须把数据从客户机内传输到服务器。    缓冲区对象，允许应用程序现实的指定把哪些数据存储在图形服务器。   1.创建缓冲区对象     glGenBuffers()：OpenGL分配n个当前未使用的名称(非 0)，表示缓冲区对象。
OPenGL中的缓冲区对象
热门推荐
MZYang272的专栏
06-12 2万+
在许多OpenGL操作中，我们都向OpenGL发送一大块数据，例如向它传递需要处理的顶点数组数据。传输这种数据可能非常简单，例如把数据从系统的内存中复制到图形卡。但是，由于OpenGL是按照客户机-服务器模式设计的，在OpenGL需要数据的任何时候，都必须把数据从客户机内存传输到服务器。如果数据并没有修改，或者客户机和服务器位于不同的计算机（分布式渲染），数据的传输可能会比较缓慢，或者是冗余的。
OpenGL API - glMapBuffer - 可用于获取缓存对象指针
Jave.Lin 的学习笔记
07-31 1420
因为有需要对网格顶点属性实时更新，所以我之前使用的 API 是：glBufferData // method 1: glBindBuffer(GL_ARRAY_BUFFER, vbos[(int)MeshVboType::POSITION]); glBufferData(GL_ARRAY_BUFFER, arr->bytes_size(), arr->ptr(), _dynamic ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW); checkGLError(); 但是从
OpenGL中的异步缓存传输Asynchronous Buffer Transfers
翻肚鱼儿的博客
07-28 600
本文介绍在OpenGL中buffer的异步传输，翻译、摘抄自OpenGL Insights Chapter 28。 目前更新到第三节，待续（后面还没看懂） Terminology 为了后文表述方便，现说明一些要使用术语： 1. GPU被称作device 2. 当调用OpenGL functions，相关命令会放入一个队列队列异步地依次执行，这个队列叫device command queue 3.uploading：数据从CPU memory向device memory传送 4.downl...
OpenGL红宝书例3.1 -- glBufferSubData使用
weixin_30385925的博客
10-26 278
代码实现 1.1 C++部分 GLFWwindow *window; GLuint shader_program; GLuint VAO; void init() { static const GLfloat positions[] = { -1.0f, -1.0f, 0.0f, 1.0f, 1.0f, -1.0f, 0.0f, 1.0f...
glBufferSubData
Frank的专栏
05-21 9326
glBufferSubData
glBufferSubData使用实例
m0_37165550的博客
01-07 714
来源与glfw源码example目录下的heightmap.c //======================================================================== // Heightmap example program using OpenGL 3 core profile // Copyright (c) 2010 Olivier Delannoy // // This software is provided 'as-is', without any
glUnmapBuffer
Frank的专栏
05-21 2382
glUnmapBuffer
OpenGL学习笔记：坐标系统
mumufan05的专栏
08-20 1万+
为了将坐标从一个坐标系变换到另一个坐标系，我们需要用到几个变换矩阵，最重要的几个分别是模型(Model)、观察(View)、投影(Projection)三个矩阵。我们的顶点坐标起始于局部空间(Local Space)，在这里它称为局部坐标(Local Coordinate)，它在之后会变为世界坐标(World Coordinate)，观察坐标(View Coordinate)，裁剪坐标(Clip ...
opengl学习笔记（三）——玩弄模型（用户交互）
qq_38782152的博客
05-09 2505
经过前面两节的功夫，我们算是搞到了一个还算可以的模型，但我们想要把模型翻来翻去，移动一下还是不行的。并且，根据用户（老师）需求，我们要让模型能以线框，点的方式绘制。也就有了这最后一讲。首先，我们通过鼠标左键来旋转物体。这就需要在鼠标回调函数里下功夫了if (state == GLUT_DOWN &amp;&amp; button == GLUT_LEFT_BUTTON)//记录旋转拖动起始点 {...
关于VAO，VBO和EBO的理解-OpenGL学习笔记
Rhys Coding House
04-14 1570
本文章首发于我的个人博客，希望大家多多支持！ Hi! This is Showhoop Studio! 如果要从代码层面去理解渲染管线的工作，学习使用OpenGL编程可以说是一个不错的选择。这里我将记录下自己的一下学习笔记，以便日后复习和引用。对于刚刚开始学习或者准备入门学习OpenGL的人，推荐去看LearnOpenGL，除了理论知识之外，这个教程会同时手把手教你搭建自己的OpenGL程序...
OpenGl学习笔记一：创建窗口&绘制三角形
Duoteng Xu
08-19 474
在OpenGL中，任何事物都在3D空间中，而屏幕和窗口却是2D像素数组，3D坐标转为2D坐标的处理过程是由OpenGL的图形渲染管线（一堆原始图形数据途经一个输送管道，期间经过各种变化处理最终出现在屏幕的过程）管理的。几何着色器的输出会被传入光栅化阶段(Rasterization Stage)，这里它会把图元映射为最终屏幕上相应的像素，生成供片段着色器(Fragment Shader)使用的片段(Fragment)。片段着色器的主要目的是计算一个像素的最终颜色，这也是所有OpenGL高级效果产生的地方。
OpenglC++学习笔记
晨蓝的博客
02-17 3635
文章目录OpenGL学习19.10.13OpenGL环境配置OpengGL是什么？GLFW预编译文件和源代码文件GLFW配置CMAKEGLAD和GLEW创建一个窗口渲染循环glClearColor和glClear三角形图元(primitive)标准化设备坐标(Normalized Device Coordinates, NDC)10.15vs解决方案sln文件lib和头文件c++里的数组和size...
glMapBuffer
Frank的专栏
05-21 7847
glMapBufferglMapBuffer
《高效学习OpenGL》之缓冲区对象 glGenBuffers(), glBindBuffer(), glBufferData(),glMapBuffer()
编辑编辑器
02-17 2万+
1.创建缓冲区对象 void glGenBuffers(GLsizei n, GLuint *buffers); //在buffers数组中返回当前n个未使用的名称，表示缓冲区对象 GLboolean glIsBuffer(GLuint buffer); //判断是否是缓冲区对象 2.激活缓冲区对象 void glBindBuffer(GLenum target, GLuint buffer
【OpenGL】OpenGL中的Buffer的巧妙使用
stalendp的专栏
02-22 3946
这篇文章，将记录OpenGL中的Buffer的巧妙使用。 参考： https://docs.unity3d.com/Manual/SL-Stencil.html https://alastaira.wordpress.com/2014/12/27/using-the-stencil-buffer-in-unity-free/
OpenGL缓冲对象：glBufferSubData、glNamedBufferSubData简介
最新发布
01-22 626
OpenGL缓冲对象：glBufferSubData、glNamedBufferSubData简介
OpenGL Buffers
weixin_42684313的博客
07-29 770
click here
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值