分享成果： 双缓冲能提高渲染速度且数据整体传输比零散传输快

三月廿七

绘制1000 张 240x320 的图片， 双缓冲 比 普通绘图快 5 倍左右，
同样是绘制1000 张 240x320 的图片，  整体绘制比零散绘制快 10倍左右，

1. 
   
2. #include <GL/glut.h>
   
3. #include <stdlib.h>
   
4. #include <stdio.h>
   
5. #include <time.h>
   
6. 
   
7. GLubyte*  readImage(const char*, GLsizei*, GLsizei* );
   
8. GLubyte  *pixels;
   
9. GLsizei   width, height;
   
10. 
    
11. void init(void)
    
12. {
    
13.         glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    
14.         glClearColor(0.0, 0.0, 0.0, 0.0);
    
15.        
    
16. }
    
17. 
    
18. void display(void)
    
19. {
    
20.         GLubyte*  buffer;
    
21.         int i;
    
22. 
    
23.     static clock_t start = 0, end = 0, t1 = 0, t2 = 0;
    
24. 
    
25.         buffer = (GLubyte*)malloc(width * height * 3);
    
26. 
    
27.         glClear(GL_COLOR_BUFFER_BIT);
    
28.         glRasterPos2i(0, 0);
    
29.        
    
30.         start = clock();
    
31.         for (i = 0; i < 1000; i++)
    
32.         {
    
33.                 glDrawPixels(width, height, GL_RGB, GL_UNSIGNED_BYTE, pixels );
    
34.         }
    
35.         end = clock();
    
36. 
    
37.         t1 = end - start;
    
38. 
    
39.         glRasterPos2i(240, 100);
    
40. 
    
41.         start = clock();
    
42.         for (i = 0; i < 1000; i++)
    
43.         {
    
44.                 memcpy(buffer, pixels, width * height * 3);
    
45.                 //glDrawPixels(width, height, GL_RGB, GL_UNSIGNED_BYTE, pixels );
    
46.         }
    
47.         glDrawPixels(width, height, GL_RGB, GL_UNSIGNED_BYTE, buffer);
    
48.         end = clock();
    
49.        
    
50.         t2 = end - start;
    
51. 
    
52.         glFlush();
    
53. }
    
54. void reshape(int w, int h)
    
55. {
    
56.         glViewport(0, 0, (GLsizei) w, (GLsizei) h);
    
57.         glMatrixMode(GL_PROJECTION);
    
58.         glLoadIdentity();
    
59.         glOrtho (0, w, 0, h, -1.0, 1.0);
    
60.         glMatrixMode(GL_MODELVIEW);
    
61. }
    
62. void keyboard(unsigned char key, int x, int y)
    
63. {
    
64.         switch (key)
    
65.         {
    
66.         case 27:
    
67.                 exit(0);
    
68.                 break;
    
69.         default:
    
70.                 break;
    
71.         }
    
72. }
    
73. /*  Main Loop
    
74. *  Open window with initial window size, title bar,
    
75. *  RGBA display mode, and handle input events.
    
76. */
    
77. int main(int argc, char** argv)
    
78. {
    
79.         pixels = readImage("blueguy\\blueguy.bmp", &width, &height);   
    
80.        
    
81.         glutInit(&argc, argv);
    
82.         glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
    
83.         glutInitWindowSize(500, 500);
    
84.         glutInitWindowPosition(100, 100);
    
85.         glutCreateWindow(argv[0]);
    
86.         init();
    
87.         glutReshapeFunc(reshape);
    
88.         glutKeyboardFunc(keyboard);
    
89.         glutDisplayFunc(display);
    
90.         glutMainLoop();
    
91.         return 0;
    
92. }
    
93. GLubyte* readImage( const char* filename, GLsizei* width, GLsizei *height )
    
