opengles之VBO和FBO的结合使用

最新推荐文章于 2024-02-29 16:40:32 发布
最新推荐文章于 2024-02-29 16:40:32 发布
阅读量1.3k 收藏 2
点赞数
分类专栏： opengles_C++_基础_学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hb707934728/article/details/72380153
版权

FBO的理论详见:http://blog.csdn.net/xiajun07061225/article/details/7283929/


FBO的创建:


class   FrameBufferId
{
public:
	FrameBufferId()
	{
		_width = 0;
		_height = 0;
		_FBOID = 0;
		_DEPTHID = 0;
	}
public:
	unsigned    _width;
	unsigned    _height;
	unsigned    _FBOID;
	unsigned    _DEPTHID;
public:
	/**
	*   创建一个缓冲区对象
	*/
	void    create(int width, int height)
	{
		_width = width;
		_height = height;

		//创建一个帧缓冲对象 第一个参数表示要创建的帧缓存的数目
		//第二个参数是保存创建的FBO的ID
		glGenFramebuffers(1, &_FBOID);
		//绑定
		glBindFramebuffer(GL_FRAMEBUFFER, _FBOID);

		//创建一个深度缓存
		glGenRenderbuffers(1, &_DEPTHID);
		//绑定
		glBindRenderbuffer(GL_RENDERBUFFER, _DEPTHID);
		//分配指定的内存空间：分配一个_width*_height的深度缓冲区 第二个参数为GL_DEPTH_COMPONENT16,是
		//指定我们的空间用来保存深度值,除此之外还可以保存GL_RGB/GL_RFBA或者模板缓存的信息,具体见定义

		//第一个参数必须是GL_RENDERBUFFER 第二个参数是可以渲染的颜色格式,可渲染的深度格式,或者可渲染的模板格式
		//第三个和第四个是以像素为单位指定数据所要占用内存的大小
		glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, _width, _height);
		//把深度缓存与FBO对象绑定在一起
		glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, _DEPTHID);

		//解除绑定
		glBindFramebuffer(GL_FRAMEBUFFER, 0);
	}

	/**
	*   使用对象
	*/
	void    begin(unsigned texId)
	{
		glBindFramebuffer(GL_FRAMEBUFFER, _FBOID);
		//把2D纹理图像关联到FBO   第一个参数必须是GL_FRAMEBUFFER 第二个参数是关联纹理图像的关联点
		//第三个参数一般都是GL_TEXTURE_2D,第四个参数是纹理对象的ID号,最后一个参数是要被关联的纹理的mipmap等级
		glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texId, 0);
	}
	/**
	*   使用完，回复状态
	*/
	void    end()
	{
		glBindFramebuffer(GL_FRAMEBUFFER, 0);
	}
};

FBO的完整使用案例 

#pragma once

#include "CELLWinApp.hpp"

//顶点结构体
struct Vertex
{
	float x, y, z;//顶点位置信息
	float u, v;//顶点纹理纹理坐标
	float r, g, b, a;//顶点颜色信息
};

