附录四 其他头文件

 1 #ifndef __CPU_BITMAP_H__
 2 #define __CPU_BITMAP_H__
 3 
 4 #include "gl_helper.h"
 5 
 6 struct CPUBitmap
 7 {
 8     unsigned char   *pixels;
 9     int             x, y;
10     void            *dataBlock;
11     void            (*bitmapExit)(void*);
12 
13     CPUBitmap( int width, int height, void *d = NULL )
14     {
15         pixels = new unsigned char[width * height * 4];
16         x = width;
17         y = height;
18         dataBlock = d;
19     }
20 
21     ~CPUBitmap()
22     {
23         delete [] pixels;
24     }
25 
26     unsigned char* get_ptr( void ) const   { return pixels; }
27     long image_size( void ) const { return x * y * 4; }
28 
29     void display_and_exit( void(*e)(void*) = NULL )
30     {
31         CPUBitmap**   bitmap = get_bitmap_ptr();
32         *bitmap = this;
33         bitmapExit = e;
34         // a bug in the Windows GLUT implementation prevents us from
35         // passing zero arguments to glutInit()
36         int c=1;
37         char* dummy = "";
38         glutInit( &c, &dummy );
39         glutInitDisplayMode( GLUT_SINGLE | GLUT_RGBA );
40         glutInitWindowSize( x, y );
41         glutCreateWindow( "bitmap" );
42         glutKeyboardFunc(Key);
43         glutDisplayFunc(Draw);
44         glutMainLoop();
45     }
46 
47      // static method used for glut callbacks
48     static CPUBitmap** get_bitmap_ptr( void )
49     {
50         static CPUBitmap   *gBitmap;
51         return &gBitmap;
52     }
53 
54    // static method used for glut callbacks
55     static void Key(unsigned char key, int x, int y)
56     {
57         switch (key)
58         {
59             case 27:
60                 CPUBitmap*   bitmap = *(get_bitmap_ptr());
61                 if (bitmap->dataBlock != NULL && bitmap->bitmapExit != NULL)
62                     bitmap->bitmapExit( bitmap->dataBlock );
63             exit(0);
64         }
65     }
66 
67     // static method used for glut callbacks
68     static void Draw( void )
69     {
70         CPUBitmap*   bitmap = *(get_bitmap_ptr());
71         glClearColor( 0.0, 0.0, 0.0, 1.0 );
72         glClear( GL_COLOR_BUFFER_BIT );
73         glDrawPixels( bitmap->x, bitmap->y, GL_RGBA, GL_UNSIGNED_BYTE, bitmap->pixels );
74         glFlush();
75     }
76 };
77 
78 #endif  // __CPU_BITMAP_H__

  1 #ifndef __CPU_ANIM_H__
  2 #define __CPU_ANIM_H__
  3 
  4 #include "D:\Code\CUDA\book\common\gl_helper.h"
  5 #include <iostream>
  6 
  7 
  8 struct CPUAnimBitmap
  9 {
 10     unsigned char    *pixels;
 11     int     width, height;
 12     void    *dataBlock;
 13     void (*fAnim)(void*,int);
 14     void (*animExit)(void*);
 15     void (*clickDrag)(void*,int,int,int,int);
 16     int     dragStartX, dragStartY;
 17 
 18     CPUAnimBitmap( int w, int h, void *d = NULL )
 19     {
 20         width = w;
 21         height = h;
 22         pixels = new unsigned char[width * height * 4];
 23         dataBlock = d;
 24         clickDrag = NULL;
 25     }
 26 
 27     ~CPUAnimBitmap()
 28     {
 29         delete [] pixels;
 30     }
 31 
 32     unsigned char* get_ptr( void ) const   { return pixels; }
 33     long image_size( void ) const { return width * height * 4; }
 34 
 35     void click_drag(void(*f)(void*, int, int, int, int))
 36     {
 37         clickDrag = f;
 38     }
 39 
 40     void anim_and_exit(void(*f)(void*, int), void(*e)(void*))
 41     {
 42         CPUAnimBitmap**   bitmap = get_bitmap_ptr();
 43         *bitmap = this;
 44         fAnim = f;
 45         animExit = e;
 46         // a bug in the Windows GLUT implementation prevents us from
 47         // passing zero arguments to glutInit()
 48         int c=1;
 49         char* dummy = "";
 50         glutInit( &c, &dummy );
 51         glutInitDisplayMode( GLUT_DOUBLE | GLUT_RGBA );
 52         glutInitWindowSize( width, height );
 53         glutCreateWindow( "bitmap" );
 54         glutKeyboardFunc(Key);
 55         glutDisplayFunc(Draw);
 56         if (clickDrag != NULL)
 57             glutMouseFunc( mouse_func );
 58         glutIdleFunc( idle_func );
 59         glutMainLoop();
 60     }
 61 
 62     // static method used for glut callbacks
 63     static CPUAnimBitmap** get_bitmap_ptr(void)
 64     {
 65         static CPUAnimBitmap*   gBitmap;
 66         return &gBitmap;
 67     }
 68 
 69     // static method used for glut callbacks
 70     static void mouse_func(int button, int state, int mx, int my)
 71     {
 72         if (button == GLUT_LEFT_BUTTON)
 73         {
 74             CPUAnimBitmap*   bitmap = *(get_bitmap_ptr());
 75             if (state == GLUT_DOWN)
 76             {
 77                 bitmap->dragStartX = mx;
 78                 bitmap->dragStartY = my;
 79             }
 80             else if (state == GLUT_UP)
 81                 bitmap->clickDrag( bitmap->dataBlock,bitmap->dragStartX,bitmap->dragStartY,mx, my );
 82         }
 83     }
 84 
 85     // static method used for glut callbacks
 86     static void idle_func( void )
 87     {
 88         static int ticks = 1;
 89         CPUAnimBitmap*   bitmap = *(get_bitmap_ptr());
 90         bitmap->fAnim( bitmap->dataBlock, ticks++ );
 91         glutPostRedisplay();
 92     }
 93 
 94     // static method used for glut callbacks
 95     static void Key(unsigned char key, int x, int y)
 96     {
 97         switch (key)
 98         {
 99             case 27:
100                 CPUAnimBitmap*   bitmap = *(get_bitmap_ptr());
101                 bitmap->animExit( bitmap->dataBlock );
102                 //delete bitmap;
103             exit(0);
104         }
105     }
106 
107     // static method used for glut callbacks
108     static void Draw( void )
109     {
110         CPUAnimBitmap*   bitmap = *(get_bitmap_ptr());
111         glClearColor( 0.0, 0.0, 0.0, 1.0 );
112         glClear( GL_COLOR_BUFFER_BIT );
113         glDrawPixels( bitmap->width, bitmap->height, GL_RGBA, GL_UNSIGNED_BYTE, bitmap->pixels );
114         glutSwapBuffers();
115     }
116 };
117 
118 #endif  // __CPU_ANIM_H__

  1 #ifndef __GPU_ANIM_H__
  2 #define __GPU_ANIM_H__
  3 #include "D:\Code\CUDA\book\common\gl_helper.h"
  4 #include "cuda.h"
  5 #include "cuda_gl_interop.h"
  6 #include <iostream>
  7 
  8 PFNGLBINDBUFFERARBPROC    glBindBuffer     = NULL;
  9 PFNGLDELETEBUFFERSARBPROC glDeleteBuffers  = NULL;
 10 PFNGLGENBUFFERSARBPROC    glGenBuffers     = NULL;
 11 PFNGLBUFFERDATAARBPROC    glBufferData     = NULL;
 12 
 13 struct GPUAnimBitmap
 14 {
 15     GLuint  bufferObj;
 16     cudaGraphicsResource *resource;
 17     int     width, height;
 18     void    *dataBlock;
 19     void (*fAnim)(uchar4*,void*,int);
 20     void (*animExit)(void*);
 21     void (*clickDrag)(void*,int,int,int,int);
 22     int     dragStartX, dragStartY;
 23 
 24     GPUAnimBitmap( int w, int h, void *d = NULL )
 25     {
 26         width = w;
 27         height = h;
 28         dataBlock = d;
 29         clickDrag = NULL;
 30 
 31         // first, find a CUDA device and set it to graphic interop
 32         cudaDeviceProp  prop;
 33         int dev;
 34         memset( &prop, 0, sizeof( cudaDeviceProp ) );
 35         prop.major = 1;
 36         prop.minor = 0;
 37          cudaChooseDevice( &dev, &prop ) );
 38         cudaGLSetGLDevice( dev );
 39 
 40         // a bug in the Windows GLUT implementation prevents us from
 41         // passing zero arguments to glutInit()
 42         int c=1;
 43         char* dummy = "";
 44         glutInit( &c, &dummy );
 45         glutInitDisplayMode( GLUT_DOUBLE | GLUT_RGBA );
 46         glutInitWindowSize( width, height );
 47         glutCreateWindow( "bitmap" );
 48 
 49         glBindBuffer    = (PFNGLBINDBUFFERARBPROC)GET_PROC_ADDRESS("glBindBuffer");
 50         glDeleteBuffers = (PFNGLDELETEBUFFERSARBPROC)GET_PROC_ADDRESS("glDeleteBuffers");
 51         glGenBuffers    = (PFNGLGENBUFFERSARBPROC)GET_PROC_ADDRESS("glGenBuffers");
 52         glBufferData    = (PFNGLBUFFERDATAARBPROC)GET_PROC_ADDRESS("glBufferData");
 53 
 54         glGenBuffers( 1, &bufferObj );
 55         glBindBuffer( GL_PIXEL_UNPACK_BUFFER_ARB, bufferObj );
 56         glBufferData(GL_PIXEL_UNPACK_BUFFER_ARB, width * height * 4, NULL, GL_DYNAMIC_DRAW_ARB);
 57 
 58         cudaGraphicsGLRegisterBuffer(&resource, bufferObj, cudaGraphicsMapFlagsNone);
 59     }
 60 
 61     ~GPUAnimBitmap()
 62     {
 63         free_resources();
 64     }
 65 
 66     void free_resources( void )
 67     {
 68         cudaGraphicsUnregisterResource( resource ) );
 69         glBindBuffer( GL_PIXEL_UNPACK_BUFFER_ARB, 0 );
 70         glDeleteBuffers( 1, &bufferObj );
 71     }
 72 
 73 
 74     long image_size( void ) const { return width * height * 4; }
 75 
 76     void click_drag(void(*f)(void*, int, int, int, int))
 77     {
 78         clickDrag = f;
 79     }
 80 
 81     void anim_and_exit(void(*f)(uchar4*, void*, int), void(*e)(void*))
 82     {
 83         GPUAnimBitmap**   bitmap = get_bitmap_ptr();
 84         *bitmap = this;
 85         fAnim = f;
 86         animExit = e;
 87 
 88         glutKeyboardFunc( Key );
 89         glutDisplayFunc( Draw );
 90         if (clickDrag != NULL)
 91             glutMouseFunc( mouse_func );
 92         glutIdleFunc( idle_func );
 93         glutMainLoop();
 94     }
 95 
 96     // static method used for glut callbacks
 97     static GPUAnimBitmap** get_bitmap_ptr( void )
 98     {
 99         static GPUAnimBitmap*   gBitmap;
100         return &gBitmap;
101     }
102 
103     // static method used for glut callbacks
104     static void mouse_func( int button, int state,int mx, int my )
105     {
106         if (button == GLUT_LEFT_BUTTON)
107         {
108             GPUAnimBitmap*   bitmap = *(get_bitmap_ptr());
109             if (state == GLUT_DOWN)
110             {
111                 bitmap->dragStartX = mx;
112                 bitmap->dragStartY = my;
113             } 
114             else if (state == GLUT_UP)
115                 bitmap->clickDrag(bitmap->dataBlock, bitmap->dragStartX, bitmap->dragStartY, mx, my);
116         }
117     }
118 
119     // static method used for glut callbacks
120     static void idle_func( void )
121     {
122         static int ticks = 1;
123         GPUAnimBitmap*  bitmap = *(get_bitmap_ptr());
124         uchar4*         devPtr;
125         size_t  size;
126 
127         cudaGraphicsMapResources(1, &(bitmap->resource), NULL);
128         cudaGraphicsResourceGetMappedPointer((void**)&devPtr, &size, bitmap->resource);
129 
130         bitmap->fAnim(devPtr, bitmap->dataBlock, ticks++);
131 
132         cudaGraphicsUnmapResources(1, &(bitmap->resource), NULL);
133 
134         glutPostRedisplay();
135     }
136 
137     // static method used for glut callbacks
138     static void Key(unsigned char key, int x, int y)
139     {
140         switch (key)
141         {
142             case 27:
143                 GPUAnimBitmap*   bitmap = *(get_bitmap_ptr();
144                 if (bitmap->animExit)
145                     bitmap->animExit( bitmap->dataBlock );
146                 bitmap->free_resources();
147                 exit(0);
148         }
149     }
150 
151     // static method used for glut callbacks
152     static void Draw( void )
153     {
154         GPUAnimBitmap*   bitmap = *(get_bitmap_ptr();
155         glClearColor( 0.0, 0.0, 0.0, 1.0 );
156         glClear( GL_COLOR_BUFFER_BIT );
157         glDrawPixels( bitmap->width, bitmap->height, GL_RGBA,
158                       GL_UNSIGNED_BYTE, 0 );
159         glutSwapBuffers();
160     }
161 };
162 
163 #endif  // __GPU_ANIM_H__

 1 #ifndef __GL_HELPER_H__
 2 #define __GL_HELPER_H__
 3 
 4 /*
 5    On 64-bit Windows, we need to prevent GLUT from automatically linking against
 6    glut32. We do this by defining GLUT_NO_LIB_PRAGMA. This means that we need to
 7    manually add opengl32.lib and glut64.lib back to the link using pragmas.
 8    Alternatively, this could be done on the compilation/link command-line, but
 9    we chose this so that compilation is identical between 32- and 64-bit Windows.
10 */
11 #ifdef _WIN64
12 #define GLUT_NO_LIB_PRAGMA
13 #pragma comment (lib, "opengl32.lib")  /* link with Microsoft OpenGL lib */
14 #pragma comment (lib, "glut64.lib")    /* link with Win64 GLUT lib */
15 #endif //_WIN64
16 
17 
18 #ifdef _WIN32
19 /* On Windows, include the local copy of glut.h and glext.h */
20 #include "GL/glut.h"
21 #include "GL/glext.h"
22 
23 #define GET_PROC_ADDRESS( str ) wglGetProcAddress( str )
24 
25 #else
26 
27 /* On Linux, include the system‘s copy of glut.h, glext.h, and glx.h */
28 #include <GL/glut.h>
29 #include <GL/glext.h>
30 #include <GL/glx.h>
31 
32 #define GET_PROC_ADDRESS( str ) glXGetProcAddress( (const GLubyte *)str )
33 
34 #endif //_WIN32
35 
36 #endif //__GL_HELPER_H__‘