使用fbo离屏渲染绘制图片

【原文：http://m.blog.csdn.net/blog/zhouschina/8985593】

概要

在OpenGL的渲染管线中，几何数据和纹理通过一系列变换和测试，最终被渲染成屏幕上的二维像素。那些用于存储颜色值和测试结果的二维数组的几何被称为帧缓冲区（frame buffer）。这些二维数组按用途划分，可分为颜色缓冲区（color buffer），深度缓冲区（depth buffer），模版缓冲区（stencil buffer）和累加缓冲区（accumulation buffer）。当我们创建了一个可供OpenGL绘制用的窗体后，窗体系统会为我们生成一个默认的帧缓冲区，这个帧缓冲区完全是由窗体系统来管理的，且仅用于将渲染后的图像输出到窗口的显示区域。

 

然而，我们可以使用OpenGL提供的GL_EXT_framebuffer_object扩展功能来创建额外的帧缓冲区。GL_EXT_framebuffer_object扩展功能中，提出了帧缓冲区对象（framebuffer object，缩写为FBO，下文中将使用FBO来代表帧缓冲区对象）的概念，用于对帧缓冲区进行建模。这样一来，无论是窗体系统创建的帧缓冲区，还是用于屏外渲染的帧缓冲区，都是FBO的实例。有了FBO，程序员就可以重定向渲染目标到其他的存储空间，比如将渲染目标重定向到纹理空间，实现渲染到纹理功能（Render to Texture）。

 