//6个面共12个三角形
Vertex g_cubeVertices[] =
{
	// 第一个三角形
	{ -1.0f, -1.0f, 1.0f, 0, 1, 1.0f, 1.0f, 1.0f, 1.0f },
	{ 1.0f, -1.0f, 1.0f, 1, 1, 1.0f, 1.0f, 1.0f, 1.0f },
	{ 1.0f, 1.0f, 1.0f, 1, 0, 1.0f, 1.0f, 1.0f, 1.0f },

	{ -1.0f, -1.0f, 1.0f, 0, 1, 1.0f, 1.0f, 1.0f, 1.0f },
	{ 1.0f, 1.0f, 1.0f, 1, 0, 1.0f, 1.0f, 1.0f, 1.0f },
	{ -1.0f, 1.0f, 1.0f, 0, 0, 1.0f, 1.0f, 1.0f, 1.0f },
	//
	{ -1.0f, -1.0f, -1.0f, 0, 1, 1.0f, 0.0f, 0.0f, 1.0f },
	{ -1.0f, 1.0f, -1.0f, 1, 1, 1.0f, 0.0f, 0.0f, 1.0f },
	{ 1.0f, 1.0f, -1.0f, 1, 0, 1.0f, 0.0f, 0.0f, 1.0f },

	{ -1.0f, -1.0f, -1.0f, 0, 1, 1.0f, 0.0f, 0.0f, 1.0f },
	{ 1.0f, 1.0f, -1.0f, 1, 0, 1.0f, 0.0f, 0.0f, 1.0f },
	{ 1.0f, -1.0f, -1.0f, 0, 0, 1.0f, 0.0f, 0.0f, 1.0f },

	//
	{ -1.0f, 1.0f, -1.0f, 0, 1, 0.0f, 1.0f, 0.0f, 1.0f },
	{ -1.0f, 1.0f, 1.0f, 1, 1, 0.0f, 1.0f, 0.0f, 1.0f },
	{ 1.0f, 1.0f, 1.0f, 1, 0, 0.0f, 1.0f, 0.0f, 1.0f },

	{ -1.0f, 1.0f, -1.0f, 0, 1, 0.0f, 1.0f, 0.0f, 1.0f },
	{ 1.0f, 1.0f, 1.0f, 1, 0, 0.0f, 1.0f, 0.0f, 1.0f },
	{ 1.0f, 1.0f, -1.0f, 0, 0, 0.0f, 1.0f, 0.0f, 1.0f },

	//
	{ -1.0f, -1.0f, -1.0f, 0, 1, 0.0f, 1.0f, 0.0f, 1.0f },
	{ 1.0f, -1.0f, -1.0f, 1, 1, 0.0f, 1.0f, 0.0f, 1.0f },
	{ 1.0f, -1.0f, 1.0f, 1, 0, 0.0f, 1.0f, 0.0f, 1.0f },

	{ -1.0f, -1.0f, -1.0f, 0, 1, 0.0f, 1.0f, 0.0f, 1.0f },
	{ 1.0f, -1.0f, 1.0f, 1, 0, 0.0f, 1.0f, 0.0f, 1.0f },
	{ -1.0f, -1.0f, 1.0f, 0, 0, 0.0f, 1.0f, 0.0f, 1.0f },

	// Quad 4
	{ 1.0f, -1.0f, -1.0f, 0, 1, 0.0f, 0.0f, 1.0f, 1.0f },
	{ 1.0f, 1.0f, -1.0f, 1, 1, 0.0f, 0.0f, 1.0f, 1.0f },
	{ 1.0f, 1.0f, 1.0f, 1, 0, 0.0f, 0.0f, 1.0f, 1.0f },

	{ 1.0f, -1.0f, -1.0f, 0, 1, 0.0f, 0.0f, 1.0f, 1.0f },
	{ 1.0f, 1.0f, 1.0f, 1, 0, 0.0f, 0.0f, 1.0f, 1.0f },
	{ 1.0f, -1.0f, 1.0f, 0, 0, 0.0f, 0.0f, 1.0f, 1.0f },

	//
	{ -1.0f, -1.0f, -1.0f, 0, 1, 0.0f, 0.0f, 1.0f, 1.0f },
	{ -1.0f, -1.0f, 1.0f, 1, 1, 0.0f, 0.0f, 1.0f, 1.0f },
	{ -1.0f, 1.0f, 1.0f, 1, 0, 0.0f, 0.0f, 1.0f, 1.0f },

	{ -1.0f, -1.0f, -1.0f, 0, 1, 0.0f, 0.0f, 1.0f, 1.0f },
	{ -1.0f, 1.0f, 1.0f, 1, 0, 0.0f, 0.0f, 1.0f, 1.0f },
	{ -1.0f, 1.0f, -1.0f, 0, 0, 0.0f, 0.0f, 1.0f, 1.0f }
};


