OpenGL 使用离屏渲染技术进行截图

于 2024-09-30 12:44:06 发布
阅读量348 收藏 4
点赞数 3
文章标签： c++ windows OpenGL Duilib
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/A_water_/article/details/142653417
版权

文章目录

背景

我有一个Duilib项目，目前已经实现了将OpenGL窗口嵌入到该项目中，并且能够加载obj文件以显示。这是我的效果：
在这里插入图片描述

第三方库

  1. glfw-3.3.8（创建OpenGL窗口）
  2. glad-0.1.33（使用OpenGL函数）
  3. glm-0.9.9.8（数学库）
  4. tinyobjloader-2.0.0rc13（读取Obj文件）

注意

  1. 因为Duilib项目是主线程，OpenGL窗口是嵌入进去，但是它也要自己的线程，所以只能作为子线程去渲染。
  2. 对于我的项目，我仍然需要去控制OpenGL窗口的显示和隐藏。一个具体的需求是，我需要在OpenGL窗口隐藏的场景下，对窗口渲染内容进行截图。所以就引出了离屏渲染技术。

参考资料

LearnOpenGL：非常好用的OpenGL学习资料，如果能认真过一遍，相信就能完成大部分的OpenGL需求了。
ChatGPT：在有基本概念之后，使用AI能大幅提高编程速度。

一、离屏渲染

先通过 LearnOpenGL-帧缓冲 了解一些基本。

（一）帧缓冲与帧缓冲对象（FBO）

简而言之，帧缓冲是一种技术，你可以等价为双缓冲算法。
帧缓冲对象是一个OpenGL对象，与什么VAO, VBO本质上没什么差别，就是一个名称标识。
你可以把FBO当成是MFC中CDC对象，绑定之后就可以在上面绘制各种内容。至于绘制完成之后，你想要拿去做什么，显示在屏幕或者截图，那是你自己的操作。

（二）附件（Attachment）

正如CDC一样，FBO也只是一个标识，如果需要绘制内容，仍然需要绑定画布（Bitmap）才能绘制内容。只不过在FBO中，画布被区分了不同的类型，分别用于绘制不同的内容，比如颜色附件和深度附件。它们通过glTexImage2D()来制定纹理的类型。

二、具体代码

总体的思路是：

  1. 当窗口尺寸改变时，主动创建FBO相关内容。
  2. 主线程要进行截图时，将m_bStartCapture = true; ，通知子线程将内容绘制在FBO上；
  3. 等待绘制完成，根据需要将像素上下反转（因为OpenGL是左下角是原点，而Bitmap图像是左上角为原点）。

（一）主线程创建OpenGL窗口

bool MyOpenGLWnd::CreateOpenGLWnd(HWND hWnd)
{
	// 1. Init GLFW library
	glfwInit();
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

	// 2. Create GLFW window
	m_pGlfwWnd = glfwCreateWindow(400, 400, "OpenGL", NULL, NULL);
	if (m_pGlfwWnd == NULL)
	{
		m_pLogger->error("Failed to create GLFW window");
		glfwTerminate();
		return false;
	}

	// 3. Retrieve the handle of the glfw window and embed it into the parent window
	HWND hwndGLFW = glfwGetWin32Window(m_pGlfwWnd);
	SetWindowLongW(hwndGLFW, GWL_STYLE, WS_VISIBLE);
	MoveWindow(hwndGLFW, 0, 0, 0, 0, TRUE);
	SetParent(hwndGLFW, hWnd);

	// 4. Set the GLFW window context as the main context
	glfwMakeContextCurrent(m_pGlfwWnd);

	// 5. Register the GLAD function address (context must be set for it to take effect)
	if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
	{
		m_pLogger->error("Failed to initialize GLAD");
		glfwTerminate();
		return false;
	}

	// 6. Enable depth test
	glEnable(GL_DEPTH_TEST);

	// 7. Create shader object
	m_pShader = new Shader;
	std::string error;
	if (!m_pShader->Load("./shader/Shader.vs", "./shader/Shader.fs", error))
	{
		m_pLogger->error(error);
		glfwTerminate();
		return false;
	}

	// 8. Create camera object
	m_pCamera = new Camera(glm::vec3(0.0f, 0.0f, 3.0f));

	// 9. Reset the context because the render procedure will be run in the child thread
	glfwMakeContextCurrent(NULL);

	// 10. Create render thread
	createRenderThread();

	return true;
}

