脏矩形技术

 优化一直是我在程序中追求的东西之一，想想让自己的游戏在一个古董机器能流畅的运行或者说在当今的机器上，CPU占用率和内存占用率都很低的情况。（毕竟我非常讨厌一个游戏独占了我所有的CPU资源）。

       如果从图形接口上作优化，常用的就是使用3D加速和CPU的特殊指令（虽然说DirectDraw能够使用2D硬件加速，但大部分机器支持的仅仅是简单的加速，比如带ColorKey的支持，连一些稍微高级一点的东西，比如Alpha混合，带Alpha通道的纹理（表面）都不支持，需要自己写，优化起来还是使用CPU的特殊指令）。虽然说使用3D加速非常简单，但是它的缺点也非常明显：对硬件有苛刻的要求，如果仅仅是做2D游戏不推荐使用（新手作为练习写DEMO而使用倒还可以,我也这样使用过，呵呵)。使用特殊的CPU指令最常见的就是使用MMX指令了，现在想找到一块装了Windows95以上但不支持MMX的CPU都有难度 ~自己花了大半年的时间用MMX高速实现了D3D对2D贴图的各种特效（带通道或者不带通道的纹理，带BlendColor, 带缩放旋转，做加减法的Alpha混合之类的）之后，虽然发现可以不使用D3D的东西，但是如果画面的东西很多的话，在一些内存带宽不高的机器上的速度还是不够理想，所以还是需要更多的优化。这时候我想起了DirtyRect。

       什么是脏矩形？简单的说，就是游戏每次画面的刷新只更新需要更新的那一块区域。Windows本身就是最好的例子。或者说Flash控件，也正是利用了脏矩形技术，所以他的效率才如此的高。传统的游戏循环如下：

      while( 游戏没有结束 )

       {

              if( 有Windows消息 )

              {

                     处理Windows消息

              }

              else if( 需要渲染 )

              {

                     清除游戏屏幕的缓冲区

                     把游戏中的物体画到缓冲区里面

                     把缓冲区更新到游戏窗口上

                     锁定游戏速度，Sleep一段时间，限制FPS

              }

       }

       从上面的伪代码可以看出，每次游戏都要做清除缓冲区-〉渲染游戏的物体-〉更新到窗口，而基本上我们写游戏至少要保证最低每秒钟要刷新24帧以上（一般都在30）。所以上面的代码每秒钟要至少24次以上，画面东西越多，耗费的CPU越多。

       不过我们也可以自然的想到，每次那么多东西不一定都需要更新的，比如一个动画，一般都有一个延迟，比如间隔200毫秒更新一次，那么在这段时间是不需要重新画的，只有更新了帧以后，表示这个动画所在的范围已经“脏”了，需要重新画，这个时候才需要画这个动画。而这段时间之内我们可以节约大量的CPU时间，很自然，积少成多，总体下来这个数值是非常可观的。再举一个例子，一个静止的游戏物体，（比如一棵树）是永远都不需要更新的，除非这个树的位置或者他的属性发生了变化。这样下来我们首先想到的是，每次我们都省略清除后台缓冲这个步骤，这个非常重要，因为上一次画下来的东西都在这个缓冲区里面，如果清除之后就什么都没有啦~~

       搞明白了这个原理以后，下面来看看具体实现过程中遇到的问题：

       游戏中的物体不会是相互没有遮挡的，所以如果遇到遮挡的问题怎么办？

       如果游戏中有100个物体，里面的物体相互遮挡关系总有一个顺序，为了简化问题，只考虑两个物体遮挡的情况，多个物体的遮挡可以根据这个来衍生。

物体A

物体B

考虑上图，物体B遮挡了物体A, 也就是说渲染顺序是先画A再画B，这个顺序由各自定义，（我自己就喜欢用一棵渲染树来排序，当然如果你用连表或者其他数据结构来实现也没有问题。）如果物体A的整个区域都需要更新，那么对于B物体，需要更新的部分也就只有A与B的交集部分（图中的蓝色区域)，在画B的时候，我们设置目标裁减区域（也就是屏幕缓冲的裁减区域）为这个交集部分，则B在渲染的时候，相当于整个缓冲区大小就只有蓝色区域那么大，那么裁减函数将会把B的数据区裁减到相应的位置（你实现的图形函数中不会没有做裁减的工作吧？？？如果没有实现，你就不用看了，直接return算了，不然下面的东西你肯定不明白我说什么）。怎么样，B物体相当于只画了蓝色区域这一部分的东西，比整个区域来说节约了不少时间吧？

       不知道上面说的你明白了没有，如果没有明白请多看几遍，直到弄明白之后再往下看，不然千万不要往下看。

       上面的例子大家肯定会问一个问题，我如何控制B只画蓝色区域的部分呢？这个问题我暂时不说，等到把所有的遮挡情况说完了再说。继续看另外的遮挡情况

