OpenGL的多重渲染目标（Multiple Render Targets）技术（Qt下实现）

最新推荐文章于 2024-04-24 12:00:59 发布
最新推荐文章于 2024-04-24 12:00:59 发布
阅读量2.1k 收藏 2
点赞数 2
分类专栏： OpenGL 文章标签： qt 开发语言 c++ opengl
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/imv123/article/details/123117672
版权

一直没有找到一个Qt下的MRT的简单实例，通过查阅资料，完成如下例子。
重要参考：https://www.jianshu.com/p/da82d3616cca
欢迎学习交流：https://github.com/986247404/OpenGL-MRT-QT/tree/main
多重渲染目标允许程序同时渲染到多个颜色缓冲，向不同的颜色缓冲中送入渲染结果的不同方面（如不同RGBA 色彩通道的值、深度值等）。不少高级特效渲染时需要使用多重渲染目标技术，例如延迟着色、屏幕空间环境光遮蔽等。下面介绍使用多重渲染目标技术的基本步骤。
（1）首先需要创建一个自定义的帧缓冲，并绑定到此帧缓冲。
（2）接着可以创建并初始化一批纹理，总数量等于要输出的不同渲染结果方面的数量，并且不能超过系统的最大限制数。
（3）然后将这一批纹理一一连接到自定义帧缓冲中的不同颜色附件中。
（4）接着在绘制时正常绘制前调用glDrawBuffers 方法设置要输出的颜色附件。
（5）最后在片元着色器中定义多个输出变量一一对应到要输出的颜色附件。
给FBO添加了4个颜色附件，效果如下：
请添加图片描述
代码如下：
头文件

#ifndef GEOMETRYSHADER_H
#define GEOMETRYSHADER_H
#include <QtWidgets/QWidget>
#include <QOpenGLWidget>
#include <QOpenGLFunctions_4_5_Core>
#include <QOpenGLVertexArrayObject>
#include <QOpenGLBuffer>
#include <QOpenGLTexture>
#include <QOpenGLShader>
#include <QOpenGLShaderProgram>
#include <QTime>
#include <QDebug>
#include <QImage>
#include <QMatrix4x4>
#include <iostream>
#include <vector>
#include <string>
constexpr int ATTACHMENT_NUM = 4;
class CGeometryShader : public QOpenGLWidget, protected QOpenGLFunctions_4_5_Core
{
	Q_OBJECT
public:
	CGeometryShader(QWidget *parent = Q_NULLPTR);
	~CGeometryShader();
	void initFBO();
protected:
	void initializeGL();
	void paintGL();
	void resizeGL(int iWidth, int iHeight);
private:
	GLuint				  VBO;
	GLuint				  VAO;
	GLuint				  EBO;
	GLuint				  m_texture[1];
	QOpenGLShaderProgram* m_pProgram;
	GLuint				  m_fVBO;
	GLuint				  m_fVAO;
	GLuint				  FBO;
	GLuint				  RBO;	
	GLuint				  m_textureFBO[ATTACHMENT_NUM];
	QOpenGLShaderProgram* m_pProgramFBO;
	int					  m_iWidth;
	int					  m_iHeight;
	const GLenum attachments[ATTACHMENT_NUM] = {
			GL_COLOR_ATTACHMENT0,
			GL_COLOR_ATTACHMENT1,
			GL_COLOR_ATTACHMENT2,
			GL_COLOR_ATTACHMENT3
	};
	QImage				  m_image;

};
#endif  //GEOMETRYSHADER_H

代码文件：

#include "GeometryShader.h"

CGeometryShader::CGeometryShader(QWidget *parent)
	: QOpenGLWidget(parent)
	, VBO(0)
	, VAO(0)
	, EBO(0)
	, m_texture{ 0 }
	, m_pProgram(new QOpenGLShaderProgram)
	, m_fVBO(0)
	, m_fVAO(0)
	, FBO(0)
	, RBO(0)
	, m_textureFBO{ 0 }
	, m_pProgramFBO(new QOpenGLShaderProgram)
	, m_iWidth(0)
	, m_iHeight(0)
{
	m_image = QImage("img/1.jpg").convertToFormat(QImage::Format_RGBA8888);
	m_iWidth = m_image.width();
	m_iHeight = m_image.height();
	this->resize(m_iWidth, m_iHeight);
}