上文提到过帧缓冲区中包含的二维数组按用途划分，可分为颜色缓冲区（color buffer），深度缓冲区（depth buffer），模版缓冲区（stencil buffer）和累加缓冲区（accumulation buffer）。FBO中也提供了与颜色缓冲区、深度缓冲区和模版缓冲区相对应的功能(注意，FBO没有提供与累加缓冲区对应的功能）。但是，这并不意味着FBO会直接为这些缓冲区分配空间。FBO只是为这些缓冲区提供一个或多个挂接点。我们需要分别为各个缓冲区创建对象，申请空间，然后挂接到相应的挂接点上。FBO提供的挂接点如下图所示。

可以看出，FBO提供了多个颜色缓冲区挂接点GL_COLOR_ATTACHMENT0_EXT ... GL_COLOR_ATTACHMENTn_EXT、一个深度缓冲区挂接点GL_DEPTH_ATTACHMENT_EXT和一个模板缓冲区挂接点GL_STENCIL_ATTACHMENT_EXT。颜色缓冲区挂接点的个数是因不同厂商和不同型号的显卡而异的。你可以通过GL_MAX_COLOR_ATTACHMENTS_EXT查询当前显卡所支持的颜色缓冲区挂接点的最大个数。FBO提供多个颜色缓冲区挂接点的用意是，允许程序员进行多目标渲染(使用GL_ARB_draw_buffers扩展功能)。

 

能够与FBO挂接的对象有两种，一种是纹理对象（texture object），另一种是渲染缓冲区对象（renderbuffer object）。纹理对象，就是我们平日为模型设置纹理贴图时使用的对象；而渲染缓冲区对象可以用作不具有纹理格式的缓冲区，如深度缓冲区和模板缓冲区。当然，渲染缓冲区对象也可以用来渲染场景。

 

前面提到过，窗体系统创建的帧缓冲区也有对应的FBO的实例。但是，这个FBO与其他通过手工创建的FBO相比有许多不同。第一，通过手工创建的FBO不能用于将渲染结果直接显示到窗口输出区，通过手工创建的FBO只能用于屏外渲染（Off-screen Rendering）；第二，窗体系统生成的FBO在创建的时候就拥有颜色缓冲区，深度缓冲区，模版缓冲区，且创建后就为这些缓冲区分配了空间。而手工创建的FBO需要手动为其添加各个缓冲区，并为其申请空间。窗体系统创建的FBO中的各个缓冲区对象不能与手动创建的FBO的挂接点挂接，反之亦然。

 

创建、绑定和删除一个FBO

我们可以使用glGenFramebuffersEXT()来向OpenGL申请一个或者多个闲置的FBO的ID。注意，就算成功地申请到了闲置的ID，OpenGL也不会马上为其创建实例。只用当调用glBindFramebufferEXT ()绑定FBO的时候OpenGL才会真正的创建一个FBO实例（这和其他glBind*函数极为相似）。在FBO被绑定之后，这个FBO就会被OpenGL当作当前的操作对象，后续的操作都被视为对被绑定的FBO进行的操作。窗体系统创建的FBO的ID默认为0。我们可以通过调用glDeleteFramebuffersEXT()函数来释放FBO的实例，如果要删除的FBO实例正在被使用，则OpenGL会自动绑定窗口系统创建的FBO（ID为0）。

 

渲染缓冲区对象

FBO创建完成后，还不能对其进行什么实质性的操作。因为，FBO的各个挂接点上还没有挂接实际的存储对象。我们需要手动创建这些对象，并将其与既存的FBO对象进行挂接。上文提到过，能够与FBO挂接的对象有两种，一种是纹理对象（texture object），另一种是渲染缓冲区对象（renderbuffer object）。读者可能对纹理对象比较熟悉，因为在为模型进行纹理贴图的时候，经常要使用这种对象。然而，对于渲染缓冲对象，读者可能会不太熟悉，因为这是OpenGL扩展中新引入的功能。下文将着重介绍渲染缓冲区对象的内容。

 

渲染缓冲区对象主要是为了实现屏外渲染（Off-screen Rendering）而设计的。渲染缓冲区对象主要用做FBO的深度缓冲区和模板缓冲区。可以使用glGenRenderbuffersEXT()函数来申请一个或多个闲置的渲染缓冲区对象ID（非负整数）。ID 0被OpenGL所保留。注意，申请了闲置ID之后，OpenGL并没有创建实际的对象，需要调用glBindRenderbufferEXT()函数来绑定并创建实际的对象。如果绑定ID 0，OpenGL会解除先前设定的渲染缓冲区对象。

 

上文提到过，渲染缓冲区对象实际上是某种二维数组的抽象。在绑定了一个渲染缓冲区对象之后，需要使用glRenderbufferStorage()函数为其分配二维数组存储空间。注意，同一个FBO中的各个二维数组空间的行数（或列数）应该相同。

 

同FBO类似，可以使用glDeleteRenderbuffersEXT()函数来删除一个渲染缓冲区对象。

 

挂接

可以使用glFramebufferRenderbufferEXT()函数将渲染缓冲区对象挂接到FBO上；使用glFramebufferTexture2D()。如果挂接的ID为0，则OpenGL将解除先前的绑定。当被绑定纹理对象或渲染缓冲区对象被删除，则他们会被自动从当前正在使用的FBO上解除挂接。如果纹理对象或渲染缓冲区对象被挂接到多个FBO上，他们被删除的时候，只会从当前被绑定的FBO上解除挂接，而不会从未被绑定的FBO上解除绑定。

 

FBO的完整性

在向FBO输出渲染结果之前，需要测试FBO的完整性。如果FBO不完整，任何渲染操作都会失败。我们可以使用glCheckFramebufferStatusEXT()函数来测试FBO的完整性（此函数不能在glBegin()和glEnd()函数之间调用）。FBO完整性的判别法则如下：

• 与FBO挂接的二维数组对象的长度和宽度必须不能为0。
• 如果一个二维数组对象被挂接到FBO的颜色缓冲区挂接点时，二维数组必须具有内部颜色格式(GL_RGBA, GL_DEPTH_COMPONENT, GL_LUMINANCE等)。
• 如果一个二维数组对象被挂接到FBO的深度缓冲区挂接点时，二维数组必须具有内部深度格式(GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT24_EXT等)。
• 如果一个二维数组对象被挂接到FBO的模板缓冲区挂接点时，二维数组必须具有内部模板格式(GL_STENCIL_INDEX, GL_STENCIL_INDEX8_EXT等)。
• FBO至少挂接有一个二维数组缓冲区对象。
• 同一个FBO上挂接的二维数组对象必须拥有相同的长度和宽度。
• 所有的颜色缓冲区挂接点上挂接的二维数组对象必须具有相同的内部格式。

FBO的使用

当所有上述的准备工作都完成之后，就可以调用glBindFramebufferEXT()来绑定一个FBO。随后，就可以像操作窗体系统提供的帧缓冲区一样操作当前绑定的FBO了。日常的3D渲染操作这里不再赘述。这里主要强调像素操作的使用。OpenGL提供了glBlitFramebufferEXT()函数进行像素操作。

[cpp] view plain copy

1. #include <gl\glew.h>  
2. #include <gl\freeglut.h>  
3. #include <stdlib.h>  
4. #include <stdio.h>  
5.   
6. #pragma comment(lib, "glew32.lib")  
7.   
8. GLuint imageFBO;  
9. GLuint imageID;  
10. GLuint depthTextureID;  
11. void SetFrameBufferObject(int fbowidth, int fboheight)  
12. {  
13.     // 创建FBO对象  
14.     glGenFramebuffersEXT(1, &imageFBO);  
15.     // 启用FBO  
16.     glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, imageFBO);  
17.   
18.     // 创建纹理  
19.     glGenTextures(1, &imageID);  
20.     // 启用纹理  
21.     glBindTexture(GL_TEXTURE_2D, imageID);  
22.     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, fbowidth, fboheight, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);                        
23.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);  
24.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);   
25.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);  
26.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);  
27.     glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, imageID, 0);  
28.       
29.     //  
30.     glGenRenderbuffersEXT(1, &depthTextureID);  
31.     glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depthTextureID);  
32.     glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT,GL_DEPTH_COMPONENT, fbowidth, fboheight);  
33.     glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT,GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depthTextureID);  
34.   
35.     GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);  
36.     if(status != GL_FRAMEBUFFER_COMPLETE_EXT)  
37.         printf( "FBO Initialization Failed.");  
38.   
39.     glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);  
40. }  
41.   
42. int IMAGE_WIDTH = 250;  
43. int IMAGE_HEIGHT = 250;  
44.   
45. void GenImage()  
46. {  
47.     glPushMatrix();  
48.     glViewport(0, 0, IMAGE_WIDTH, IMAGE_HEIGHT);  
49.     glMatrixMode(GL_PROJECTION);  
50.     glLoadIdentity();  
51.   
52.     glMatrixMode(GL_MODELVIEW);  
53.   
54.     glShadeModel(GL_SMOOTH);  
55.     glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, imageFBO);  
56.     glDrawBuffer(GL_COLOR_ATTACHMENT0_EXT);  
57.     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);  
58.     glBegin(GL_POLYGON);  
59.         glColor3f(1.0,0.0,0.0); glVertex3f(-1.0, -1.0, 0.0);  
60.         glColor3f(0.0,1.0,0.0); glVertex3f(-1.0, 1.0, 0.0);  
61.         glColor3f(0.0,0.0,1.0); glVertex3f(1.0, 1.0, 0.0);  
62.         glColor3f(1.0,0.0,0.0); glVertex3f(1.0, -1.0, 0.0);  
63.     glEnd();  
64.   
65.     glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);  
66.     glPopMatrix();  
67. }  
68.   
69. static GLuint texName;  
70.   
71. void display(void)  
72. {  
73.     // 离屏渲染纹理  
74.     GenImage();  
75.   
76.     glViewport(0,0,250,250);  
77.     glClear(GL_COLOR_BUFFER_BIT);  
78.     glEnable(GL_TEXTURE_2D);  
79.     glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);  
80.     //切换屏幕  
81.     glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,0);  
82.     // 启用离屏渲染的纹理影像  
83.     glBindTexture(GL_TEXTURE_2D,imageID);  
84.     // 创建Mipmap(多重细节层)  
85.     glGenerateMipmapEXT(GL_TEXTURE_2D);  
86.       
87.     // 绘制纹理影像  
88.     glBegin(GL_QUADS);  
89.     glTexCoord2f(1.0, 0.0); glVertex3f(-1.0, -1.0, 0.0);  
90.     glTexCoord2f(0.0, 1.0); glVertex3f(-1.0, 1.0, 0.0);  
91.     glTexCoord2f(1.0, 1.0); glVertex3f(1.0, 1.0, 0.0);  
92.     glTexCoord2f(1.0, 0.0); glVertex3f(1.0, -1.0, 0.0);  
93.     glEnd();  
94.   
95.     glutSwapBuffers();  
96.     glDisable(GL_TEXTURE_2D);  
97. }  
98.   
99. void reshape(int w, int h)  
100. {  
101.     glViewport(0, 0, (GLsizei) w, (GLsizei) h);  
102.     glMatrixMode(GL_PROJECTION);  
103.     glLoadIdentity();  
104. }  
105.   
106. void keyboard (unsigned char key, int x, int y)  
107. {  
108.     switch (key) {  
109.       case 27:  
110.           exit(0);  
111.           break;  
112.       default:  
113.           break;  
114.     }  
115. }  
116.   
117. int main(int argc, char** argv)  
118. {  
119.     glutInit(&argc, argv);  
120.     glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);  
121.     glutInitWindowSize(250, 250);  
122.     glutInitWindowPosition(100, 100);  
123.     glutCreateWindow(argv[0]);  
124.     glewInit();  
125.     glutDisplayFunc(display);  
126.     glutReshapeFunc(reshape);  
127.     glutKeyboardFunc(keyboard);  
128.         // 设置创建虚拟屏幕  
129.     SetFrameBufferObject(IMAGE_WIDTH, IMAGE_HEIGHT);  
130.   
131.     glutMainLoop();  
132.     return 0;  
133. }  