（二）渲染子线程

void MyOpenGLWnd::createRenderThread()
{
	m_pRenderThread = new std::thread([this]() {
		glfwMakeContextCurrent(m_pGlfwWnd);

		// 2. Register the callback function we need
		glfwSetFramebufferSizeCallback(m_pGlfwWnd, [](GLFWwindow* window, int width, int height) {
			auto pThisClass = static_cast<MyOpenGLWnd*>(glfwGetWindowUserPointer(window));
			if (pThisClass) {
				pThisClass->frameSizeCallback(window, width, height);
			}
		});

		glfwSetMouseButtonCallback(m_pGlfwWnd, [](GLFWwindow* window, int button, int action, int mods) {
			auto pThisClass = static_cast<MyOpenGLWnd*>(glfwGetWindowUserPointer(window));
			if (pThisClass) {
				pThisClass->mouseBtnCallback(window, button, action, mods);
			}
		});

		glfwSetCursorPosCallback(m_pGlfwWnd, [](GLFWwindow* window, double xposIn, double yposIn) {
			auto pThisClass = static_cast<MyOpenGLWnd*>(glfwGetWindowUserPointer(window));
			if (pThisClass) {
				pThisClass->mousePosCallback(window, xposIn, yposIn);
			}
		});

		glfwSetScrollCallback(m_pGlfwWnd, [](GLFWwindow* window, double xoffset, double yoffset) {
			auto pThisClass = static_cast<MyOpenGLWnd*>(glfwGetWindowUserPointer(window));
			if (pThisClass) {
				pThisClass->scrollCallback(window, xoffset, yoffset);
			}
		});

		glfwSetKeyCallback(m_pGlfwWnd, [](GLFWwindow* window, int key, int scancode, int action, int mods) {
			auto pThisClass = static_cast<MyOpenGLWnd*>(glfwGetWindowUserPointer(window));
			if (pThisClass) {
				pThisClass->keyCallback(window, key, scancode, action, mods);
			}
		});
		glfwSetWindowUserPointer(m_pGlfwWnd, this);

		// 3. Render loop
		while (!glfwWindowShouldClose(m_pGlfwWnd))
		{
			// If window is not visible, just continue.
			if (!glfwGetWindowAttrib(m_pGlfwWnd, GLFW_VISIBLE) && !m_bForceRendering)
			{
				Sleep(10);
				continue;
			}

			// 4. Check the whether the mesh needs to update
			checkVerticeUpdate();

			// 5. Check window size
			checkFrameSize();

			// 6. Check mouse position
			checkMousePos();

			// 7. Check mouse wheel              
			checkScrollOffset();

			// 8. Chek the keydown
			checkKeyDown();

			// 9. Update the timing
			float currentFrameTime = static_cast<float>(glfwGetTime());
			m_deltaTime = currentFrameTime - m_lastFrameTime;
			m_lastFrameTime = currentFrameTime;

			bool bCapture = m_bStartCapture;
			if (bCapture)
			{
				glBindFramebuffer(GL_FRAMEBUFFER, m_frameBufferObj._name);
			}
			else
			{
				glBindFramebuffer(GL_FRAMEBUFFER, 0);
			}

			// 10. Refresh color buffer and depth
			glClearColor(m_clearColor.r, m_clearColor.g, m_clearColor.b, m_clearColor.a);
			glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

			// 11. Use shader
			m_pShader->use();

#pragma region 12. Set vertices shader
			// 12.1 pass projection matrix to shader (note that in this case it could change every frame)
			const auto& frameSize = m_frameSize.load();
			glm::mat4 projection{ 1.0f };
			if (frameSize.y > 0)
			{
				ReadLock(m_cameraMutex);
				projection = glm::perspective(glm::radians(m_pCamera->Zoom), (float)m_frameSize.load().x / (float)m_frameSize.load().y, 0.1f, 100.0f);
			}
			m_pShader->setMat4("projection", projection);

			// 12.2 camera/view transformation
			{
				ReadLock(m_cameraMutex);
				glm::mat4 view = m_pCamera->GetViewMatrix();
				m_pShader->setMat4("view", view);
			}

			// 12.3 model transformation
			glm::mat4 model = glm::mat4(1.0f);
			if (m_bAutorotate) {
				updateRotationAngles(m_deltaTime);
			}
			model = glm::rotate(model, glm::radians(m_modelRotAngle.x), glm::vec3(1.0f, 0.0f, 0.0f));
			model = glm::rotate(model, glm::radians(m_modelRotAngle.y), glm::vec3(0.0f, 1.0f, 0.0f));
			m_pShader->setMat4("model", model);
#pragma endregion

#pragma region 13. Set fragment shader
			{
				ReadLock(m_cameraMutex);
				m_pShader->setVec3("viewPos", m_pCamera->Position);
			}

			// light properties
			glm::vec3 lightColor{ 1.0, 1.0, 1.0 };

			glm::vec3 diffuseColor = lightColor * glm::vec3(0.5f); // decrease the influence
			glm::vec3 ambientColor = diffuseColor * glm::vec3(0.2f); // low influence
			m_pShader->setVec3("light.ambient", ambientColor);
			m_pShader->setVec3("light.diffuse", diffuseColor);
			m_pShader->setVec3("light.specular", 1.0f, 1.0f, 1.0f);

			m_pShader->setVec3("light.direction", glm::normalize(glm::vec3(-0.5f, -0.5f, -0.5f)));
#pragma endregion

			// 14. Draw elements
			for (const Mesh& mesh : m_vMeshs)
			{
				m_pShader->setVec3("material.ambient", mesh.ambient);
				m_pShader->setVec3("material.diffuse", mesh.diffuse);
				m_pShader->setVec3("material.specular", mesh.specular); // specular lighting doesn't have full effect on this object's material
				m_pShader->setFloat("material.shininess", mesh.shininess);

				glBindVertexArray(mesh.VAO); // seeing as we only have a single VAO there's no need to bind it every time, but we'll do so to keep things a bit more organized
				glDrawElements(GL_TRIANGLES, mesh.indices.size(), GL_UNSIGNED_INT, 0);
				glBindVertexArray(0);
			}

			for (const auto& mesh : m_vPlaneMeshs)
			{
				m_pShader->setVec3("material.ambient", mesh.ambient);
				m_pShader->setVec3("material.diffuse", mesh.diffuse);
				m_pShader->setVec3("material.specular", mesh.specular); // specular lighting doesn't have full effect on this object's material
				m_pShader->setFloat("material.shininess", mesh.shininess);

				glBindVertexArray(mesh.VAO); // seeing as we only have a single VAO there's no need to bind it every time, but we'll do so to keep things a bit more organized
				glDrawElements(GL_TRIANGLES, mesh.indices.size(), GL_UNSIGNED_INT, 0);
				glBindVertexArray(0);
			}

			if (bCapture && m_bForceRendering)
			{
				auto frameSize = m_frameSize.load(std::memory_order_relaxed);
				size_t w = frameSize.x;
				size_t h = frameSize.y;
				size_t c = m_capImageChannel;
				size_t pixelSize = w * h * c; 
				
				m_vCaptureDatas.clear();
				m_vCaptureDatas.resize(pixelSize);
				glReadPixels(0, 0, w, h, GL_RGBA, GL_UNSIGNED_BYTE, m_vCaptureDatas.data());

				glBindFramebuffer(GL_FRAMEBUFFER, 0);

				m_bStartCapture = false;
				m_bForceRendering = false;
			}

			// 15. Update buffer
			glfwSwapBuffers(m_pGlfwWnd);
			glfwPollEvents();
		}

		// 16. release data
		for (auto& mesh : m_vMeshs)
		{
			glDeleteVertexArrays(1, &mesh.VAO);
			glDeleteBuffers(1, &mesh.VBO_1);
			glDeleteBuffers(1, &mesh.VBO_2);
			glDeleteBuffers(1, &mesh.EBO);
		}

		for (auto& mesh : m_vPlaneMeshs)
		{
			glDeleteVertexArrays(1, &mesh.VAO);
			glDeleteBuffers(1, &mesh.VBO_1);
			glDeleteBuffers(1, &mesh.VBO_2);
			glDeleteBuffers(1, &mesh.EBO);
		}

		m_frameBufferObj.Clear();

		glfwDestroyWindow(m_pGlfwWnd);
	});
}