X

A

C

D

E

B

上面6个物体A,B,C,D,E,X。X是我们的游戏背景颜色，假设画的顺序是EADCB,如果E需要重新画，那很显然，A,B,C,D不需要做什么

如果A,D都需要重新画，那显然A,D只需要各画一次。而B需要更新的，不是需要更新BD相交的区域，而是AB相交的大区域，也就是说小区域该忽略掉，如果B需要重新画，A,D,C需要重新画吗？也许有人会说，B画的次序是在最后的，所以前面的就不需要画了，对么？答案是错的，需要重新画，因为背景缓冲区我们一般情况下不去清除它，所以谈不上画的顺序了。也就是说，A与B相交的部分，A在下次画的时候也需要更新，D也同样(想通了吗？再举一个例子，如果B含有大量的透明色，如果B需要更新的话，那么B的区域首先要涂上X作为背景，不然B非透明色如果变成了透明色的话，那B在重新画的时候，由于透明色不需要画，那么B上一次留下来的颜色就残留在X上面，看起来当然不对啦，同理对于A,D也一样处理）。

       上面的理论部分不知道听明白了没有，如果不明白的话自己花一点点时间去想象看。假如明白了的话，下面继续更加深入的问题。

       从上面的理论解说部分可以看出，脏矩形的选取和优化是关键。怎样得到最优化的脏矩形表，就成为了这个技术优化的核心部分。

       为了简单起见，这里使用的是一个链表来管理所有的渲染物体。

       为了实现我们所设计的东西，我设计了一个非常简单的类：

       class CRenderObject

       {

       public:

              virtual ~CRenderObject(){}

              virtual void OnRender( GraphicsDevice*pDevice ) = 0; //所有物体都在这里渲染

              virtual void OnUpdate( float TimeStamp ) = 0;//物体更新，比如动画帧更新拉之类的，在这里面可以设置DirtyRect标志之类的

              virtual bool IsDirty( ) = 0;//是否有脏矩形

              virtual bool GetBoundsRect(RECT*pRect) =0;//得到该物体的范围

              virtual int GetDirtyRects ( RECT*pRectBuffer ) = 0;//该物体的脏矩形个数，填充到pRectBuffer里面，返回填充了多少个

              ...其他函数

       };

我们还需要一个简单的能管理脏矩形和渲染物体的类

class CRenderObjectManager

{

pulibc:

       void RemoveRenderObject( CRenderObject*pObject );//删除一个渲染物体

       void AddRenderObject( CRenderObject*pObject );//添加一个渲染物体

       void Render( GraphicsDevice*pDevice );//渲染所有的物体

       void Update( );//更新所有物体

       .....其他函数

protected:

       std::list< CRenderObject* >                 m_RenderObjects;

       int                                                    m_nCurrentDirtyRectCount;//当前脏矩形数量

       struct DirtyRect

       {

              RECT            Range;                  //脏矩形范围

              int                  AreaSize;               //脏矩形大小，用来排序

       };

       BOOL                                               m_bHoleDirty;//是否全部脏了

       DirtyRect                                                 m_DirtyRects[128];//屏幕上最多的脏矩形数量，如果大于这个数量则认为屏幕所有范围都脏了
};

void CRenderObjectManager::Update()

{

       m_bHoleDirty = false;

       m_nCurrentDirtyRectCount = 0;

       static RECT DirtyRectBuffer[128];

       float TimeStamp = GetElapsedTime();

       for(std::list< CRenderObject* >::iterator it = m_RenderObjects.begin();

              it != m_RenderObjects.end(); it++)

       {

              CRenderObject*pObject = *it;
              pObject->OnUpdate( TimeStamp );

              if(m_bHoleDirty == false && pObject->IsDirty() )

              {

                     int Count = pObject->GetDirtyRects(DirtyRectBuffer);

                     for( i =0; i

                     {

                            对于该物体的每一个脏矩形DirtyRectBuffer[i]

                            如果DirtyRectBuffer[i]　没有在任何一个已有的脏矩形范围内

                            那么把这个脏矩形根据从大到小的顺序添加到脏矩形范围内，否则忽略这个脏矩形

                            　　　如果脏矩形数量已经大于设定的最大脏矩形范围，设置所有所有屏幕都脏了的标志，

                     }

              }

       }

       如果屏幕所有都脏了，填充背景颜色

       否则为每一个脏矩形填充背景颜色

}

void CRenderObjectManager::Render( GraphicsDevice* pGraphics)

{

       for(std::list< CRenderObject* >::iterator it = m_RenderObjects.begin();

              it != m_RenderObjects.end(); it++)

       {

              CRenderObject*pObject = *it;
              if(如果屏幕都脏了的标志已经设定）

              {

                     RECT rcBoundsRect = { 0, 0, 0, 0 };

                     if( pObject->GetBoundsRect( rcBoundsRect ) )

                     {

                            //设置屏幕裁减区域

                            pGraphics->SetClipper( &rcBoundsRect );

                     }

                     pObject->OnRender( pGraphics );

              }

              else

              {

                     RECT rcBoundsRect = { 0, 0, 0, 0 };

                     if( pObject->GetBoundsRect( rcBoundsRect ) )

                     {

                            //如果该物体的范围与脏矩形缓冲区的任何一个脏矩形有交集的话

                            for( int i=0; i

                            {

                                   RECT rcIntersect;

                                   if( ::IntersectRect( &rcIntersect, &m_DirtyRects[i].Range, &rcBoundsRect ) )

                                   {    

                                          //只画交集的部分

                                          pGraphics-> SetClipper ( &m_DirtyRects[i].Range );

                                          pObject->OnRender( pGraphics );

                                   }

                            }

                     }

              }

       ｝
}

好了，核心代码的伪代码就在这里，不知道大家看明白没有，当然我在这里上面实现的这种方法有一个缺陷，最坏情况下一个也许会导致重新画很多次，如图的情况：

A

B

C

D

E

假设A是渲染物体，B,C,D,E是由大到小的脏矩形范围，那么很显然，重叠的部分就被反复画。。。这是在分割脏矩形导致的问题，这样画下来，如果A物体是采用了叠加混合到背景的算法的话，问题就出来了，重画的部分会变得非常亮。所以脏矩形的分割就显得非常重要，也就是说把这些脏矩形还要分割为互相独立的互不相交的矩形，至于分割算法嘛，嘿嘿，各位还是动一下脑筋思考思考吧：）这个也是最值得优化的地方了，哈哈。实在想不出的话，最简单的方法就是把彼此相交的脏矩形都做一个合并，得到更大的脏矩形，虽然没有相交的区域了，但是也许这个脏矩形会变得比较大了哦：）

       最后，大家一定关心的是我会不会提供源代码，很抱歉的说，不能。我在我的引擎中实现的不是以简单的链表去做的，用的是一棵比较复杂的渲染树，牵扯到的东西就比较多了，所以不方便提供代码，不过可以给一个演示吧：）再说大家如果真的明白了我所说的，那就可以自己动手写一下嘛，不要怕失败/P^_^,

       好啦，关于脏矩形的技术就介绍到这里啦，用好这个技术你会发现你的游戏会在配置极低的机器上也能运行如飞的：）这种技术如果能用在现在市面上的那么多的游戏中的话，就不必为一个小游戏就强占了您１００％的CPU资源而烦恼拉：）

       如果您有更好的方法或者指出其中的不完善的地方还请您不吝赐教，大家多多交流：）

关于测试的Demo

该Demo渲染部分由Kylinx花了近半年的时间，全部采用MMX写成，已经成功实现d3d中对2d纹理的操作，速度非常快

关于Settings.ini

EnableDirtyRect = 1      //是否允许脏矩形技术，0=关闭，1=开启

LockFPS = 1         //是否锁定FPS，0=关闭，1=开启

哈，这个Demo在不锁定FPS,脏技术开启的的情况下，我的Duron1.8G CPU,FPS达到 31500左右！（没错，是三万一千五百）这个数字吓人吧？如果脏技术未打开，只能在150左右，相差200倍阿！！！

如果LockFPS开启，在我机器上（512M DDR)跑30个DEMO,CPU占用还是为0，哈哈！

加一些C++源码：

1 canvas.h
2 #ifndef _DIRTYRECT_CANVAS_H
3  #define _DIRTYRECT_CANVAS_H
4
5  #define CANVAS_BLOCK_WIDTH 64
6  #define CANVAS_BLOCK_HEIGHT 32
7  #define DIRTY (~0)
8
9 typedef unsigned short pixel;
10 typedef void (*draw_func)(pixel *ptr,int pitch,void *object,int x,int y);
11  struct canvas;
12
13  #define COMMON_HEADER \
14 unsigned dirty; \
15 int width; \
16 int height; \
17 int kx; \
18 int ky;
19
20  struct canvas* canvas_create(int w,int h,pixel *ptr,int pitch,draw_func flip,void *flip_object);
21  void canvas_release(struct canvas *c);
22  void canvas_draw(struct canvas *c,draw_func func,void *object,int x,int y);
23 void canvas_update(struct canvas *c);
24 void canvas_redraw(struct canvas *c);
25
26 #endif
27

1 canvas.c
2 #include < malloc.h >
3 #include < assert.h >
4 #include < string .h >
5 #include " canvas.h "
6
7 #define CANVAS_PIPELINE_EXPAND 32
8
9 struct pipe_node {
10 draw_func func;
11 void * object ;
12 int x;
13 int y;
14 };
15
16 struct canvas_block {
17 pixel * ptr;
18 struct pipe_node * pipeline;
19 int total_object;
20 int total_last;
21 int capability_pipeline;
22 };
23
24 struct canvas {
25 int width;
26 int height;
27 int pitch;
28 int block_w;
29 int block_h;
30 struct canvas_block block[ 1 ];
31 };
32
33 static void drawfunc_clear(pixel * ptr, int pitch, void * object , int x, int y)
34 {
35 int i;
36 for (i = 0 ;i < CANVAS_BLOCK_HEIGHT;i ++ ) {
37 memset(ptr, 0 ,CANVAS_BLOCK_WIDTH * sizeof (pixel));
38 ptr = (pixel * )(( char * )ptr + pitch);
39 }
40 }
41
42 static void canvas_block_resize( struct canvas_block * blk)
43 {
44 const int size = blk -> capability_pipeline + CANVAS_PIPELINE_EXPAND;
45 const int newsize = size * sizeof ( struct pipe_node);
46 blk -> capability_pipeline = size;
47 blk -> pipeline = ( struct pipe_node * )realloc(blk -> pipeline,newsize);
48 }
49
50 static void canvas_init( struct canvas * c,pixel * ptr,draw_func flip, void * flip_object)
51 {
52 int pitch = c -> pitch * CANVAS_BLOCK_HEIGHT;
53 int i,j;
54 const int w = c -> width;
55 const int h = c -> height;
56 pixel * line = ptr;
57 struct canvas_block * block = c -> block;
58 for (i = 0 ;i < h;i += CANVAS_BLOCK_HEIGHT) {
59 for (j = 0 ;j < w;j += CANVAS_BLOCK_WIDTH) {
60 block -> ptr = line + j;
61 block -> pipeline = 0 ;
62 block -> capability_pipeline = 0 ;
63 canvas_block_resize(block);
64 block -> total_object = 1 ;
65 block -> total_last = 0 ;
66 block -> pipeline[ 0 ].func = flip;
67 block -> pipeline[ 0 ]. object = flip_object;
68 block -> pipeline[ 0 ].x = j;
69 block -> pipeline[ 0 ].y = i;
70 ++ block;
71 }
72 line = (pixel * )(( char * )line + pitch);
73 }
74 }
75
76 struct canvas * canvas_create( int w, int h,pixel * ptr, int pitch,draw_func flip, void * flip_object)
77 {
78 const int nw = (w + CANVAS_BLOCK_WIDTH - 1 ) / CANVAS_BLOCK_WIDTH;
79 const int nh = (h + CANVAS_BLOCK_HEIGHT - 1 ) / CANVAS_BLOCK_HEIGHT;
80 struct canvas * c = ( struct canvas * )malloc(
81 sizeof ( struct canvas) - sizeof ( struct canvas_block) +
82 sizeof ( struct canvas_block) * (nw * nh)
83 );
84
85 c -> width = w;
86 c -> height = h;
87 c -> block_w = nw;
88 c -> block_h = nh;
89 c -> pitch = pitch;
90 canvas_init(c,ptr,flip,flip_object);
91 return c;
92 }
93
94 void canvas_release( struct canvas * c)
95 {
96 int i,j;
97 const int w = c -> block_w;
98 const int h = c -> block_h;
99 struct canvas_block * block = c -> block;
100 for (i = 0 ;i < h;i ++ ) {
101 for (j = 0 ;j < w;j ++ ) {
102 free(block -> pipeline);
103 ++ block;
104 }
105 }
106 free(c);
107 }
108
109 struct object_2d { COMMON_HEADER } ;
110
111 void canvas_draw( struct canvas * c,draw_func func, void * object , int x, int y)
112 {
113 struct object_2d * obj = ( struct object_2d * ) object ;
114 int left,right,top,bottom;
115 unsigned dirty = obj -> dirty;
116 if (obj -> width <= 0 || obj -> height <= 0 )
117 return ;
118 obj -> dirty = 0 ;
119 left = (x -= obj -> kx);
120 top = (y -= obj -> ky);
121 right = left + obj -> width - 1 ;
122 bottom = top + obj -> height - 1 ;
123
124 // clip to canvas
125 if (left < 0 ) {
126 left = 0 ;
127 }
128 else if (left >= c -> width) {
129 return ;
130 }
131 if (top < 0 ) {
132 top = 0 ;
133 }
134 else if (top >= c -> height) {
135 return ;
136 }
137 if (right > c -> width - 1 ) {
138 right = c -> width - 1 ;
139 }
140 else if (right < 0 ) {
141 return ;
142 }
143 if (bottom > c -> height - 1 ) {
144 bottom = c -> height - 1 ;
145 }
146 else if (bottom < 0 ) {
147 return ;
148 }
149
150 // splite to blocks
151 do {
152 int i,j;
153 int w = right / CANVAS_BLOCK_WIDTH;
154 int h = bottom / CANVAS_BLOCK_HEIGHT;
155 int from_x = left / CANVAS_BLOCK_WIDTH;
156 int from_y = top / CANVAS_BLOCK_HEIGHT;
157 struct canvas_block * block =& c -> block[from_y * c -> block_w];
158 for (i = from_y;i <= h;i ++ ) {
159 for (j = from_x;j <= w;j ++ ) {
160 struct canvas_block * blk =& block[j];
161 struct pipe_node * node;
162 if (blk -> total_object == blk -> capability_pipeline) {
163 canvas_block_resize(blk);
164 }
165 node =& blk -> pipeline[blk -> total_object ++ ];
166 node -> func = func;
167 node -> object = object ;
168 node -> x = x - j * CANVAS_BLOCK_WIDTH;
169 node -> y = y - i * CANVAS_BLOCK_HEIGHT;
170 blk -> total_last |= dirty;
171 }
172 block += c -> block_w;
173 }
174 } while ( 0 );
175 }
176
177 void canvas_update( struct canvas * c)
178 {
179 int i,j;
180 struct canvas_block * blk = c -> block;
181 int pitch = c -> pitch;
182 for (i = c -> block_w * c -> block_h;i > 0 ; -- i, ++ blk) {
183 if (blk -> total_object != blk -> total_last) {
184 pixel * ptr = blk -> ptr;
185 drawfunc_clear(ptr,pitch, 0 , 0 , 0 );
186 for (j = blk -> total_object - 1 ;j >= 0 ;j -- ) {
187 struct pipe_node * node =& blk -> pipeline[j];
188 node -> func(ptr,pitch,node -> object ,node -> x,node -> y);
189 }
190 blk -> total_last = blk -> total_object;
191 }
192 blk -> total_object = 1 ;
193 }
194 }
195
196 void canvas_redraw( struct canvas * c)
197 {
198 int i;
199 struct canvas_block * blk = c -> block;
200 int pitch = c -> pitch;
201 for (i = c -> block_w * c -> block_h;i > 0 ; -- i, ++ blk) {
202 blk -> total_last = 0 ;
203 }
204 }

1 box.h
2 #ifndef _DIRTYRECT_BOX_H
3 #define _DIRTYRECT_BOX_H
4
5 #include " canvas.h "
6
7 struct box {
8 COMMON_HEADER
9 pixel color;
10 };
11
12 void box_draw( struct canvas * c, struct box * b, int x, int y);
13
14 #endif
15

1 box.c
2 #include " box.h "
3
4 static void draw_box(pixel * ptr, int pitch, void * object , int x, int y)
5 {
6 struct box * obj = ( struct box * ) object ;
7 int w = obj -> width;
8 int h = obj -> height;
9 int i,j;
10 pixel * buffer = ptr;
11 pixel color = obj -> color;
12 if (y < 0 ) {
13 h += y;
14 y = 0 ;
15 }
16 else {
17 buffer = (pixel * )(( char * )buffer + y * pitch);
18 }
19 if (x < 0 ) {
20 w += x;
21 x = 0 ;
22 }
23 else {
24 buffer += x;
25 }
26 if (w + x > CANVAS_BLOCK_WIDTH) {
27 w = CANVAS_BLOCK_WIDTH - x;
28 }
29 if (h + y > CANVAS_BLOCK_HEIGHT) {
30 h = CANVAS_BLOCK_HEIGHT - y;
31 }
32 for (i = 0 ;i < h;i ++ ) {
33 for (j = 0 ;j < w;j ++ ) {
34 buffer[j] = color;
35 }
36 buffer = (pixel * )(( char * )buffer + pitch);
37 }
38 }
39
40 void box_draw( struct canvas * c, struct box * b, int x, int y)
41 {
42 canvas_draw(c,draw_box,b,x,y);
43 }

1 gdi.h
2 #ifndef _DIRTYRECT_FLIPGDI_H
3 #define _DIRTYRECT_FLIPGDI_H
4
5 #include " canvas.h "
6
7 struct gdi {
8 draw_func flip;
9 void * object ;
10 pixel * buffer;
11 int width;
12 int height;
13 int pitch;
14 };
15
16 void gdi_create( struct gdi * g, void * wnd, int w, int h);
17 void gdi_release( struct gdi * g);
18
19 #endif
20

1 gdi.c
2 #include " gdi.h "
3 #include < windows.h >
4 #include < malloc.h >
5 #include < string .h >
6
7 struct gdi_object {
8 HWND wnd;
9 HDC dc;
10 BITMAPINFO bi;
11 RGBQUAD pal[ 2 ];
12 };
13
14 static void gdi_flip(pixel * ptr, int pitch, void * object , int x, int y)
15 {
16 struct gdi_object * obj = ( struct gdi_object * ) object ;
17 SetDIBitsToDevice(obj -> dc,
18 x,y,CANVAS_BLOCK_WIDTH,CANVAS_BLOCK_HEIGHT,
19 x, 0 ,
20 0 ,CANVAS_BLOCK_HEIGHT,
21 ptr - x, & (obj -> bi),DIB_RGB_COLORS
22 );
23 }
24
25 void gdi_create( struct gdi * g, void * wnd, int w, int h)
26 {
27 struct gdi_object * obj;
28 BITMAPINFOHEADER * bh;
29 g -> pitch = (w * sizeof (pixel) + 3 ) & ( ~ 3 );
30 g -> flip = gdi_flip;
31 g -> buffer = (pixel * )malloc(h * g -> pitch);
32 g -> object = obj = ( struct gdi_object * )malloc( sizeof ( struct gdi_object));
33 g -> width = w;
34 g -> height = h;
35 obj -> wnd = (HWND)wnd;
36 obj -> dc = GetDC(obj -> wnd);
37 bh =& (obj -> bi.bmiHeader);
38 memset(bh, 0 , sizeof ( * bh));
39 bh -> biSize = sizeof ( * bh);
40 bh -> biWidth = g -> pitch / sizeof (pixel);
41 bh -> biHeight =- CANVAS_BLOCK_HEIGHT;
42 bh -> biPlanes = 1 ;
43 bh -> biBitCount = sizeof (pixel) * 8 ;
44 bh -> biCompression = BI_BITFIELDS;
45 * ( int * )(obj -> bi.bmiColors + 0 ) = 0xf800 ;
46 * ( int * )(obj -> bi.bmiColors + 1 ) = 0x7e0 ;
47 * ( int * )(obj -> bi.bmiColors + 2 ) = 0x1f ;
48 }
49
50 void gdi_release( struct gdi * g)
51 {
52 struct gdi_object * obj = ( struct gdi_object * )g -> object ;
53 ReleaseDC(obj -> wnd,obj -> dc);
54 free(g -> buffer);
55 free(g -> object );
56 }

1 test.c
2 #include < windows.h >
3 #include " gdi.h "
4 #include " canvas.h "
5 #include " box.h "
6
7 #define WIDTH 640
8 #define HEIGHT 480
9
10 struct gdi g_gdi;
11 struct canvas * g_canvas;
12
13 HINSTANCE hInst; // current instance
14
15 ATOM MyRegisterClass();
16 BOOL InitInstance();
17 LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
18
19 int main()
20 {
21 int i;
22 MSG msg;
23 struct box b;
24 hInst = GetModuleHandle( 0 ); // Store instance handle in our global variable
25 MyRegisterClass();
26
27 if ( ! InitInstance ()) {
28 return FALSE;
29 }
30 b.kx = 0 ;
31 b.ky = 0 ;
32 b.width = 100 ;
33 b.height = 100 ;
34 b.color = 0xffff ;
35 b.dirty = DIRTY;
36
37 // Main message loop:
38 i = 0 ;
39 for (;;) {
40 if (PeekMessage( & msg,NULL, 0 , 0 ,PM_NOREMOVE)) {
41 if ( ! GetMessage( & msg,NULL, 0 , 0 )) {
42 break ;
43 }
44 TranslateMessage( & msg);
45 DispatchMessage( & msg);
46 }
47 b.dirty = DIRTY;
48 box_draw(g_canvas, & b,i,i);
49 canvas_update(g_canvas);
50 ++ i;
51 Sleep( 5 );
52 }
53
54
55 gdi_release( & g_gdi);
56 canvas_release(g_canvas);
57
58 return msg.wParam;
59 }
60
61 ATOM MyRegisterClass()
62 {
63 WNDCLASS wc;
64
65 wc.style = CS_HREDRAW | CS_VREDRAW;
66 wc.lpfnWndProc = (WNDPROC)WndProc;
67 wc.cbClsExtra = 0 ;
68 wc.cbWndExtra = 0 ;
69 wc.hInstance = hInst;
70 wc.hIcon = NULL;
71 wc.hCursor = LoadCursor(NULL, IDC_ARROW);
72 wc.hbrBackground = NULL;
73 wc.lpszMenuName = NULL;
74 wc.lpszClassName = " TEST " ;
75
76 return RegisterClass( & wc);
77 }
78
79 BOOL InitInstance()
80 {
81 HWND hWnd;
82 DWORD style = WS_OVERLAPPEDWINDOW &~ WS_SIZEBOX &~ WS_MAXIMIZEBOX;
83 RECT rect = { 0 , 0 ,WIDTH,HEIGHT};
84 AdjustWindowRect( & rect,style,FALSE);
85
86 hWnd = CreateWindow( " TEST " , " test " ,
87 style, CW_USEDEFAULT, 0 ,
88 rect.right - rect.left,rect.bottom - rect.top,
89 0 , 0 ,hInst, 0 );
90
91
92 if ( ! hWnd)
93 {
94 return FALSE;
95 }
96
97 gdi_create( & g_gdi,hWnd,WIDTH,HEIGHT);
98 g_canvas = canvas_create(g_gdi.width,g_gdi.height,
99 g_gdi.buffer,g_gdi.pitch,g_gdi.flip,g_gdi. object );
100
101 ShowWindow(hWnd, SW_SHOWDEFAULT);
102 UpdateWindow(hWnd);
103
104 return TRUE;
105 }
106
107 LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
108 {
109 switch (message)
110 {
111 case WM_PAINT:
112 canvas_redraw(g_canvas);
113 break ;
114 case WM_DESTROY:
115 PostQuitMessage( 0 );
116 break ;
117 default :
118 return DefWindowProc(hWnd, message, wParam, lParam);
119 }
120 return 0 ;
121 }

转载于:https://www.cnblogs.com/GameDeveloper/archive/2011/05/25/2056501.html