94. {
    
95.     FILE* file;
    
96.         GLubyte*  pixels;
    
97.     unsigned long size;                 /* size of the image in bytes.*/
    
98.     unsigned long i;                    /* standard counter.*/
    
99.     unsigned short int planes;          /* number of planes in image (must be 1) */
    
100.     unsigned short int bpp;             /* number of bits per pixel (must be 24)*/
     
101.     char temp;                          /* temporary color storage for bgr-rgb conversion.*/
     
102.        
     
103.     /* make sure the file is there.*/
     
104.     if ((file = fopen(filename, "rb"))==NULL)
     
105.         {
     
106.                 printf("File Not Found : %s\n",filename);
     
107.                 return 0;
     
108.     }
     
109.    
     
110.     /* seek through the bmp header, up to the width/height:*/
     
111.     fseek(file, 18, SEEK_CUR);
     
112.        
     
113.     /* No 100% errorchecking anymore!!!*/
     
114.        
     
115.     /* read the width*/
     
116.     *width = getInt(file);
     
117.     printf("Width of %s: %lu\n", filename, *width);
     
118.    
     
119.     /* read the height */
     
120.     *height = getInt(file);
     
121.     printf("Height of %s: %lu\n", filename, *height);
     
122.    
     
123.     /* calculate the size (assuming 24 bits or 3 bytes per pixel).*/
     
124.     size = (*width) * (*height) * 3;
     
125.        
     
126.     /* read the planes*/
     
127.     planes = getShort(file);
     
128.        
     
129.     if (planes != 1)
     
130.         {
     
131.                 printf("Planes from %s is not 1: %u\n", filename, planes);
     
132.                 return 0;
     
133.     }
     
134.        
     
135.     /* read the bpp*/
     
136.     bpp = getShort(file);
     
137.        
     
138.     if (bpp != 24)
     
139.         {
     
140.                 printf("Bpp from %s is not 24: %u\n", filename, bpp);
     
141.                 return 0;
     
142.     }
     
143.        
     
144.     /* seek past the rest of the bitmap header.*/
     
145.     fseek(file, 24, SEEK_CUR);
     
146.        
     
147.     /* read the data. */
     
148.     pixels = (GLubyte*)malloc(size);
     
149.        
     
150.     if (pixels == NULL)
     
151.         {
     
152.                 printf("Error allocating memory for color-corrected image data");
     
153.                 return 0;
     
154.     }
     
155.        
     
156.     if ((i = fread(pixels, size, 1, file)) != 1)
     
157.         {
     
158.                 printf("Error reading image data from %s.\n", filename);
     
159.                 return 0;
     
160.     }
     
161.        
     
162.        
     
163.     for (i = 0; i < size; i += 3)
     
164.         { /* reverse all of the colors. (bgr -> rgb)*/
     
165.                 temp = pixels[i];
     
166.                 pixels[i] = pixels[i+2];
     
167.                 pixels[i+2] = temp;
     
168.     }
     
169.        
     
170.        
     
171.     /* we're done.*/
     
172.     return pixels;
     
173. }
     
174. static unsigned int getInt(FILE* fp)
     
175. {
     
176.         int c, c1, c2, c3;
     
177.        
     
178.         /* get 4 bytes*/
     
179.         c = getc(fp);  
     
180.         c1 = getc(fp);  
     
181.         c2 = getc(fp);  
     
182.         c3 = getc(fp);
     
183.        
     
184.         return ((unsigned int) c) +   
     
185.                 (((unsigned int) c1) << 8) +
     
186.                 (((unsigned int) c2) << 16) +
     
187.                 (((unsigned int) c3) << 24);
     
188. }
     
189. static unsigned int getShort(FILE* fp)
     
190. {
     
191.         int c, c1;
     
192.        
     
193.         /*get 2 bytes*/
     
194.         c = getc(fp);  
     
195.         c1 = getc(fp);
     
196.         return ((unsigned int) c) + (((unsigned int) c1) << 8);
     
197. }

复制代码

三月廿七

#include <GL/glut.h>
#include <stdlib.h>
#include <stdio.h>
#include <time.h>

GLubyte*  readImage(const char*, GLsizei*, GLsizei* );
GLubyte  *pixels;
GLsizei   width, height;

void init(void)
{
        glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
        glClearColor(0.0, 0.0, 0.0, 0.0);
       
}