（三）窗口尺寸改变的回调函数

/*
	因为窗口尺寸改变是在主线程，渲染是在子线程，所以只能子线程时刻检查
*/
void MyOpenGLWnd::checkFrameSize()
{
	auto frameSize = m_frameSize.load(std::memory_order_relaxed);
	if (frameSize.bUpdate)
	{
		glViewport(0, 0, frameSize.x, frameSize.y);
		m_frameSize.store(FrameSize(false, frameSize.x, frameSize.y), std::memory_order_relaxed);

		createFBO();
	}
}

（四）创建FBO

/*
* @brief	Create FBO for off-line rendering
* @note
*
* @author 	Canliang Wu
* @day		2024/09/26
*/
void MyOpenGLWnd::createFBO()
{
	auto frameSize = m_frameSize.load(std::memory_order_relaxed);
	int width = frameSize.x;
	int height = frameSize.y;

	// Generate fbo
	if (m_frameBufferObj._name == 0)
	{
		glGenFramebuffers(1, &m_frameBufferObj._name);
	}
	glBindFramebuffer(GL_FRAMEBUFFER, m_frameBufferObj._name);

	// Create textures for fbo
	if (!m_frameBufferObj._vTextures.empty())
	{
		glDeleteTextures(m_frameBufferObj._vTextures.size(), m_frameBufferObj._vTextures.data());
		m_frameBufferObj._vTextures.clear();
	}
	m_frameBufferObj._vTextures.resize(2);
	glGenTextures(m_frameBufferObj._vTextures.size(), m_frameBufferObj._vTextures.data());

	// Set color texture attributes
	glBindTexture(GL_TEXTURE_2D, m_frameBufferObj._vTextures[0]);
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

	// Add color texture
	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_frameBufferObj._vTextures[0], 0);

	// Set depth texture attributes (If there is a lack of depth texture, the screenshot will become fragmented)
	glBindTexture(GL_TEXTURE_2D, m_frameBufferObj._vTextures[1]);
	glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, width, height, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

	// Add depth texture
	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, m_frameBufferObj._vTextures[1], 0);

	// Check the fbo is complete
	if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
		std::cerr << "Framebuffer is not complete!" << std::endl;
	}

	glBindTexture(GL_TEXTURE_2D, 0);		// unbind Texture
	glBindFramebuffer(GL_FRAMEBUFFER, 0);	// unbind Framebuffer
}