CGeometryShader::~CGeometryShader()
{
	glDeleteVertexArrays(1, &VAO);
	glDeleteVertexArrays(1, &m_fVAO);
	glDeleteBuffers(1, &VBO);
	glDeleteBuffers(1, &EBO);
	glDeleteBuffers(1, &m_fVBO);
	glDeleteBuffers(1, &FBO);
	glDeleteBuffers(1, &RBO);
	glDeleteTextures(1, m_texture);
	glDeleteTextures(ATTACHMENT_NUM, m_textureFBO);

	if (m_pProgram)
		delete m_pProgram;
	m_pProgram = nullptr;	
	if (m_pProgramFBO)
		delete m_pProgramFBO;
	m_pProgramFBO = nullptr;
}

void CGeometryShader::initFBO()
{
	// FBO
	glGenFramebuffers(1, &FBO);
	glBindFramebuffer(GL_FRAMEBUFFER, FBO);
	// RBO
	glGenRenderbuffers(1, &RBO);
	glBindRenderbuffer(GL_RENDERBUFFER, RBO);
	glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, m_iWidth, m_iHeight);
	glBindRenderbuffer(GL_RENDERBUFFER, 0);
	glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, RBO);
	// texture2D
	glGenTextures(ATTACHMENT_NUM, m_textureFBO);
	for (auto i = 0; i < ATTACHMENT_NUM; ++i)
	{
		glBindTexture(GL_TEXTURE_2D, m_textureFBO[i]);
		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_iWidth, m_iHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
		glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, attachments[i], GL_TEXTURE_2D, m_textureFBO[i], 0);
		glBindTexture(GL_TEXTURE_2D, 0);
	}
	//渲染到 4 个颜色附着上
	glDrawBuffers(ATTACHMENT_NUM, attachments);
	if (GL_FRAMEBUFFER_COMPLETE != glCheckFramebufferStatus(GL_FRAMEBUFFER))
		qDebug() << "GL_FRAMEBUFFER_COMPLETE ERROE !";
	glBindFramebuffer(GL_FRAMEBUFFER, 0);

	QOpenGLShader* m_vertexShader = new QOpenGLShader(QOpenGLShader::Vertex);//顶点着色器
	QOpenGLShader* m_fragmentShader = new QOpenGLShader(QOpenGLShader::Fragment);//片段着色器
	m_vertexShader->compileSourceFile("shader/1.vertex_GeometryShader_fbo.vert");
	m_fragmentShader->compileSourceFile("shader/1.fragment_GeometryShader_fbo.frag");
	m_pProgramFBO->addShader(m_vertexShader);
	m_pProgramFBO->addShader(m_fragmentShader);
	m_pProgramFBO->link();
	GLfloat vertices[] = {
		-1.0f,  1.0f, 0.0f, 1.0f, 0.0f, 1.0f,
		-1.0f, -1.0f, 0.0f, 1.0f, 0.0f, 0.0f,
		 1.0f, -1.0f, 0.0f, 1.0f, 1.0f, 0.0f,

		-1.0f,  1.0f, 0.0f, 1.0f, 0.0f, 1.0f,
		 1.0f, -1.0f, 0.0f, 1.0f, 1.0f, 0.0f,
		 1.0f,  1.0f, 0.0f, 1.0f, 1.0f, 1.0f
	};

	glGenVertexArrays(1, &m_fVAO);
	glBindVertexArray(m_fVAO);
	glGenBuffers(1, &m_fVBO);
	glBindBuffer(GL_ARRAY_BUFFER, m_fVBO);
	glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
	glEnableVertexAttribArray(0);
	glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (void*)0);
	glEnableVertexAttribArray(1);
	glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (void*)(4 * sizeof(float)));
	glBindBuffer(GL_ARRAY_BUFFER, 0);
	glBindVertexArray(0);

	m_pProgramFBO->bind();
	for (int i = 0; i < ATTACHMENT_NUM; ++i)
	{
		glActiveTexture(GL_TEXTURE0 + i);
		glBindTexture(GL_TEXTURE_2D, m_textureFBO[i]);
		QString texture = "s_Texture" + QString::number(i);
		QByteArray temp = texture.toLatin1(); 
		char*  index = temp.data();
		m_pProgramFBO->setUniformValue(index, i);
	}
	m_pProgramFBO->release();
}