void display(void)
{
        unsigned int i, j, k, m;
        GLbyte r, g, b;
        GLubyte*  buffer;
       
    static clock_t start = 0, end = 0, t1 = 0, t2 = 0;
       
        buffer = (GLubyte*)malloc(width * height * 3);
       
        glClear(GL_COLOR_BUFFER_BIT);
        glRasterPos2i(240, 100);
       
        start = clock();
        for (i = 0; i < 1000; i++)
        {
                glDrawPixels(width, height, GL_RGB, GL_UNSIGNED_BYTE, pixels);
        }
        end = clock();
        t1 = end - start;
       
        start = clock();
        for (m = 0; m < 1000; m++)
        {
                k = 0;
                glBegin(GL_POINTS);
                for (i = 0; i < height; i++)
                {
                        for (j = 0; j < width; j++)
                        {
                                r = pixels[k];
                                g = pixels[k+1];
                                b = pixels[k+2];
                               
                                glColor3ub(r, g, b);
                                glVertex2i(j, i);
                               
                                k += 3;
                        }
                }
                glEnd();
        }
        end = clock();
        t2 = end - start;
       
        glFlush();
}
void reshape(int w, int h)
{
        glViewport(0, 0, (GLsizei) w, (GLsizei) h);
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        glOrtho (0, w, 0, h, -1.0, 1.0);
        glMatrixMode(GL_MODELVIEW);
}
void keyboard(unsigned char key, int x, int y)
{
        switch (key)
        {
        case 27:
                exit(0);
                break;
        default:
                break;
        }
}
/*  Main Loop
*  Open window with initial window size, title bar,
*  RGBA display mode, and handle input events.
*/
int main(int argc, char** argv)
{
        pixels = readImage("blueguy\\blueguy.bmp", &width, &height);   
       
        glutInit(&argc, argv);
        glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
        glutInitWindowSize(500, 500);
        glutInitWindowPosition(100, 100);
        glutCreateWindow(argv[0]);
        init();
        glutReshapeFunc(reshape);
        glutKeyboardFunc(keyboard);
        glutDisplayFunc(display);
        glutMainLoop();
        return 0;
}
GLubyte* readImage( const char* filename, GLsizei* width, GLsizei *height )
{
    FILE* file;
        GLubyte*  pixels;
    unsigned long size;                 /* size of the image in bytes.*/
    unsigned long i;                    /* standard counter.*/
    unsigned short int planes;          /* number of planes in image (must be 1) */
    unsigned short int bpp;             /* number of bits per pixel (must be 24)*/
    char temp;                          /* temporary color storage for bgr-rgb conversion.*/
       
    /* make sure the file is there.*/
    if ((file = fopen(filename, "rb")==NULL)
        {
                printf("File Not Found : %s\n",filename);
                return 0;
    }
   
    /* seek through the bmp header, up to the width/height:*/
    fseek(file, 18, SEEK_CUR);
       
    /* No 100% errorchecking anymore!!!*/
       
    /* read the width*/
    *width = getInt(file);
    printf("Width of %s: %lu\n", filename, *width);
   
    /* read the height */
    *height = getInt(file);
    printf("Height of %s: %lu\n", filename, *height);
   
    /* calculate the size (assuming 24 bits or 3 bytes per pixel).*/
    size = (*width) * (*height) * 3;
       
    /* read the planes*/
    planes = getShort(file);
       
    if (planes != 1)
        {
                printf("lanes from %s is not 1: %u\n", filename, planes);
                return 0;
    }
       
    /* read the bpp*/
    bpp = getShort(file);
       
    if (bpp != 24)
        {
                printf("Bpp from %s is not 24: %u\n", filename, bpp);
                return 0;
    }
       
    /* seek past the rest of the bitmap header.*/
    fseek(file, 24, SEEK_CUR);
       
    /* read the data. */
    pixels = (GLubyte*)malloc(size);
       
    if (pixels == NULL)
        {
                printf("Error allocating memory for color-corrected image data";
                return 0;
    }
       
    if ((i = fread(pixels, size, 1, file)) != 1)
        {
                printf("Error reading image data from %s.\n", filename);
                return 0;
    }
       
       
    for (i = 0; i < size; i += 3)
        { /* reverse all of the colors. (bgr -> rgb)*/
                temp = pixels[i];
                pixels[i] = pixels[i+2];
                pixels[i+2] = temp;
    }
       
       
    /* we're done.*/
    return pixels;
}
static unsigned int getInt(FILE* fp)
{
        int c, c1, c2, c3;
       
        /* get 4 bytes*/
        c = getc(fp);  
        c1 = getc(fp);  
        c2 = getc(fp);  
        c3 = getc(fp);
       
        return ((unsigned int) c) +   
                (((unsigned int) c1) << +
                (((unsigned int) c2) << 16) +
                (((unsigned int) c3) << 24);
}
static unsigned int getShort(FILE* fp)
{
        int c, c1;
       
        /*get 2 bytes*/
        c = getc(fp);  
        c1 = getc(fp);
        return ((unsigned int) c) + (((unsigned int) c1) << ;
}

三月廿七

很专业。看不太懂
static unsigned int getInt(FILE* fp)中的
int c, c1, c2, c3;能否定义为unsigned int ...
pmerofc 发表于 2011-03-12 16:40

当然可以，

说实话， 我很佩服你啊， 细节搞的那么透彻，
唉， 我只是(半调子/5) 的水平~~~

本人支持你打击一切不自然的写法~~

三月廿七

过奖过奖。说实话我很想了解一下“双缓冲”，看了半天没看懂。能否给详细说说
pmerofc 发表于 2011-03-12 16:50

双缓冲原理很简单，

绘制图片 就是将内存中的 像素数据 传输到 帧缓冲区（屏幕缓冲），
原先不使用双缓冲（也就是不使用自己开辟的内存）， 每绘制一次图片， 把内存中的 像素数据 传输到 帧缓冲区一次，
绘制1000次， 就得从内存传送数据1000次 到 帧缓冲区。
for (i = 0; i < 1000; i++)

        {

                glDrawPixels(width, height, GL_RGB, GL_UNSIGNED_BYTE, pixels );

        }



现在自己开辟一块内存， 每绘制一次图片都是在自己开辟的内存中操作像素数据， 我记得 J2ME 有离屏缓冲， 可以很简单的使用 双缓冲， 如果是用c 语言
实现双缓冲， 就需要自己实现 图片的 旋转， 镜像等一系列操作。绘制1000次， 就在自己开辟的内存中绘图1000次， 最后再把 内存中的像素数据传输到 帧缓冲区，
这样就节省了大量的像素传输时间。
for (i = 0; i < 1000; i++)

        {

                memcpy(buffer, pixels, width * height * 3);

                //glDrawPixels(width, height, GL_RGB, GL_UNSIGNED_BYTE, pixels );

        }

        glDrawPixels(width, height, GL_RGB, GL_UNSIGNED_BYTE, buffer);


所以， 双缓冲的优点是能够 提高渲染速度， 相对的缺点是 需要耗掉与帧缓冲区一样大小的内存