（五）主线程主动调用截图函数

/*
* @brief	Capture glfw image no matter whether the window is displayed or hidden
* @param	vImageDatas - image source data
* @param	bResize - when the glfw is hidden, need to set the viewport directly
* @param	w - viewport width
* @param	h - viewport height
* @note
*
* @author 	Canliang Wu
* @day		2024/09/26
*/
void MyOpenGLWnd::CaptureScreen(std::vector<unsigned char>& vImageDatas, bool bResize, int w, int h)
{
	// 1. Resize the viewport when the glfw window is hiding
	if (bResize)
	{
		m_frameSize.store(FrameSize(true, w, h), std::memory_order_relaxed);
	}

	// 2. Start capture 
	m_bStartCapture = true;
	m_bForceRendering = true;
	while (m_bStartCapture)
	{
		Sleep(10);
	}

	// 3. Reverse the image
	auto frameSize = m_frameSize.load(std::memory_order_relaxed);

	vImageDatas.resize(m_vCaptureDatas.size());
	for (int y = 0; y < frameSize.y; ++y) {
		for (int x = 0; x < frameSize.x; ++x) {
			// 原始像素位置
			int originalIndex = (frameSize.y - 1 - y) * frameSize.x * m_capImageChannel + x * m_capImageChannel;
			// 翻转后的像素位置
			int flippedIndex = y * frameSize.x * m_capImageChannel + x * m_capImageChannel;

			// 复制 RGB 值
			vImageDatas[flippedIndex] = m_vCaptureDatas[originalIndex];         // R
			vImageDatas[flippedIndex + 1] = m_vCaptureDatas[originalIndex + 1]; // G
			vImageDatas[flippedIndex + 2] = m_vCaptureDatas[originalIndex + 2]; // B
			vImageDatas[flippedIndex + 3] = m_vCaptureDatas[originalIndex + 3]; // A
		}
	}
}