参考：

OpenGL怎样近似进行同时到FBO和屏幕的渲染

http://www.zwqxin.com/archives/opengl/fbo-screen-nearly-same-time.html

zwqxin的博客opengl技术相关内容

http://www.zwqxin.com/archives/opengl.html

#include <GL/glew.h>  //最好放在glut.h前面包含
#include <GL/glut.h>
#include <cv.h>
#include <opencv2/opencv.hpp>
#include <iostream>
using namespace std;
using namespace cv;


#pragma comment( lib, "glew32.lib"  )
#pragma comment( lib, "glew32s.lib" )
#pragma comment( lib, "glut32.lib"  )


const int WIDTH  = 600;
const int HEIGHT = 600;

const double xMax =  10;
const double xMin = -10;
const double yMax =  10;
const double yMin = -10;
const double nearDist = 0;
const double farDist  = 100;


const double camPosX = 0;
const double camPosY = 0;
const double camPosZ = 0;
const double lookAtX = 0;
const double lookAtY = 0;
const double lookAtZ = -1;
const double upX     = 0;
const double upY     = 1;
const double upZ     = 0;


void main() {


//////////////////////
// Create a window. //
//////////////////////


//glutInit( &argc, argv );
glutCreateWindow( "RTT window" );  //完成OpenGL初始化，但是窗口并没有显示，要调用glutMainLoop才显示
//glutInitWindowSize( WIDTH, HEIGHT );
glewInit(); 


//////////////////////////////////
// Check th framebuffer status. //
//////////////////////////////////


GLenum status = glCheckFramebufferStatusEXT( GL_FRAMEBUFFER_EXT );


switch( status ) {


case GL_FRAMEBUFFER_COMPLETE_EXT:
cout<<"GL_FRAMEBUFFER_COMPLETE_EXT!: SUCCESS"<<endl<<endl;
break;


case GL_FRAMEBUFFER_UNSUPPORTED_EXT:
cout<<"GL_FRAMEBUFFER_UNSUPPORTED_EXT!: ERROR"<<endl;
exit(0);
break;


default:
exit(0);


}
// ID numbers for buffers.
GLuint fbo; // for 'frame buffer object'
GLuint rbo; // for 'render buffer object'

// ID numbers for textures.
GLuint renderTarget;
GLuint textureID;  //外部加载ID号

// Create buffers.
glGenFramebuffersEXT(  1, &fbo );
glGenRenderbuffersEXT( 1, &rbo );

// Create textures.
glGenTextures( 1, &renderTarget );
glBindTexture( GL_TEXTURE_2D, renderTarget );
glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, WIDTH, HEIGHT, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL );

// Set the render target.
glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, fbo );
glBindRenderbufferEXT( GL_RENDERBUFFER_EXT, rbo );
glRenderbufferStorageEXT( GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, WIDTH, HEIGHT ); //

glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );

glFramebufferTexture2DEXT( GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, renderTarget, 0 );
glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, rbo );

//sphere texture
IplImage* imgBGR = cvLoadImage("test1.jpg"); //通过opengcv从磁盘加载图
IplImage* imgRGB = cvCreateImage(cvGetSize(imgBGR), 8, 3);
cvCvtColor(imgBGR,imgRGB,CV_BGR2RGB);

int width  = imgRGB->width;
int height = imgRGB->height; 

glGenTextures(1, &textureID);
glBindTexture(GL_TEXTURE_2D, textureID);
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, 3, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE,imgRGB->imageData); //已存入显存

cvReleaseImage(&imgBGR);
cvReleaseImage(&imgRGB);

///////////////////
// Render scene. //
///////////////////

// Set the render states.
glEnable( GL_DEPTH_TEST );
glDepthMask( 1 );
glDepthFunc( GL_LEQUAL );

glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);

glEnable(GL_LINE_SMOOTH);
glLineWidth(1.0);


// Draw on the buffer.
glClearColor( 0.f, 0.f, 0.f, 1.f );
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