class   FrameBufferId
{
public:
	FrameBufferId()
	{
		_width = 0;
		_height = 0;
		_FBOID = 0;
		_DEPTHID = 0;
	}
public:
	unsigned    _width;
	unsigned    _height;
	unsigned    _FBOID;
	unsigned    _DEPTHID;
public:
	/**
	*   创建一个缓冲区对象
	*/
	void    create(int width, int height)
	{
		_width = width;
		_height = height;

		//创建一个帧缓冲对象 第一个参数表示要创建的帧缓存的数目
		//第二个参数是保存创建的FBO的ID
		glGenFramebuffers(1, &_FBOID);
		//绑定
		glBindFramebuffer(GL_FRAMEBUFFER, _FBOID);

		//创建一个深度缓存
		glGenRenderbuffers(1, &_DEPTHID);
		//绑定
		glBindRenderbuffer(GL_RENDERBUFFER, _DEPTHID);
		//分配指定的内存空间：分配一个_width*_height的深度缓冲区 第二个参数为GL_DEPTH_COMPONENT16,是
		//指定我们的空间用来保存深度值,除此之外还可以保存GL_RGB/GL_RFBA或者模板缓存的信息,具体见定义

		//第一个参数必须是GL_RENDERBUFFER 第二个参数是可以渲染的颜色格式,可渲染的深度格式,或者可渲染的模板格式
		//第三个和第四个是以像素为单位指定数据所要占用内存的大小
		glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, _width, _height);
		//把深度缓存与FBO对象绑定在一起
		glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, _DEPTHID);

		//解除绑定
		glBindFramebuffer(GL_FRAMEBUFFER, 0);
	}

	/**
	*   使用对象
	*/
	void    begin(unsigned texId)
	{
		glBindFramebuffer(GL_FRAMEBUFFER, _FBOID);
		//把2D纹理图像关联到FBO   第一个参数必须是GL_FRAMEBUFFER 第二个参数是关联纹理图像的关联点
		//第三个参数一般都是GL_TEXTURE_2D,第四个参数是纹理对象的ID号,最后一个参数是要被关联的纹理的mipmap等级
		glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texId, 0);
	}
	/**
	*   使用完，回复状态
	*/
	void    end()
	{
		glBindFramebuffer(GL_FRAMEBUFFER, 0);
	}
};

class   OffscreenApp :public CELLWinApp
{
public:
	PROGRAM_P2_T2_C3    _shader;
	unsigned            _textureId;

	//! 顶点缓冲区
	unsigned            _vertexId;
	//! 创建一个FBO FameBufferObject对象
	FrameBufferId       _fbo;
	//! 纹理对象
	unsigned            _dynamicTexture;
public:
	OffscreenApp()
	{
		_textureId = -1;
	}
public:

	/**
	*   创建一个文理函数
	*/
	unsigned    createTexture(int width, int height, unsigned inteFmt, unsigned dataFmt, void* data)
	{
		unsigned    texId = 0;
		/**
		*   产生一个纹理Id,可以认为是纹理句柄，后面的操作将书用这个纹理id
		*/
		glGenTextures(1, &texId);

		/**
		*   使用这个纹理id,或者叫绑定(关联)
		*/
		glBindTexture(GL_TEXTURE_2D, texId);
		/**
		*   指定纹理的放大,缩小滤波，使用线性方式，即当图片放大的时候插值方式
		*/
		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);
		/**
		*   将图片的rgb数据上传给opengl.
		*/
		glTexImage2D(
			GL_TEXTURE_2D,      //! 指定是二维图片
			0,                  //! 指定为第一级别，纹理可以做mipmap,即lod,离近的就采用级别大的，远则使用较小的纹理
			inteFmt,            //! 纹理的使用的存储格式
			width,              //! 宽度，老一点的显卡，不支持不规则的纹理，即宽度和高度不是2^n。
			height,             //! 宽度，老一点的显卡，不支持不规则的纹理，即宽度和高度不是2^n。
			0,                  //! 是否的边
			dataFmt,            //! 数据的格式
			GL_UNSIGNED_BYTE,   //! 数据是8bit数据
			data
			);
		return  texId;
	}
	//! 重写初始化函数
	virtual void    onInit()
	{
		_shader.initialize();
		loadTexture();
		glEnable(GL_DEPTH_TEST);
		//! 创建顶点缓冲区
		glGenBuffers(1, &_vertexId);
		glBindBuffer(GL_ARRAY_BUFFER, _vertexId);//绑定
		//将顶点数据上传至显卡内存
		glBufferData(GL_ARRAY_BUFFER, sizeof(g_cubeVertices), g_cubeVertices, GL_STATIC_DRAW);
		//解除绑定
		glBindBuffer(GL_ARRAY_BUFFER, 0);

		//! 初始化FBO
		_fbo.create(_winWidth, _winHeight);

		_dynamicTexture = createTexture(_fbo._width, _fbo._height, GL_RGBA, GL_RGBA, 0);
	}
	virtual void    loadTexture()
	{
		//1 获取图片格式
		FREE_IMAGE_FORMAT fifmt = FreeImage_GetFileType("Debug/data/image/smoke.tga", 0);

		//2 加载图片
		FIBITMAP    *dib = FreeImage_Load(fifmt, "Debug/data/image/smoke.tga", 0);

		//3 转化为rgb 24色
		dib = FreeImage_ConvertTo24Bits(dib);

		//4 获取数据指针
		BYTE    *pixels = (BYTE*)FreeImage_GetBits(dib);

		int     width = FreeImage_GetWidth(dib);
		int     height = FreeImage_GetHeight(dib);

		_textureId = createTexture(width, height, GL_RGB, GL_RGB, pixels);
		/**
		*   释放内存
		*/
		FreeImage_Unload(dib);
	}


	void    drawCube(int viewW, int viewH)
	{
		static  float x = 0;

		glBindBuffer(GL_ARRAY_BUFFER, _vertexId);
		_shader.begin();
		{
			glUniform1i(_shader._texture, 0);
			CELL::matrix4   matProj = CELL::perspective(45.0f, float(viewW) / float(viewH), 0.1f, 100.0f);

			CELL::matrix4   model(1);
			model.translate(0.0f, 0.0f, -10.0f);
			CELL::matrix4   matRot(1);
			matRot.rotateYXZ(x, x, x);

			x += 1.0f;

			CELL::matrix4   mvp = matProj *  model * (matRot);

			glUniformMatrix4fv(_shader._MVP, 1, false, mvp.data());

			glVertexAttribPointer(_shader._positionAttr, 3, GL_FLOAT, false, sizeof(Vertex), 0);
			glVertexAttribPointer(_shader._uvAttr, 2, GL_FLOAT, false, sizeof(Vertex), (void*)12);
			glVertexAttribPointer(_shader._colorAttr, 4, GL_FLOAT, false, sizeof(Vertex), (void*)20);

			glDrawArrays(GL_TRIANGLES, 0, sizeof(g_cubeVertices) / sizeof(g_cubeVertices[0]));
		}
		_shader.end();
		glBindBuffer(GL_ARRAY_BUFFER, 0);
	}

	virtual void    render()
	{
		_fbo.begin(_dynamicTexture);
		{
			glClearColor(1, 1, 1, 1);
			glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
			glViewport(0, 0, _fbo._width, _fbo._height);
			glBindTexture(GL_TEXTURE_2D, _textureId);
			drawCube(_fbo._width, _fbo._height);
		}
		_fbo.end();


		glClearColor(0, 0, 0, 1);
		glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);

		glViewport(0, 0, _winWidth, _winHeight);

		//glBindTexture(GL_TEXTURE_2D,_textureId);
		glBindTexture(GL_TEXTURE_2D, _dynamicTexture);
		//! 绘制到窗口上
		drawCube(_winWidth, _winHeight);
		eglSwapBuffers(_display, _surface);

	}
};

// 完整案例下载地址：http://download.csdn.net/detail/hb707934728/9844615