三、注意

这里必须添加深度附件，不然就会出现这样的结果：
在这里插入图片描述

OpenGL ES FBO 离屏渲染详解（附项目源码）
字节流动
08-04 2万+
FBO（Frame Buffer Object）即帧缓冲区对象，实际上是一个可添加缓冲区的容器，可以为其添加纹理或渲染缓冲区对象（RBO）。FBO 本身不能用于渲染，只有添加了纹理或者渲染缓冲区之后才能作为渲染目标，它仅且提供了 3 种附着（Attachment），分别是颜色附着、深度附着和模板附着。RBO（Render Buffer Object）即渲染缓冲区对象，是一个由应用程序分配的 2D 图像缓冲区。渲染缓冲区可以用于分配和存储颜色、深度或者模板值，可以用作 FBO 中的颜色、深度或者模板附着。
iOS之从OpenGL深入探究离屏渲染及性能优化
热门推荐
╰つ栺尖篴夢ゞ
07-06 2万+
探究内容 到底什么是离屏渲染？是在GPU上面还是CPU上面执行的？ 为什么要有离屏渲染？什么情况下会产生离屏渲染？ 帧缓冲区是什么？当前屏幕缓冲区和屏幕外缓冲区又是什么？ 切换缓冲区是什么操作？真的比较耗时吗？ OpenGL屏幕渲染方式 OpenGL中，GPU屏幕渲染有以下两种方式： On-Screen Rendering：意为当前屏幕渲染，指的是GPU的渲染操作是在当前用于显示的屏幕缓冲区中进行。 Off-Screen Rendering：意为离屏渲染，指的是GPU在当前屏幕缓冲区以外新开辟一个缓冲
OpenGL ES 离屏渲染实例（pbuffer)
lh0616的博客
08-27 1550
系列文章目录 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 第一章 OpenGL ES 离屏渲染实例（pbuffer） 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 系列文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术..
OpenGL之离屏渲染
henry_lei的博客
11-28 1884
作者：范大可 链接：https://juejin.cn/post/6899635441201643534 什么是离屏渲染 Off-Screen Rendering意为离屏渲染，指的是GPU在当前屏幕缓冲区以外新开辟一个缓冲区进行渲染操作 为什么需要离屏渲染 因为在帧缓冲区渲染一个视图到屏幕中就抛弃的机制.所以当我们有多组视图需要组合随后统一处理的时候.需要在屏缓冲区额外开辟一个离屏的缓冲区去记录这些视图.随后统一处理.最后渲染显示出来 怎么产生离屏渲染 我们首先分析圆角产生离屏渲染的情况: 回顾一下.当我
1.OpenGLES——FBO方式的离屏渲染
liuyizhou95的博客
04-13 5380
参考 https://blog.csdn.net/u011371324/article/details/78011211 书写本文的初衷是为了自我学习 出现背景 明确两个概念 窗口系统默认帧缓冲 应用程序帧缓冲 FBO(frame buffer object),帧缓冲区对象，在Android中，绘制三角形一般都是直接重写GLSurfaceVi...
离屏渲染 &FBO
微小的鱼的博客
06-29 1256
介绍FBO，展开说明了相关进阶的RTT，与调试手段MRT等等相关的知识
离屏渲染&图形渲染的流程
Z1591090的博客
09-01 623
图形渲染的流程 iOS图形渲染的技术栈 APP通过Core Graphics ,Core Animation ,Core Image 等框架进行可视化的绘制，这些框架相互依赖，并通过OpenGL ES /Metal 调度GPU进行视图的渲染最终显示在屏幕上。 UIKit 1.UIKitk框架提供一系列的Class(类)来建立和管理iPhone OS应用程序的用户界面( UI )接口、应用程序对象、事件控制、绘图模型、窗口、视图和用于控制触摸屏等的接口。 2.开发者一般直接使用UIKit进行视图的布局和对用
OpenGL之深入解析屏幕成像和渲染原理
╰つ栺尖篴夢ゞ
04-10 614
PU 和 GPU 因为设计之初需求就不一样，所以它们的组成不同，在计算机中的分工也不同。可以看到，GPU 有更多的 ALU，而 CPU 有 Control 单元和 Cache 单元，普通的业务代码因为逻辑复杂，数据类型复杂，跳转复杂，依赖性高等，就更适合 CPU 来做。而 GPU 不擅长处理这些复杂的逻辑，它更擅长处理单一的运算，大量的算术逻辑单元可以保证做到真正的高并发，所以大量的计算任务是适合它的工作，就比如 GLSL 代码。
Android OpenGLES2.0（十二）——FBO离屏渲染
u010029439的博客
09-15 444
Android OpenGLES2.0（十二）——FBO离屏渲染 2016年12月24日 18:36:06湖广午王阅读数 18952更多 分类专栏：Android 午王OpenGLESAndroid OpenGLES 版权声明：本文为博主原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接和本声明。 本文链接：https://blog.csdn.net/ju...
Android OpenGL ES 二 、 FBO 离屏渲染
10-05 3074
1. 什么是FBO 2. FBO还需相关对象来辅佐，Shader；原纹理texture；输出纹理texture（fbo纹理） 2.1 如何创建 FBO private int createFbo(int width, int height) { int[] texture = new int[1]; int[] fbo = new int[1]; //创建FBO GLES20.glGenFrameb...
【OpenGL ES】离屏渲染
03-30
本资源使用 OpenGL ES 的 FBO 技术实现离屏渲染，使用 ImageView 显示离屏渲染后的图片（将原图片变灰）。博客见：https://zhyan8.blog.csdn.net/article/details/123749012
OpenGL实现离屏渲染(Offscreen Render),
12-30
离屏渲染（Offscreen Rendering）是OpenGL中的一个重要技术，它允许我们在屏幕之外的纹理或帧缓冲区进行渲染操作，然后将结果用于后续的图形处理或者保存为图像文件。这个初级的OpenGL程序Demo就是围绕离屏渲染展开...
OpenglES离屏渲染 C++ demo
03-18
OpenGL ES离屏渲染是移动设备和嵌入式系统中图形处理的一种关键技术，它允许开发者在屏幕上不可见的纹理或帧缓冲上执行渲染操作。在这个"OpenglES离屏渲染 C++ demo"中，作者展示了如何利用OpenGL ES进行离屏渲染，...
NDK调用OpenGL使用Camera2进行相机黑白滤镜预览（FBO离屏渲染）
01-05
FBO（Frame Buffer Object）是OpenGL的一个特性，它允许开发者在GPU上创建离屏渲染的目标。在这个场景中，NDK调用OpenGL与Camera2 API结合，实现了一个具有黑白滤镜的相机预览效果。 首先，我们来理解Camera2 API。...
【C++】拆分详解 - string类
bubble_shadow的博客
09-23 1033
string类的文档介绍注：此处及下文部分，蓝色下划线标识文本均为超链接，点击即可跳转字符串是表示字符序列的类标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作单字节字符字符串的设计特性。string类是使用char(即作为它的字符类型，使用它的默认char_traits和分配器类型(关于模板的更多信息，请参阅basic_string)。
pyqt瀑布流布局
weixin_54217201的博客
09-21 504
最近研究瀑布流布局，发现都是收费的，所以只能自己写算法写布局。所以啥都不说直接上代码。
189. 轮转数组（C++）
weixin_45813121的博客
09-25 449
给定一个整数数组nums，将数组中的元素向右轮转k个位置，其中k是非负数。
c++ 使用 Graham 扫描的凸包（Convex Hull using Graham Scan）
csdn_aspnet的专栏
09-26 1086
对于剩余的点，我们跟踪最近的三个点，并找到它们形成的角度。如果这些点的方向（按相同顺序考虑它们）不是逆时针的，我们丢弃 c，否则我们保留它。因此，第六步逐个处理点需要 O(n) 时间，假设堆栈操作需要 O(1) 时间。总体复杂度为 O(n) + O(nLogn) + O(n) + O(n)，即 O(nLogn)。在每个步骤中，算法都会检查添加到凸包中的最后两个点是否形成右转。格雷厄姆扫描算法是一种简单而有效的算法，用于计算一组点的凸包。凸包用于各种计算几何算法，例如查找最近的点对和计算一组点的直径。
求n的阶乘的相反数（c语言）
最新发布
scy2429828663的博客
09-26 394
【代码】求n的阶乘的相反数（c语言）
opengles 离屏渲染 零拷贝
08-14
OpenGLES是一种图形处理API，用于在移动设备上进行3D图形渲染。离屏渲染是指将渲染结果不直接显示在屏幕上，而是存储在离屏缓冲区中。离屏渲染可以用于实现一些特殊效果，例如阴影、反射等。 离屏渲染与传统的屏幕渲染不同，它在内存中创建一个与屏幕大小相同的缓冲区，并将渲染结果存储在其中。通过离屏渲染，开发者可以对渲染结果进行处理和修改，然后再将最终的结果显示在屏幕上。这种方式可以提高图形处理的效率和灵活性。 零拷贝指的是在数据传输过程中避免不必要的数据复制操作，从而提高数据传输的效率。在图形渲染中，数据复制操作可能会导致性能下降。零拷贝技术通过直接使用数据的引用或者共享内存的方式，避免了数据的复制，从而提高了渲染的效率。 在OpenGLES中，离屏渲染可以与零拷贝技术结合使用，以进一步优化渲染性能。通过离屏渲染，可以将渲染结果存储在离屏缓冲区中，然后通过零拷贝的方式将结果直接传递给其他处理器或者存储设备，避免了不必要的数据复制，提高了数据传输的效率。 综上所述，OpenGLES离屏渲染与零拷贝技术可以相互结合，提高图形渲染的效率和灵活性，并且减少数据复制操作，提升数据传输的效率。这些技术在移动设备上的图形处理中有着广泛的应用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值