void CGeometryShader::initializeGL()
{
	this->initializeOpenGLFunctions();

	QOpenGLShader* vertexShader = new QOpenGLShader(QOpenGLShader::Vertex);//顶点着色器
	QOpenGLShader* fragmentShader = new QOpenGLShader(QOpenGLShader::Fragment);//片段着色器
	vertexShader->compileSourceFile("shader/1.vertex_GeometryShader.vert");
	fragmentShader->compileSourceFile("shader/1.fragment_GeometryShader.frag");
	m_pProgram->addShader(vertexShader);
	m_pProgram->addShader(fragmentShader);
	m_pProgram->link();
	GLfloat vertices[] = {
		-1.0f, -1.0f, 0.0f, 1.0f, 0.0f, 0.0f,
		 1.0f, -1.0f, 0.0f, 1.0f, 1.0f, 0.0f,
		 1.0f,  1.0f, 0.0f, 1.0f, 1.0f, 1.0f,
		-1.0f,  1.0f, 0.0f, 1.0f, 0.0f, 1.0f,
	};
	GLuint indices[] = {
		0,1,2,
		0,2,3
	};
	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, 4, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (void*)0);
	glEnableVertexAttribArray(0);
	glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (void*)(4 * sizeof(float)));
	glEnableVertexAttribArray(1);
	glGenBuffers(1, &EBO);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
	glBindVertexArray(0);
	glBindBuffer(GL_ARRAY_BUFFER, 0);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

	glGenTextures(1, m_texture);
	glBindTexture(GL_TEXTURE_2D, m_texture[0]);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_iWidth, m_iHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
	glBindTexture(GL_TEXTURE_2D, 0);

	m_pProgram->bind();
	m_pProgram->setUniformValue("s_Texture", 0);
	m_pProgram->release();

	// FBO
	initFBO();
}

void CGeometryShader::paintGL()
{
	glBindFramebuffer(GL_FRAMEBUFFER, FBO);
	//glEnable(GL_DEPTH_TEST); 要关闭

	glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
	glViewport(0, 0, m_iWidth, m_iHeight);
	glClear(GL_COLOR_BUFFER_BIT);
	glDrawBuffers(ATTACHMENT_NUM, attachments);
	
	m_pProgram->bind();
	glActiveTexture(GL_TEXTURE0);
	glBindTexture(GL_TEXTURE_2D, m_texture[0]);
	glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, m_iWidth, m_iHeight, GL_RGBA, GL_UNSIGNED_BYTE, m_image.bits());
	glBindVertexArray(VAO);
	glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, NULL);//绘制
	glBindTexture(GL_TEXTURE_2D, 0);
	glBindVertexArray(0);
	m_pProgram->release();

	auto fb = context()->defaultFramebufferObject();
	glBindFramebuffer(GL_FRAMEBUFFER, fb);
	glViewport(0, 0, m_iWidth, m_iHeight);
	glClear(GL_COLOR_BUFFER_BIT);

	m_pProgramFBO->bind();
	glBindVertexArray(m_fVAO);
	for (int i = 0; i < ATTACHMENT_NUM; ++i)
	{
		glActiveTexture(GL_TEXTURE0 + i);
		glBindTexture(GL_TEXTURE_2D, m_textureFBO[i]);
	}
	glDrawArrays(GL_TRIANGLES, 0, 6);
	glBindTexture(GL_TEXTURE_2D, 0);
	m_pProgramFBO->release();

}

void CGeometryShader::resizeGL(int iWidth, int iHeight)
{
	glViewport(0, 0, iWidth, iHeight);
}

用到的shader：
1.vertex_GeometryShader.vert和1.vertex_GeometryShader_fbo.vert相同：

#version 450 core
layout(location = 0) in vec4 a_position;
layout(location = 1) in vec2 a_texCoord;
 
out vec2 v_texCoord;

void main()
{
	v_texCoord = a_texCoord;
	gl_Position = a_position;
}

1.fragment_GeometryShader_fbo.frag：

#version 450 core

in vec2 v_texCoord;
layout(location = 0) out vec4 outColor;
uniform sampler2D s_Texture0;
uniform sampler2D s_Texture1;
uniform sampler2D s_Texture2;
uniform sampler2D s_Texture3;
void main()
{
    if(v_texCoord.x < 0.5 && v_texCoord.y < 0.5)
    {
        outColor = texture(s_Texture0, v_texCoord);
    }
    else if(v_texCoord.x > 0.5 && v_texCoord.y < 0.5)
    {
        outColor = texture(s_Texture1, v_texCoord);
    }
    else if(v_texCoord.x < 0.5 && v_texCoord.y > 0.5)
    {
        outColor = texture(s_Texture2, v_texCoord);
    }
    else
    {
        outColor = texture(s_Texture3, v_texCoord);
    }
}