glViewport( 0, 0, WIDTH, HEIGHT );  // Viewport transformation

glMatrixMode( GL_PROJECTION );      // Projection transformation
glLoadIdentity();
//glOrtho( xMin, xMax, yMin, yMax, nearDist, farDist );
gluPerspective(90, (float)WIDTH/(float)HEIGHT, 0.1, 100);

glMatrixMode( GL_MODELVIEW );       // Viewing transformation
glLoadIdentity();
gluLookAt( camPosX, camPosY, camPosZ, lookAtX, lookAtY, lookAtZ, upX, upY, upZ );


//glColor3f(1,1,1); // yellow 这里是画四边形
//glTranslatef( 0, 0, -60 );
//glBegin( GL_QUADS );
//glVertex3f( xMin, yMin, 0 );
//glVertex3f( xMax, yMin, 0 );
//glVertex3f( xMax, yMax, 0 );
//glVertex3f( xMin, yMax, 0 );
//glEnd();


GLUquadricObj*quadratic= gluNewQuadric(); //画带纹理的球
gluQuadricDrawStyle(quadratic, GLU_FILL);
gluQuadricNormals(quadratic, GLU_SMOOTH);
gluQuadricTexture(quadratic, GL_TRUE);
glPushMatrix(); 
glColor3f(1.0f,1.0f,1.0f); 
glTranslatef(0.0f,0.0f,0.0f);
glBindTexture(GL_TEXTURE_2D,textureID); 
glEnable(GL_TEXTURE_2D); 


glRotatef(90.0f,1.0f,0.0f,0.0f);
glRotatef(-23.5f,0.0f,0.0f,1.0f);


gluSphere(quadratic,1,180,180); 
glDisable(GL_TEXTURE_2D);
glPopMatrix(); 


///////////////////////
// Read from buffer. //
///////////////////////
unsigned char *color = new unsigned char[WIDTH*HEIGHT*4];
float         *depth = new float[WIDTH*HEIGHT];;


glReadBuffer( GL_COLOR_ATTACHMENT0_EXT );
glReadPixels( 0, 0, WIDTH, HEIGHT, GL_RGBA, GL_UNSIGNED_BYTE, color );
IplImage* image = cvCreateImage(cvSize(WIDTH, HEIGHT), IPL_DEPTH_8U, 4);
IplImage* imageRGB = cvCreateImage(cvSize(WIDTH, HEIGHT), IPL_DEPTH_8U, 4);
IplImage* imageFlip = cvCreateImage(cvSize(WIDTH, HEIGHT), IPL_DEPTH_8U, 4);
image->imageData = (char*)color;
//cvCvtColor(image,imgRGB,CV_BGRA2BGR);
//cvFlip(imageRGB,imageFlip,1);
cvSaveImage("C:\\temp.jpg", image); //保存
cvReleaseImage(&image);
//cvReleaseImage(&imageRGB);
//cvReleaseImage(&imageFlip);

cout<<"Color values from color buffer:"<<endl;
cout<<"("<<(int)color[8]<<","<<(int)color[9]<<","<<(int)color[10]<<","<<(int)color[11]<<") ("
<<(int)color[12]<<","<<(int)color[13]<<","<<(int)color[14]<<","<<(int)color[15]<<")"<<endl;
cout<<"("<<(int)color[0]<<","<<(int)color[1]<<","<<(int)color[2]<<","<<(int)color[3]<<") ("
<<(int)color[4]<<","<<(int)color[5]<<","<<(int)color[6]<<","<<(int)color[7]<<")"<<endl<<endl;

glReadBuffer( GL_DEPTH_ATTACHMENT_EXT );
glReadPixels( 0, 0, WIDTH, HEIGHT, GL_DEPTH_COMPONENT, GL_FLOAT, depth );

cout<<"Depth values from z-buffer:"<<endl;
cout<<depth[2]<<" "<<depth[3]<<endl;
cout<<depth[0]<<" "<<depth[1]<<endl;

delete[] color;
delete[] depth;
/////////////////////
// Release mmemory //
/////////////////////
// Delete textures;
glDeleteTextures( 1, &renderTarget );

// Delete buffers.
glDeleteFramebuffersEXT(  1, &fbo );
glDeleteRenderbuffersEXT( 1, &rbo );

// Return to rendering to the main framebuffer instead of 'fbo'.
glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, 0 );