hb707934728
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
OpenGL ES 3.0 开发（五）：FBO 离屏渲染
字节流动
08-08 3万+
该原创文章首发于微信公众号：字节流动 什么是 FBO FBO（Frame Buffer Object）即帧缓冲区对象，实际上是一个可添加缓冲区的容器，可以为其添加纹理或渲染缓冲区对象（RBO）。 FBO 本身不能用于渲染，只有添加了纹理或者渲染缓冲区之后才能作为渲染目标，它仅且提供了 3 个附着（Attachment），分别是颜色附着、深度附着和模板附着。 RBO（Render Buffer ...
【OpenGL ES】EGL+FBO离屏渲染
04-01
本资源实现了将彩色图片转换为灰色，并且使用 ImageView 显示转换后的图片。案例使用 EGL 代替 GLSurfaceView 生成 OpenGL ES 的渲染环境，并结合FBO实现离屏渲染，将渲染后的图片显示在 ImageView 上。博客见：https://zhyan8.blog.csdn.net/article/details/123887797
【OpenGL学习】使用VBO和FBO
weixin_34240520的博客
08-22 156
一、概念 这两个都是Buffer Object，说白了就是一块存储区域。 VBO（顶点缓冲对像）是用来加快渲染的速度，主要思想是在显卡中分配一块显存空间，然后一次性将CPU中的数据传输过来，这样显示的时候就会直接输出到显示器，这样做的动机是因为CPU到GPU传输的瓶颈。 FBO（帧缓冲对像）是用来改变当前帧缓存的输出位置，默认的帧缓存会直接输出到显示器，而有的时候不需要输出到显示器，...
第六章 OpenGL ES 基础-FBO、VBO理解与运用
最新发布
u012836015的博客
02-29 461
在 OpenGL 中，VBO 是 Vertex Buffer Object 的缩写，用于存储顶点数据（如位置、颜色、法线等）在显存中的缓冲区对象。使用 VBO 可以提高性能并减少 CPU 到 GPU 之间的数据传输。
1.OpenGLES——FBO方式的离屏渲染
liuyizhou95的博客
04-13 5236
参考 https://blog.csdn.net/u011371324/article/details/78011211 书写本文的初衷是为了自我学习 出现背景 明确两个概念 窗口系统默认帧缓冲 应用程序帧缓冲 FBO(frame buffer object),帧缓冲区对象，在Android中，绘制三角形一般都是直接重写GLSurfaceVi...
OpenGLES实战应用FBO
Flying_Motor的博客
12-21 1425
OpenGLES实战应用FBO
opengles2.0 帧缓存对象（FBO)
12-13 1万+
帧缓存对象（fbo）主要是用于做渲染到纹理。 opengles2.0渲染到纹理的方法有三种：     第一，使用glCopyTexImage2D或者glCopyTexSubImage2D，这两个函数，复制framebuffer中的         像素到纹理缓存里面，但这两个函数性能比较低下，并且要求纹理的尺寸必须小于等于         framebuffer的尺寸。
opengles之vbo
05-16
opengles之vbo顶点缓冲
Android平台OpenGLES生成使用Mipmap纹理
12-08
该案例代码为Android 平台OpenGL ES实现举例，有两个作用： ...2、使用 OpenGLES 生成与使用Mipmap纹理，构建远处模糊，近处清晰的效果。 具体案例文章讲解请见： https://xiaxl.blog.csdn.net/article/details/8873106
Android OpenGL ES 3.0 VBO VAO应用
01-26
Android OpenGL ES 3.0中Vertex Buffer Object(VBO)和Vertex Array Object(VAO)的应用。
【OpenGL ES】离屏渲染
03-30
本资源使用 OpenGL ES 的 FBO 技术实现离屏渲染，使用 ImageView 显示离屏渲染后的图片（将原图片变灰）。博客见：https://zhyan8.blog.csdn.net/article/details/123749012
Qt开发高级进阶：初探qt + opengl
tanmx219的博客
06-11 3462
Qt 官方提供了好几个OpenGL的例程，我使用的qt5.15.0版，随便搜索了一下，发现有下面这几个例程，如图，随便点击了其中一个例程boxes，配置后rebuild了一下，项目地址在Qt的源码中，C:\Qt\qt5\Examples\Qt-5.15.0\widgets\graphicsview\boxes但发现总是报错， "This example requires Qt to be configured with -opengl desktop" 于是打开boxes.pro看了一
OpenGLES FBO-BlitFramebuffer MSAA 抗锯齿的实现
我是一只小小小小鸟
09-19 4372
OpenGLES FBO-BlitFramebuffer MSAA 抗锯齿的实现不太好用的FBO-Blit MSAA昨天写了一篇 OpenGLES 在几种情况下的 MSAA（Multisample Anti-aliasing）抗锯齿，其中唯独没有提到一种利用 FBO-Blit 的抗锯齿方法，那是因为我没能实现。我对 OpenGL MSAA 的大部分代码的了解都是根据 关于支持多重采样的FBO和Tex
在Qt中使用OpenGL（八）
Ninsun的博客
01-28 6818
使用Qt中的OpenGL，绘制一个地球
QT+Opengl ES2.0显示立方体
御伽草子的博客
10-19 6658
好嘞，这一次是一个不错的突破。前几次的文章中已经将点云用QT结合opengl显示出来了，但是所用的opengl为固定管线绘制方式。这种方式效率低下，比方说你有一块100W的点云，那么每次paint的时候都要循环绘制100W个点在屏幕上，这也就是为什么传统opengl显示800W的点云就开始卡B了。     笔者寄希望于QT中的OpenglES2.0，这种采用顶点缓存和索引缓存的绘制方式大大提升了
OpenGLES（三）VAO、VBO、EBO
麦芽的博客
01-14 355
OpengGLES VAO、VBO、EBO 的使用
Android OpenGLES2.0（十二）——FBO离屏渲染
热门推荐
湖广午王
12-24 3万+
之前的博客我们所做的示例都是直接渲染到屏幕上的，如果我们并不需要渲染到屏幕上，也就是离屏渲染，该怎么做呢？FBO离屏渲染是一个很好的选择。在这篇博客中，我们将以渲染摄像头数据为例，使用FBO进行离屏渲染。 关于FBO离屏渲染 所谓的FBO就是Frame Buffer Object。之前我们使用OpenGLES渲染，都是直接渲染到屏幕上，FBO可以让我们的渲染不渲染到屏幕上，而是渲染到离屏B
Android OpenGL ES 总结之FBO
m0_37884055的博客
10-13 113
别人都说计算机图形学是程序员的浪漫，但是作为一个天赋不高的普通码农，只能一遍又一遍的硬啃具体实现，这东西太麻烦了，单单只是绘制一个三角形，就要写一堆代码，然后不写又记不住具体步骤。因此，你首先不是在默认的帧缓冲中渲染原始纹理，而是在FBO中渲染原始纹理，这样结果就保存在fboTextureId中。因为工作上用到了OpenGL ES，不得不从头开始学OpenGL，虽说之前有看过图形学相关的，但是理论太抽象了，还是要实践。总的来说，帧缓冲对象允许你将渲染的结果重定向到纹理，而不是直接输出到屏幕。
Android OpenGL ES 3.0 FBO 离屏渲染
风的轨迹
11-24 1397
FBO：Frame Buffer Object，即帧缓冲区对象，实际上是一个可添加缓冲区的容器，可以为其添加纹理和缓冲区对象。FBO本身不能用于渲染，只有添加了纹理或者渲染缓冲区之后才能作为渲染目标，仅提供三种附着，颜色附着、深度附着、模板附着。
学习OpenGL ES之透视和正交投影
05-24
OpenGL ES 中的投影矩阵可以使用透视投影和正交投影两种方式进行设置。 透视投影是一种模拟人眼观察物体的方式，近处的物体看起来比远处的物体大，而且在远处的物体看起来比在近处的物体更小。在 OpenGL ES 中，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值