1.fragment_GeometryShader.frag：

#version 450 core
 
in vec2 v_texCoord; 
layout(location = 0) out vec4 outColor0; 
layout(location = 1) out vec4 outColor1; 
layout(location = 2) out vec4 outColor2; 
layout(location = 3) out vec4 outColor3; 
uniform sampler2D s_Texture; 
void main() 
{ 
    vec4 outputColor = texture(s_Texture, v_texCoord); 
    outColor0 = outputColor; 
    outColor1 = vec4(outputColor.r, 0.0, 0.0, 1.0); 
    outColor2 = vec4(0.0, outputColor.g, 0.0, 1.0); 
    outColor3 = vec4(0.0, 0.0, outputColor.b, 1.0); 
} ;
茜茜嘻茜茜
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Qt | 鼠标事件第四节
m0_45463480的博客
04-22 274
九、鼠标事件 1、Qt 使用 QMouseEvent 类来描述与鼠标有关的信息，比如鼠标的位置坐标，键是否被按下等，使用枚举类型 QEvent::Type描述与鼠标有关的事件，比如 QEvent::MouseButtonPress表示鼠标按下事件，QEvent::MouseMove表示鼠标移动事件等。 2、是否接收鼠标事件，最好明确的调用QEvent::ignore()和 QEvent::accept()函数。
Qt使用OpenGL进行多线程离屏渲染
QtCompany的博客
03-03 2771
使用OpenGL进行多线程离屏渲染
一篇搞懂OpenGL中的渲染器（Renderer）、纹理（Texture）和混合（Blending）
CodeWorld1999的博客
12-24 2720
OpenGL入门到入坟——学习笔记（四）
认识多渲染目标(Multiple Render Targets)技术
weixin_30709061的博客
12-01 824
首先，渲染到纹理是D3D中的一项高级技术。一方面，它很简单，另一方面它很强大并能产生很多特殊效果。 比如说发光效果，环境映射，阴影映射，景深效果，都可以通过它来实现。渲染到纹理只是渲染到表面的一个延伸。我们只需对得到的纹理图像进行后处理即可。首先，我们要创造一个纹理，并且做好一些防范措施。第二步我们就可以把适当的场景渲染到我们创建的纹理上了。然后，我们把这个纹理用在最后的渲染上。 GeFo...
OpenGL之FBO(Frame Buffer Object)和多次离屏渲染
What_can_you_do的博客
07-14 2713
OpenGL学习笔记
详解vue渲染函数render的使用
08-28
本篇文章主要介绍了vue渲染函数render的使用，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
DXT纹理压缩，Multiple Render Targets
蛰伏--当你不够强大时，就不要放弃努力
07-09 1153
游戏中对于3D物体表面细节的表现最重要的还是靠贴图来实现的，那么越是高分辨率越是真彩色的贴图自然表现力也是越强，但是同时带来的问题是所需占用的内存会成倍的上升，而节省内存这一点在目前的游戏中还是非常非常重要的。     所以各个平台上都在使用纹理压缩的技术，让纹理贴图在内存占用和显示效果能达到一个尽可能的平衡。在DirectX中，使用一种叫做DXT的纹理压缩技术，目前这种技术被大部分显卡所支持，通...
webgl 开发之 mrt(“Multiple Render Targets“（多重渲染目标）
huhuan123456的博客
07-06 530
需要注意的是，WebGL MRT在WebGL 2.0中是原生支持的，而在WebGL 1.0中，可以借助扩展（extension）来实现类似的功能。使用WebGL MRT技术，可以将片段着色器（fragment shader）的输出数据同时写入多个目标缓冲区（render buffer），例如颜色、法线、深度等，这些缓冲区可以是纹理或帧缓冲区。通过gl.drawBuffers方法，我们将多个渲染目标绑定到帧缓冲，然后在渲染操作中，片段着色器将将对应的数据写入到不同的渲染目标上。
UnityShader：MRT多重渲染
热门推荐
键盘春秋的博客
12-04 1万+
UnityShader：深度图获取，屏幕后期处理特效 中学习了如何使用unityshader处理摄像机画面，这次来看看多重渲染的使用。 有时候我们想同时获得一个画面的不同后期效果：比如需要同时显示深度图，RGB，像素化等，但是又不想进行多次处理浪费性能，这时候我们就需要多重渲染技术了，通过多重渲染技术，只需要一次就可以将我们想要处理的画面处理成我们需要的多种效果并输出。一、 多重渲染shader
分析OpenGL中renderbuffer和texture的区别和联系
行者cheng
08-11 366
分析OpenGL中renderbuffer和texture的区别和联系
渲染缓冲区对象 RBO
whl0071的专栏
05-15 280
渲染缓冲区对象 RBO
015_render_to_texture.zip_linux opengl_opengl texture_render to
09-14
render_to_texture using opengl
OpenGL实现离屏渲染(Offscreen Render),
12-30
这是一个初级的OpenGL程序Demo，实现了Offscreen Render，在VS下可以直接运行，拖动鼠标右键可以实现内正方体的转动，拖动鼠标左键可以实现外正方体的转动；适合初学OpenGL
opengl渲染到纹理技术
11-06
opengl渲染到纹理技术，RendertoaTexture很好的例子
vue渲染方式render和template的区别
10-15
主要介绍了vue渲染方式render和template的区别，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Qt 集成VTK
qthello
04-23 637
Qt的debug模式需要加载VTK的debug库，同样 release模式需要加载release库。不然会出现这个错误“QWidget: Must construct a QApplication before a QWidget”。4. 我们以显示一个stl文件为例。
【Qt踩坑】Qt项目嵌入Web踩坑记录--加载QtWebEngine模块的程序会出现崩溃
Monster_H7的博客
04-23 229
是一个环境变量设置，用于禁用 Qt WebEngine 的沙箱功能。Qt WebEngine 是 Qt 框架中用于处理 web 内容的模块，沙箱功能可以增强安全性，防止恶意代码对系统造成影响。但在某些情况下，可能由于特定需求或系统配置，需要禁用沙箱功能。设置这个环境变量为1就是告诉 Qt WebEngine 不要使用沙箱功能。
Qt中的 tableView 设置 二进制 十六进制 序号表头
最新发布
日常解决问题的记录。
04-24 371
因为QTableView的垂直表头并不支持使用委托来自定义。相反，你可以通过将自定义的QWidget作为QHeaderView的标签来实现这一目标。在这个示例中，我自定义了BinaryHeaderView类，继承自QHeaderView，重写了paintSection方法来绘制二进制序列。然后，我将这个自定义的垂直表头应用到了QTableView中。
Qt环境搭建
m0_64028711的博客
04-22 472
本文讲述了 QT 工具的下载安装以及环境变量的配置，并且了解了项目的创建以及项目代码的细节。
qt opengl多线程渲染
08-05
在Qt中使用OpenGL进行多线程渲染可以提高渲染效率和用户体验。下面是一个基本的示例，演示了如何在Qt中使用OpenGL进行多线程渲染： 1. 首先，在Qt中创建一个新的OpenGL窗口类，继承自QOpenGLWidget。 ```cppclass MyGLWidget : public QOpenGLWidget{ public: MyGLWidget(QWidget *parent = nullptr) : QOpenGLWidget(parent) {} protected: void initializeGL() override { // 初始化OpenGL环境 } void resizeGL(int w, int h) override { // 处理窗口大小变化事件 } void paintGL() override { // 执行OpenGL渲染操作 } }; ``` 2. 接下来，在主窗口类中创建一个新的线程，并在该线程中进行OpenGL渲染操作。 ```cppclass MainWindow : public QMainWindow{ public: MainWindow(QWidget *parent = nullptr) : QMainWindow(parent) { // 创建OpenGL窗口 m_glWidget = new MyGLWidget(this); setCentralWidget(m_glWidget); // 创建渲染线程 m_renderThread = new QThread(this); m_glWidget->moveToThread(m_renderThread); // 连接信号槽，触发渲染操作 connect(m_renderThread, &QThread::started, m_glWidget, &MyGLWidget::update); connect(m_glWidget, &MyGLWidget::frameSwapped, m_renderThread, &QThread::quit); connect(m_glWidget, &MyGLWidget::destroyed, m_renderThread, &QThread::quit); // 启动渲染线程 m_renderThread->start(); } private: MyGLWidget *m_glWidget; QThread *m_renderThread; }; ``` 在上述代码中，我们在主窗口类的构造函数中创建了一个OpenGL窗口，并将其移动到一个新的线程中。然后，我们连接了一些信号槽，以触发渲染操作，并在窗口销毁时停止渲染线程。 这样，我们就可以在Qt中使用OpenGL进行多线程渲染了。当启动应用程序时，渲染线程将开始执行OpenGL渲染操作，而主线程仍然可以响应用户交互事件。请注意，这只是一个简单的示例，你可能需要根据你的具体需求进行更多的代码调整和优化。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值