T3D图形库(四)

 DDraw及图形算法库文件部分

 

1. /*2008.9.16
2. T3D图形库
3. ——<<windows游戏
4. 编程大师技巧>>
5. */
7. //DDraw_lib.cpp
9. // INCLUDES ///////////////////////////////////////////////
11. #include <windows.h>
12. #include <windowsx.h>
13. #include <mmsystem.h> //多媒体API
14. #include <iostream.h>
15. #include <conio.h>    //控制台IO支持
16. #include <stdlib.h>   //声明定义的一些常用标准函数库
17. #include <malloc.h>   //声明或定义一些内存的函数
18. #include <memory.h>   //提供了内存操作相关的一些函数及声明
19. #include <string.h>   //字符串的一些功能
20. #include <stdarg.h>   //应付可变参数
21. #include <stdio.h>    //efinitions/declarations for standard I/O routines
22. #include <math.h>     //一些数学方法
23. #include <io.h>       //declarations for low-level file handling and I/O functions
24. #include <fcntl.h>    //文件控制操作
25. #include <sys/timeb.h>//附加的日期和时间定义
26. #include <time.h>     //时间操作函数库
28. #include <ddraw.h>
29. #include "DDraw_lib.h"
31. // DEFINES ////////////////////////////////////////////////
33. // TYPES //////////////////////////////////////////////////
35. // PROTOTYPES /////////////////////////////////////////////
37. // EXTERNALS /////////////////////////////////////////////
39. extern HWND main_window_handle;
40. extern HINSTANCE main_instance;
42. // GLOBALS ////////////////////////////////////////////////
44. FILE *fp_error = NULL;
45. char error_filename[80];
47. //DirectDraw 接口指针
48. LPDIRECTDRAW7         lpdd =NULL;
49. LPDIRECTDRAWSURFACE7  lpddsprimary =NULL;
50. LPDIRECTDRAWSURFACE7  lpddsback =NULL;
51. LPDIRECTDRAWPALETTE   lpddpal =NULL;
52. LPDIRECTDRAWCLIPPER   lpddclipper =NULL;
53. LPDIRECTDRAWCLIPPER   lpddclipperwin =NULL;
55. PALETTEENTRY          palette[MAX_COLORS_PALETTE];
56. PALETTEENTRY          save_palette[MAX_COLORS_PALETTE];
57. DDSURFACEDESC2        ddsd;
58. DDBLTFX               ddbltfx;
59. DDSCAPS2              ddscaps;
60. HRESULT               ddrval;
61. UCHAR                 *primary_buffer = NULL;   //主缓冲
62. UCHAR                 *back_buffer    = NULL;   //后备缓冲
63. int                   primary_lpitch  = 0;      //主缓冲内存行距
64. int                   back_lpitch     = 0;      //后备缓冲内存行距
66. BITMAP_FILE           bitmap8bit;
67. BITMAP_FILE           bitmap16bit;
68. BITMAP_FILE           bitmap24bit;
70. DWORD                 start_clock_count = 0;
71. int                   windowed_mode     = FALSE;
73. //裁剪矩形
74. int min_clip_x = 0,
75.     max_clip_x = (SCREEN_WIDTH-1),
76.     min_clip_y = 0,
77.     max_clip_y = (SCREEN_HEIGHT-1);
79. //屏幕相关信息,被DDraw_Init()重写
80. int screen_width    =SCREEN_WIDTH,
81.     screen_height   =SCREEN_HEIGHT,
82.     screen_bpp      =SCREEN_BPP,
83.     screen_windowed =0;
85. int dd_pixel_format =DD_PIXEL_FORMAT565;  //默认像素格式
87. int window_client_x0  = 0;  //DirectDraw下窗口模式客户区起始地址坐标
88. int window_client_y0  = 0;
90. float cos_look[361];  //存储相应角度对应的弧度
91. float sin_look[361];
93. //函数指针
94. USHORT (*RGB16Bit)(int r,int g,int b) =NULL;
96. // FUNCTIONS //////////////////////////////////////////////
98. USHORT RGB16Bit565(int r,int g,int b)
99. {
100.   r>>=3; g>>=2; b>>=3;
101.   return(_RGB16BIT565((r),(g),(b)));
102. }
104. USHORT RGB16Bit555(int r, int g, int b)
105. {
106.   r>>=3; g>>=3; b>>=3;
107.   return(_RGB16BIT555((r),(g),(b)));
108. }
110. inline void Mem_Set_WORD(void *dest,USHORT data,int count)
111. {
112.   //把无符号16位data数据分count次传输到dest地址
113.   _asm
114.   {
115.     mov edi,dest ;
116.     mov ecx,count;
117.     mov ax, data ;
118.     rep stosw    ;
119.   }
120. }
122. inline void Mem_Set_QUAD(void *dest, UINT data, int count)
123. {
124.   //把无符号32位data数据分count次传输到dest地址
125.   _asm
126.   {
127.     mov edi, dest ;
128.     mov ecx, count;
129.     mov eax, data ;
130.     rep stosd     ;
131.   }
132. }
134. LPDIRECTDRAWSURFACE7 DDraw_Create_Surface(int width, int height, 
135.                                           int mem_flags/* =0 */, 
136.                                           USHORT color_key_value/* =0 */)
137. {
138.   DDSURFACEDESC2 ddsd;
139.   LPDIRECTDRAWSURFACE7 lpdds;
140.   DDRAW_INIT_STRUCT(ddsd);  //初始化ddsd
141.   ddsd.dwFlags=DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT; //设置有效标志
142.   
143.   ddsd.dwWidth=width;
144.   ddsd.dwHeight=height;
146.   ddsd.ddsCaps.dwCaps=DDSCAPS_OFFSCREENPLAIN | mem_flags; //设置属性
147.   
148.   if(FAILED(lpdd->CreateSurface(&ddsd,&lpdds,NULL)))  //创造表面
149.     return(NULL);
151.   DDCOLORKEY color_key;
152.   color_key.dwColorSpaceLowValue=color_key_value;
153.   color_key.dwColorSpaceHighValue=color_key_value;
154.   
155.   lpdds->SetColorKey(DDCKEY_SRCBLT,&color_key);   //设置透明色键
157.   return(lpdds);
158. }
160. int DDraw_Init(int width, int height, int bpp, int windowed)
161. {
162.   int index;
164.   if(FAILED(DirectDrawCreateEx(NULL,(void **)&lpdd,IID_IDirectDraw7,NULL)))
165.     return(0);
166.   
167.   if (windowed)
168.   {
169.     //设置协作模式(窗口模式)
170.     if (FAILED(lpdd->SetCooperativeLevel(main_window_handle,DDSCL_NORMAL)))
171.       return(0);
173.   }
175.   else
176.   {
177.     //设置协作模式(全屏模式)
178.     if (FAILED(lpdd->SetCooperativeLevel(main_window_handle,
179.                 DDSCL_ALLOWMODEX | DDSCL_FULLSCREEN |
180.                 DDSCL_EXCLUSIVE | DDSCL_ALLOWMODEX | DDSCL_MULTITHREADED)))
181.       return(0);
182.     //设置显示模式
183.     if (FAILED(lpdd->SetDisplayMode(width,height,bpp,0,0)))
184.       return(0);
185.   }
187. //设置全局变量
188. screen_height  =height;
189. screen_width   =width ;
190. screen_bpp     =bpp;
191. screen_windowed=windowed;
193. //初始化DDSURFACEDESC2结构体
194. memset(&ddsd,0,sizeof(ddsd));
195. ddsd.dwSize=sizeof(ddsd);
197. if(!screen_windowed)
198.   {
199.     //全屏模式
200.     ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
201.     ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_FLIP | DDSCAPS_COMPLEX;
203.     //设置后备缓冲数——窗口模式为0，全屏模式(双缓冲)为1，三缓冲为2
204.     ddsd.dwBackBufferCount=1;
205.   }
206. else
207.   {
208.     //窗口模式
209.     ddsd.dwFlags=DDSD_CAPS;
210.     ddsd.ddsCaps.dwCaps=DDSCAPS_PRIMARYSURFACE;
211.     ddsd.dwBackBufferCount=0;
212.   }
213.   
214. //创造主显示表面
215. lpdd->CreateSurface(&ddsd,&lpddsprimary,NULL);
217. //取得主显示表面的像素格式
219. DDPIXELFORMAT ddpf;
220. //初始化ddpf
221. DDRAW_INIT_STRUCT(ddpf);
222. //从主表面取得格式
223. lpddsprimary->GetPixelFormat(&ddpf);
225. dd_pixel_format=ddpf.dwRGBBitCount;
227. Write_Error("/npixel format = %d",dd_pixel_format);
229. //确定16位RGB格式(1.5.5.5或5.6.5)
231. if (dd_pixel_format==DD_PIXEL_FORMAT555)
232.   {
233.     RGB16Bit = RGB16Bit555;
234.     Write_Error("/npixel format = 5.5.5");
235.   }
236. else
237.   {
238.     RGB16Bit = RGB16Bit565;
239.     Write_Error("/npixel format = 5.6.5");
240.   }
244. if (!screen_windowed)
245.   {//全屏模式下需要一个后备缓冲
246.     ddscaps.dwCaps=DDSCAPS_BACKBUFFER;
247.     if(FAILED(lpddsprimary->GetAttachedSurface(&ddscaps,&lpddsback)))
248.       return(0);
249.   }
250. else
251.   {//否则创造一个离屏表面
252.     lpddsback=DDraw_Create_Surface(width,height);
253.   }
255. //创造一个调色板(仅适用8位模式)
256. if (screen_bpp=DD_PIXEL_FORMAT8)
257.   {
258.     memset(palette,0,MAX_COLORS_PALETTE*sizeof(PALETTEENTRY));
259.     //从文件中加载调色板项到palette
260.     Load_Palette_From_File(DEFAULT_PALETTE_FILE,palette);
262.     if (screen_windowed)
263.     { 
264.       //窗口模式,则调色板前/后10个索引设置为windows桌面颜色
265.       for (index=0;index<10;index++)
266.         palette[index].peFlags=palette[index+246].peFlags=PC_EXPLICIT;
267.       //创建调色板接口lpddpal(不允许256个索引)
268.       if(FAILED(lpdd->CreatePalette(DDPCAPS_8BIT | DDPCAPS_INITIALIZE,
269.                                     palette,&lpddpal,NULL)))
270.         return(0);  
271.     }
272.     else
273.     {
274.       //全屏模式
275.       if(FAILED(lpdd->CreatePalette(DDPCAPS_8BIT | DDPCAPS_INITIALIZE | DDPCAPS_ALLOW256,
276.                                     palette,&lpddpal,NULL)))
277.         return(0);  
278.     }
279.     //将调色板接口关联到主显示表面
280.     if(FAILED(lpddsprimary->SetPalette(lpddpal)))
281.       return(0);
282.   }
283.   
284. //清空主/从显示表面
285. if (screen_windowed)
286.   {
287.      DDraw_Fill_Surface(lpddsback,0);
288.   }
289. else
290.   {
291.     DDraw_Fill_Surface(lpddsprimary,0);
292.     DDraw_Fill_Surface(lpddsback,0);
293.   }
295. //设置裁剪矩形(软件模拟算法时用)
296. min_clip_x = 0;
297. max_clip_x = screen_width-1;
298. min_clip_y = 0;
299. max_clip_y = screen_height-1;
301. //设置后备缓冲裁剪矩形(用于接口)
302. RECT screen_rect = { 0,0,screen_width,screen_height };
303. //创建后备缓冲裁剪器
304. if(FAILED(lpddclipper = DDraw_Attach_Clipper(lpddsback,1,&screen_rect)))
305.   return(0);
306. //创建窗口模式裁剪器
307. if (screen_windowed)
308.   {
309.     if(FAILED(lpdd->CreateClipper(0,&lpddclipperwin,NULL)))
310.       return(0);
311.     if(FAILED(lpddclipperwin->SetHWnd(0,main_window_handle)))
312.       return(0);
313.     if(FAILED(lpddsprimary->SetClipper(lpddclipperwin)))
314.       return(0);
315.   }
317. return(1);
319. }
321. int DDraw_Shutdown(void)
322. {
323.   //释放申请的directdraw资源
324.   //首先释放裁剪器
325.   if(lpddclipper)
326.     lpddclipper->Release();
328.   if(lpddclipperwin)
329.     lpddclipperwin->Release();
331.   //释放调色板
332.   if(lpddpal)
333.     lpddpal->Release();
335.   //释放后备缓冲
336.   if(lpddsback)
337.     lpddsback->Release();
339.   //释放主缓冲
340.   if(lpddsprimary)
341.     lpddsprimary->Release();
343.   //释放directdraw对象
344.   if(lpdd)
345.     lpdd->Release();
347.   return(1);
348. }
351. LPDIRECTDRAWCLIPPER DDraw_Attach_Clipper(LPDIRECTDRAWSURFACE7 lpdds, 
352.                                          int num_rects,
353.                                          LPRECT clip_list)
354. {
355.   int index;
356.   LPDIRECTDRAWCLIPPER lpddclipper;
357.   LPRGNDATA region_data;
358.   
359.   //创建裁剪器对象
360.   if(FAILED(lpdd->CreateClipper(0,&lpddclipper,NULL)))
361.     return(0);
363.   //创建裁剪序列
364.   region_data = (LPRGNDATA)malloc(sizeof(RGNDATAHEADER)+num_rects*sizeof(RECT));
366.   memcpy(region_data->Buffer,clip_list,sizeof(RECT)*num_rects);
368.   region_data->rdh.dwSize        =sizeof(RGNDATAHEADER);
369.   region_data->rdh.iType         =RDH_RECTANGLES;
370.   region_data->rdh.nCount        =num_rects;
371.   region_data->rdh.nRgnSize      =num_rects*sizeof(RECT);
372.   region_data->rdh.rcBound.left  =64000;
373.   region_data->rdh.rcBound.top   =64000;
374.   region_data->rdh.rcBound.right =-64000;
375.   region_data->rdh.rcBound.bottom=-64000;
377.   for (index=0; index<num_rects; index++)
378.     {
379.       //在所有RECT周围创建一个边界框并存储在rcBound中
380.     if (clip_list[index].left < region_data->rdh.rcBound.left)
381.        region_data->rdh.rcBound.left = clip_list[index].left;
383.     if (clip_list[index].right > region_data->rdh.rcBound.right)
384.        region_data->rdh.rcBound.right = clip_list[index].right;
386.     if (clip_list[index].top < region_data->rdh.rcBound.top)
387.        region_data->rdh.rcBound.top = clip_list[index].top;
389.     if (clip_list[index].bottom > region_data->rdh.rcBound.bottom)
390.        region_data->rdh.rcBound.bottom = clip_list[index].bottom;
392.     } 
393.   //将裁减序列发送给裁剪器
394.   if (FAILED(lpddclipper->SetClipList(region_data,0)))
395.   {
396.     free(region_data);
397.     return(NULL);
398.   }
399.   //将裁剪器与表面相关联
400.   if (FAILED(lpdds->SetClipper(lpddclipper)))
401.   {
402.     free(region_data);
403.     return(NULL);
404.   }
406.   free(region_data);
407.   return(lpddclipper);
409. }
411. int DDraw_Flip(void)
412. {
413.   //此函数切换主显示表面和第二表面(这里是后备缓冲)
415.   //测试表面是否被锁定
416.   if (primary_buffer||back_buffer)
417.     return(0);
419.   if(!screen_windowed)
420.     while (FAILED(lpddsprimary->Flip(NULL,DDFLIP_WAIT)));
421.   else
422.   {
423.     RECT dest_rect;
424.     //取得窗口矩形
425.     GetWindowRect(main_window_handle,&dest_rect);
426.     //确定窗口客户区坐标
427.     dest_rect.left   +=window_client_x0;
428.     dest_rect.top    +=window_client_y0;
430.     dest_rect.right  +=dest_rect.left+screen_width;
431.     dest_rect.bottom +=dest_rect.top+screen_height;
432.     //将后备缓冲blit到主缓冲的目标矩形内
433.     if(FAILED(lpddsprimary->Blt(&dest_rect,lpddsback,NULL,DDBLT_WAIT,NULL)))
434.       return(0);
435.   }
436.   
437.   return(1);
438. }
440. int DDraw_Wait_For_Vsync(void)
441. {
442.   //等待垂直刷新
443.   lpdd->WaitForVerticalBlank(DDWAITVB_BLOCKEND,0);
445.   return(1);
446. }
448. int DDraw_Fill_Surface(LPDIRECTDRAWSURFACE7 lpdds, USHORT color, RECT *client/* =NULL */)
449. {
450.   DDBLTFX ddbltfx;
452.   DDRAW_INIT_STRUCT(ddbltfx);
454.   ddbltfx.dwFillColor=color;
455.   //向目标表面的目标矩形(null为整个表面)填充颜色
456.   lpdds->Blt(client,
457.             NULL,
458.             NULL,
459.             DDBLT_WAIT | DDBLT_COLORFILL,
460.             &ddbltfx);
462.   return(1);
463. }
465. UCHAR* DDraw_Lock_Surface(LPDIRECTDRAWSURFACE7 lpdds,int *lpitch)
466. {
467.   //锁定表面
468.   //如果表面无效
469.   if(!lpdds)
470.     return(NULL);
471.   //表面有效,则锁定之
472.   DDRAW_INIT_STRUCT(ddsd);
473.   lpdds->Lock(NULL,&ddsd,DDLOCK_WAIT | DDLOCK_SURFACEMEMORYPTR,NULL);
475.   if(lpitch)
476.     *lpitch = ddsd.lPitch;
478.   //返回指向表面初始地址的指针
479.   return((UCHAR*)ddsd.lpSurface);
481. }
483. int DDraw_Unlock_Surface(LPDIRECTDRAWSURFACE7 lpdds)
484. {
485.   //解锁表面
487.   if(!lpdds)
488.     return(0);
490.   lpdds->Unlock(NULL);
492.   return(1);
493. }
495. UCHAR* DDraw_Lock_Primary_Surface(void)
496. {
497.   //如果已经被锁定(主缓冲首地址存在)
498.   if (primary_buffer)
499.   {
500.     return(primary_buffer);
501.   }
503.   DDRAW_INIT_STRUCT(ddsd);
504.   lpddsprimary->Lock(NULL,&ddsd,DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT,NULL);
506.   primary_buffer = (UCHAR*)ddsd.lpSurface;
507.   primary_lpitch = ddsd.lPitch;
509.   return(primary_buffer);
510. }
512. int DDraw_Unlock_Primary_Surface(void)
513. {
514.   //解锁主显示表面
516.   if (!primary_buffer)
517.     return(0);
519.   lpddsprimary->Unlock(NULL);
521.   primary_buffer = NULL;
522.   primary_lpitch = 0;
524.   return(1);
525. } 
527. UCHAR* DDraw_Lock_Back_Surface(void)
528. {
529.   //锁定后备显示表面
531.   if (back_buffer)
532.   {
533.     return(back_buffer);
534.   }
536.   DDRAW_INIT_STRUCT(ddsd);
537.   lpddsback->Lock(NULL,&ddsd,DDLOCK_WAIT | DDLOCK_SURFACEMEMORYPTR,NULL);
539.   back_buffer=(UCHAR*)ddsd.lpSurface;
540.   back_lpitch=ddsd.lPitch;
542.   return(back_buffer);
543. }
545. int DDraw_Unlock_Back_Surface(void)
546. {
547.   //解锁后备显示表面
549.   if (!back_buffer)
550.     return(0);
552.   lpddsback->Unlock(NULL);
554.   back_buffer=NULL;
555.   back_lpitch=0;
557.   return(1);
558. }
560. DWORD Get_Clock(void)
561. {
562.   //返回当前时间片
563.   return(GetTickCount());
564. }
566. DWORD Start_Clock(void)
567. {
568.   //记录开始时间
570.   return(start_clock_count=Get_Clock());
571. }
573. DWORD Wait_Clock(DWORD count)
574. {
575.   while((Get_Clock() - start_clock_count)<count);
576.   return(Get_Clock());
577. }
579. Draw_Clip_Line16(int x0,int y0,int x1,int y1,int color,
580.                  UCHAR* dest_buffer,int lpitch)
581. {
582.   //画经裁剪的直线(16位)
584.   int cxs,cys,cxe,cye;
585.   cxs=x0;
586.   cys=y0;
587.   cxe=x1;
588.   cye=y1;
589.   if(Clip_Line(cxs,cys,cxe,cye))
590.     Draw_Line16(cxs,cys,cxe,cye,color,dest_buffer,lpitch);
592.   return(1);
593. }
595. Draw_Clip_Line(int x0,int y0,int x1,int y1,int color,
596.                  UCHAR* dest_buffer,int lpitch)
597. {
598.   //画经裁剪的直线(8位)
600.   int cxs,cys,cxe,cye;
601.   cxs=x0;
602.   cys=y0;
603.   cxe=x1;
604.   cye=y1;
605.   if(Clip_Line(cxs,cys,cxe,cye))
606.     Draw_Line(cxs,cys,cxe,cye,color,dest_buffer,lpitch);
608.   return(1);
609. }
611. Clip_Line(int &x1,int &y1,int &x2,int &y2)
612. {
613.   //裁剪直线
615.   #define CLIP_CODE_C 0x0000
616.   #define CLIP_CODE_N 0x0008
617.   #define CLIP_CODE_S 0x0004
618.   #define CLIP_CODE_E 0x0002
619.   #define CLIP_CODE_W 0x0001
621.   #define CLIP_CODE_NE 0x000a
622.   #define CLIP_CODE_SE 0x0006
623.   #define CLIP_CODE_NW 0x0009
624.   #define CLIP_CODE_SW 0x0005
626.   int xc1=x1,
627.       yc1=y1,
628.       xc2=x2,
629.       yc2=y2;
630.   
631.   int p1_code=0,
632.       p2_code=0;
634.   //确定两点的位置
635.   if(y1<min_clip_y)
636.     p1_code|=CLIP_CODE_N;
637.   else
638.   if(y1>max_clip_y)
639.     p1_code|=CLIP_CODE_S;
640.   if(x1<min_clip_x)
641.     p1_code|=CLIP_CODE_W;
642.   else
643.   if(x1>max_clip_x)
644.     p1_code|=CLIP_CODE_E;
646.   if(y2<min_clip_y)
647.     p2_code|=CLIP_CODE_N;
648.   else
649.   if(y2>max_clip_y)
650.     p2_code|=CLIP_CODE_S;
651.   if(x2<min_clip_x)
652.     p2_code|=CLIP_CODE_W;
653.   else
654.   if(x2>max_clip_x)
655.     p2_code|=CLIP_CODE_E;
657.   //若两点在剪切区域外且在同一方向
658.   if((p1_code&p2_code))
659.     return(0);
661.   //若两点都在剪切区域内
662.   if(p1_code==0&&p2_code==0)
663.     return(1);
665.   switch(p1_code)
666.   {
667.   case CLIP_CODE_C: break;
669.   case CLIP_CODE_N:
670.     {
671.       yc1=min_clip_y;
672.       xc1=x1+(min_clip_y-y1)*(x2-x1)/(y2-y1);
673.     }break;
675.   case CLIP_CODE_S:
676.     {
677.       yc1=max_clip_y;
678.       xc1=x1+(max_clip_y-y1)*(x2-x1)/(y2-y1);
679.     }break;
681.   case CLIP_CODE_W:
682.     {
683.       xc1=min_clip_x;
684.       yc1=y1+(min_clip_x-x1)*(y2-y1)/(x2-x1);
685.     }break;
687.   case CLIP_CODE_E:
688.     {
689.       xc1=max_clip_x;
690.       yc1=y1+(max_clip_x-x1)*(y2-y1)/(x2-x1);
691.     }break;
693.   case CLIP_CODE_NE:
694.     {
695.       yc1=min_clip_y;
696.       xc1=x1+(min_clip_y-y1)*(x2-x1)/(y2-y1);
697.       if(xc1<min_clip_x||xc1>max_clip_x)
698.       {
699.         xc1=max_clip_x;
700.         yc1=y1+(max_clip_x-x1)*(y2-y1)/(x2-x1);
701.       }
702.     }break;
704.   case CLIP_CODE_SE:
705.     {
706.       yc1=max_clip_y;
707.       xc1=x1+(max_clip_y-y1)*(x2-x1)/(y2-y1);
708.       if(xc1<min_clip_x||xc1>max_clip_x)
709.       {
710.         xc1=max_clip_x;
711.         yc1=y1+(max_clip_x-x1)*(y2-y1)/(x2-x1);
712.       }
713.     }break;
715.   case CLIP_CODE_NW:
716.     {
717.       yc1=min_clip_y;
718.       xc1=x1+(min_clip_y-y1)*(x2-x1)/(y2-y1);
719.       if(xc1<min_clip_x||xc1>max_clip_x)
720.       {
721.         xc1=min_clip_x;
722.         yc1=y1+(min_clip_x-x1)*(y2-y1)/(x2-x1);
723.       }
724.     }break;
726.   case CLIP_CODE_SW:
727.     {
728.       yc1=max_clip_y;
729.       xc1=x1+(max_clip_y-y1)*(x2-x1)/(y2-y1);
730.       if(xc1<min_clip_x||xc2>max_clip_x)
731.       {
732.         xc1=min_clip_x;
733.         yc1=y1+(min_clip_x-x1)*(y2-y1)/(x2-x1);
734.       }
735.     }break;
736.     
737.   default:break;
738.     
739.   }
741.   switch(p2_code)
742.   {
743.   case CLIP_CODE_C: break;
745.   case CLIP_CODE_N:
746.     {
747.       yc2=min_clip_y;
748.       xc2=x2+(min_clip_y-y2)*(x2-x1)/(y2-y1);
749.     }break;
751.   case CLIP_CODE_S:
752.     {
753.       yc2=max_clip_y;
754.       xc2=x2+(max_clip_y-y2)*(x2-x1)/(y2-y1);
755.     }break;
757.   case CLIP_CODE_W:
758.     {
759.       xc2=min_clip_x;
760.       yc2=y2+(min_clip_x-x2)*(y2-y1)/(x2-x1);
761.     }break;
763.   case CLIP_CODE_E:
764.     {
765.       xc2=max_clip_x;
766.       yc2=y2+(max_clip_x-x2)*(y2-y1)/(x2-x1);
767.     }break;
769.   case CLIP_CODE_NE:
770.     {
771.       yc2=min_clip_y;
772.       xc2=x2+(min_clip_y-y2)*(x2-x1)/(y2-y1);
773.       if(xc2<min_clip_x||xc2>max_clip_x)
774.       {
775.         xc2=max_clip_x;
776.         yc2=y2+(max_clip_x-x2)*(y2-y1)/(x2-x1);
777.       }
778.     }break;
780.   case CLIP_CODE_SE:
781.     {
782.       yc2=max_clip_y;
783.       xc2=x2+(max_clip_y-y2)*(x2-x1)/(y2-y1);
784.       if(xc2<min_clip_x||xc2>max_clip_x)
785.       {
786.         xc2=max_clip_x;
787.         yc2=y2+(max_clip_x-x2)*(y2-y1)/(x2-x1);
788.       }
789.     }break;
791.   case CLIP_CODE_NW:
792.     {
793.       yc2=min_clip_y;
794.       xc2=x2+(min_clip_y-y2)*(x2-x1)/(y2-y1);
795.       if(xc2<min_clip_x||xc2>max_clip_x)
796.       {
797.         xc2=min_clip_x;
798.         yc2=y2+(min_clip_x-x2)*(y2-y1)/(x2-x1);
799.       }
800.     }break;
802.   case CLIP_CODE_SW:
803.     {
804.       yc2=max_clip_y;
805.       xc2=x2+(max_clip_y-y2)*(x2-x1)/(y2-y1);
806.       if(xc2<min_clip_x||xc2>max_clip_x)
807.       {
808.         xc2=min_clip_x;
809.         yc2=y2+(min_clip_x-x2)*(y2-y1)/(x2-x1);
810.       }
811.     }break;
812.     
813.   default:break;    
815.   }
817.   if( (xc1<min_clip_x)||(xc1>max_clip_x)||
818.     (yc1<min_clip_y)||(yc1>max_clip_y)||
819.     (xc2<min_clip_x)||(xc2>max_clip_x)||
820.     (yc2<min_clip_y)||(yc2>max_clip_y) )
821.   {//若经过裁剪仍有点在剪切区域外,
822.    //则剪切区域内不存在要画的直线
823.     return (0);
824.   }
825.   //否则修改直线的两个端点坐标
826.   x1=xc1;
827.   y1=yc1;
828.   x2=xc2;
829.   y2=yc2;
831.   return (1);
832. }
834. int Draw_Line(int x0,int y0,
835.               int x1,int y1,
836.               int color,
837.               UCHAR* vb_start,int lpitch)
838. {/*Bresenham算法画线*/
839.   int dx,
840.       dy,
841.       dx2,
842.       dy2,
843.       x_inc,
844.       y_inc,
845.       error,
846.       index;
848.   //取得直线的第一个点(像素)
849.   vb_start=vb_start+x0+y0*lpitch;
851.   dx=x1-x0;
852.   dy=y1-y0;
854.   if(dx>=0)
855.     x_inc=1;
856.   else
857.   {
858.     x_inc=-1;
859.     dx=-dx;
860.   }
861.   
862.   if(dy>=0)
863.     y_inc=lpitch;
864.   else
865.   {
866.     y_inc=-lpitch;
867.     dy=-dy;
868.   }
870.   dx2=dx<<1;
871.   dy2=dy<<1;
873.   if(dx>dy)
874.   {/*斜率<1的情况*/
875.     error=dy2-dx;
877.     for(index=0;index<=dx;index++)
878.     {
879.       *vb_start=color;
881.       if(error>=0)
882.       {
883.         error-=dx2;
884.         vb_start+=y_inc;  
885.       }
886.         error+=dy2;
887.         vb_start+=x_inc;
888.     }
889.   }
890.   else
891.   {/*斜率>1的情况*/
892.     error=dx2-dy;
893.     for(index=0;index<=dy;index++)
894.     {
895.       *vb_start=color;
896.       if(error>=0)
897.       {
898.         error-=dy2;
899.         vb_start+=x_inc;
900.       }
901.       error+=dx2;
902.       vb_start+=y_inc;
903.     }
904.   }
905.   
906.   return(1);
907. }
909. int Draw_Line16(int x0, int y0,
910.                 int x1,int y1, 
911.                 int color,
912.                 UCHAR *vb_start,int lpitch)
913. {
914.   int dx,
915.       dy,
916.       dx2,
917.       dy2,
918.       x_inc,
919.       y_inc,
920.       error,
921.       index;
923.   //将字节间距转换为USHORT间距
924.   int lpitch_2 = lpitch>>1;
926.   //确定直线首地址
927.   USHORT* vb_start2=(USHORT*)vb_start + x0 + y0*lpitch_2;
929.   dx = x1 - x0;
930.   dy = y1 - y0;
931.   
932.   if (dx>=0)
933.   {
934.     x_inc = 1;
935.   }
936.   else
937.   {
938.     x_inc = -1;
939.     dx = -dx;
940.   }
942.   if (dy>=0)
943.   {
944.     y_inc = lpitch_2;
945.   }
946.   else
947.   {
948.     y_inc = -lpitch_2;
949.     dy = -dy;
950.   }
952.   dx2 = dx<<1;
953.   dy2 = dy<<1;
955.   if (dx>dy)
956.   {
957.     //斜率小于1的情况
959.     error = dy2 - dx;
961.     for (index=0;index<=dx;index++)
962.     {
963.       //设置像素
964.       *vb_start2 = (USHORT)color;
966.       if (error>=0)
967.       {
968.         error-=dx2;
969.         vb_start2+=y_inc;
970.       }
972.       error+=dy2;
973.       vb_start2+=x_inc;
974.     }
975.   }
977.   else
978.   {
979.     //斜率大于1的情况
981.     error = dx2 -dy;
983.     for (index=0;index<=dy;index++)
984.     {
985.       *vb_start2 = (USHORT)color;
987.       if (error>=0)
988.       {
989.         error-=dy2;
990.         vb_start2+=x_inc;
991.       }
993.       error+=dx2;
994.       vb_start2+=y_inc;
995.     }
996.   }
998.   return(1);
999. }
1001. int Draw_Pixel(int x, int y,int color,
1002.                UCHAR *video_buffer, int lpitch)
1003. {
1004.   //画像素
1006.   video_buffer[x+y*lpitch] = color;
1008.   return(1);
1009. }
1011. int Draw_Pixel16(int x, int y,int color,
1012.                UCHAR *video_buffer, int lpitch)
1013. {
1015.   ((USHORT*)video_buffer)[x+y*(lpitch>>1)] = color;
1017.   return(1);
1018. }
1020. int Draw_Rectangle(int x1, int y1, int x2, int y2, int color,
1021.                    LPDIRECTDRAWSURFACE7 lpdds)
1022. {
1023.   //填充矩形
1025.   DDBLTFX ddbltfx;
1026.   //目标矩形
1027.   RECT fill_area;
1029.   DDRAW_INIT_STRUCT(ddbltfx);
1031.   //填充颜色
1032.   ddbltfx.dwFillColor = color;
1034.   //y1>y2?x1>x2?
1035.   fill_area.top    = y1;
1036.   fill_area.left   = x1;
1037.   fill_area.bottom = y2;
1038.   fill_area.right  = x2;
1040.   lpdds->Blt(&fill_area,
1041.              NULL,
1042.              NULL,
1043.              DDBLT_COLORFILL | DDBLT_WAIT,
1044.              &ddbltfx);
1046.   return(1);
1048. }
1050. int Set_Palette_Entry(int color_index, LPPALETTEENTRY color)
1051. {
1052.   //更改调色板相应索引号的颜色
1053.   lpddpal->SetEntries(0,color_index,1,color);
1054.   //更改调色板对象数组
1055.   memcpy(&palette[color_index],color,sizeof(PALETTEENTRY));
1057.   return(1);
1058. }
1060. int Get_Palette_Entry(int color_index, LPPALETTEENTRY color)
1061. {
1062.   //取得调色板索引对应的palette存放在color地址处
1064.   memcpy(color,&palette[color_index],sizeof(PALETTEENTRY));
1066.   return(1);
1067. }
1069. int Load_Palette_From_File(char *filename, LPPALETTEENTRY palette)
1070. {
1072.   FILE *fp_file;  //文件指针
1074.   if((fp_file=fopen(filename,"r"))==NULL)   //以'读'模式打开文件
1075.     return(0);
1077.   for (int index=0; index<MAX_COLORS_PALETTE;index++)
1078.   {
1079.     //从文件中读出R.G.B.F值赋给palette对象
1081.     fscanf(fp_file,"%d %d %d %d",&palette[index].peRed,
1082.                                  &palette[index].peGreen,
1083.                                  &palette[index].peBlue,
1084.                                  &palette[index].peFlags);
1085.   }
1087.   fclose(fp_file);
1089.   return(1);
1090. }
1092. int Save_Palette_To_File(char *filename, LPPALETTEENTRY palette)
1093. {
1095.   FILE* fp_file;
1097.   if((fp_file=fopen(filename,"w"))==NULL)   //以"写"方式打开文件
1098.     return(0);
1100.   for (int index=0;index<MAX_COLORS_PALETTE;index++)
1101.   {
1102.     fprintf(fp_file,"/n%d %d %d %d",palette[index].peRed,
1103.                                     palette[index].peGreen,
1104.                                     palette[index].peBlue,
1105.                                     palette[index].peFlags);
1106.   }
1108.   fclose(fp_file);
1110.   return(1);
1111. }
1113. int Save_Palette(LPPALETTEENTRY sav_palette)
1114. {
1115.   //保存palette对象至sav_palette对象
1116.   memcpy(sav_palette,palette,MAX_COLORS_PALETTE*sizeof(PALETTEENTRY));
1118.   return(1);
1119. }
1121. int Set_Palette(LPPALETTEENTRY set_palette)
1122. {
1123.   //设置调色板
1124.   //更改palette对象
1125.   memcpy(palette,set_palette,MAX_COLORS_PALETTE*sizeof(PALETTEENTRY));
1126.   //更改与显示表面关联的调色板项
1127.   lpddpal->SetEntries(0,0,MAX_COLORS_PALETTE,palette);
1129.   return(1);
1130. }
1132. int Rotate_Colors(int start_index, int end_index)
1133. {
1135.   //取得需改变的调色板项数
1136.   int colors = end_index -start_index + 1;
1138.   PALETTEENTRY work_pal[MAX_COLORS_PALETTE];
1140.   //取得需改变的调色板项存放在work_pal对象中
1141.   lpddpal->GetEntries(0,start_index,colors,work_pal);
1143.   //调色板项右移一位(最后一位放置第一位)
1144.   lpddpal->SetEntries(0,start_index+1,colors-1,work_pal);
1145.   lpddpal->SetEntries(0,start_index,1,&work_pal[colors-1]);
1147.   //更新palette对象
1148.   lpddpal->GetEntries(0,0,MAX_COLORS_PALETTE,palette);
1150.   return(1);
1151. }
1153. int Blink_Colors(int command, BLINKER_PTR new_light, int id)
1154. {
1155.   //闪烁像素
1157.   static BLINKER lights[256];
1158.   static int initialized = 0;
1160.   if (!initialized)
1161.   {
1162.     initialized = 1;
1163.     memset((void*)lights,0,sizeof(lights));
1164.   }
1166.   switch(command)
1167.   {
1169.   case BLINKER_ADD :
1170.     {
1171.       for (int index=0;index<256;index++)
1172.       {
1173.         if (lights[index].state==0)
1174.         {
1175.           lights[index] = *new_light;
1176.           lights[index].counter = 0;
1177.           lights[index].state = -1;   //初始化为关(灯)
1179.           lpddpal->SetEntries(0,lights[index].color_index,1,&lights[index].off_color);
1181.           return(index);
1182.         }
1183.       }
1184.     } break;
1186.   case BLINKER_DELETE:
1187.     {
1188.       //删除闪烁灯
1190.       if (lights[id].state!=0)
1191.       {
1192.         memset((void*)&lights[id],0,sizeof(BLINKER));
1194.         return(id);
1195.       }
1196.       else
1197.         return(-1);
1199.     } break;
1201.   case BLINKER_UPDATE:
1202.     {
1203.       //更新闪烁灯
1205.       if (lights[id].state!=0)
1206.       {
1207.         lights[id].on_color = new_light->on_color;
1208.         lights[id].off_color = new_light->off_color;
1209.         lights[id].on_time   = new_light->on_time;
1210.         lights[id].off_time  = new_light->off_time;
1212.         if (lights[id].state==-1)
1213.           lpddpal->SetEntries(0,lights[id].color_index,1,&lights[id].off_color);
1214.         else
1215.           lpddpal->SetEntries(0,lights[id].color_index,1,&lights[id].on_color);
1217.         return(id);
1218.       }
1219.       else
1220.         return(-1);
1222.     } break;
1224.   case BLINKER_RUN:
1225.     {
1226.       //运行闪烁灯
1228.       for (int index=0;index<256;index++)
1229.       {
1230.         if (lights[index].state==-1)
1231.         { 
1232.           //如果闪烁灯是关着的
1234.           if (++lights[index].counter>=lights[index].off_time)
1235.           {
1236.             //当计数器超过预定的关灯时间
1238.             lights[index].counter = 0;    //计数器清零
1239.             lights[index].state = - lights[index].state;    //改变灯的开关状态
1241.             lpddpal->SetEntries(0,lights[index].color_index,1,&lights[index].on_color);
1242.           }
1243.         }
1245.         else if (lights[index].state ==1)
1246.         {
1247.           if (++lights[index].counter >= lights[index].on_time)
1248.           {
1249.             lights[index].counter = 0;
1250.             lights[index].state = -lights[index].state;
1252.             lpddpal->SetEntries(0,lights[index].color_index,1,&lights[index].off_color);
1253.           }
1254.         }
1255.       }
1256.     } break;
1258.     
1259.   }//end switch
1261.   return(1);
1263. }
1266. int Draw_Text_GDI(char *text, int x,int y,COLORREF color, LPDIRECTDRAWSURFACE7 lpdds)
1267. {
1268.   //传入COLORREF结构
1269.   
1270.   HDC xdc;
1272.   if(FAILED(lpdds->GetDC(&xdc)))
1273.     return(0);
1275.   SetTextColor(xdc,color);
1277.   SetBkMode(xdc,TRANSPARENT);
1279.   TextOut(xdc,x,y,text,strlen(text));
1281.   lpdds->ReleaseDC(xdc);
1283.   return(1);
1285. }
1287. int Draw_Text_GDI(char *text, int x,int y,int color, LPDIRECTDRAWSURFACE7 lpdds)
1288. {
1289.   //传入颜色索引
1290.   
1291.   HDC xdc;
1293.   if(FAILED(lpdds->GetDC(&xdc)))
1294.     return(0);
1296.   SetTextColor(xdc,RGB(palette[color].peRed,palette[color].peGreen,palette[color].peBlue) );
1298.   SetBkMode(xdc,TRANSPARENT);
1300.   TextOut(xdc,x,y,text,strlen(text));
1302.   lpdds->ReleaseDC(xdc);
1304.   return(1);
1306. }
1308. int Open_Error_File(char *filename, FILE *fp_override/* =NULL */)
1309. {
1310.   //打开误差文件
1312.   if (fp_override)
1313.   { //如果误差文件是打开的
1314.     fp_error = fp_override;
1315.   }
1316.   else
1317.   { 
1318.     //误差文件没打开，则打开它
1319.     if ((fp_error = fopen(filename,"w"))==NULL)
1320.       return(0);
1321.   }
1323.   struct _timeb timebuffer;
1324.   char *timeline;
1325.   char timestring[280];
1327.   _ftime(&timebuffer);
1328.   timeline = ctime(&(timebuffer.time));   //ctime()将本地时间格式化为字符串,保存在timeline地址处
1330.   //先输出timeline地址处的前19位,在加上.毫秒数，最后加上年份
1331.   sprintf(timestring,"%.19s.%hu,%s",timeline,timebuffer.millitm,&timeline[20]);
1333.   Write_Error("/nOpening Error Output File (%s) on %s/n",filename,timestring);
1335.   if (!fp_override)
1336.   {
1337.     //为什么要重新打开? 也许是想把文件指针定位在文件末尾
1338.     fclose(fp_error);
1339.     //'a+' 读写方式打开，将文件指针指向文件末尾。如果文件不存在则尝试创建之。
1340.     if ((fp_error = fopen(filename,"a+"))==NULL)
1341.       return(0);
1342.   }
1344.   return(1);
1345. }
1347. int Close_Error_File(void)
1348. {
1349.   //关闭误差文件
1351.   if (fp_error)
1352.   {
1353.     Write_Error("/nClosing Error Output File.");
1354.     if (fp_error!=stdout || fp_error!=stderr) //?
1355.     {
1356.       fclose(fp_error);
1357.     }
1359.     fp_error = NULL;
1361.     return(1);
1362.   }
1364.   else
1365.     return(0);
1366. }
1368. int Write_Error(char *string, ...)
1369. {
1370.   //写入误差文件
1372.   char buffer[80];
1374.   va_list arglist;
1376.   if(!string || !fp_error)
1377.     return(0);
1379.   va_start(arglist,string);
1380.   vsprintf(buffer,string,arglist);
1381.   va_end(arglist);
1383.   fprintf(fp_error,buffer);
1385.   fflush(fp_error);
1387.   return(1);
1389. }
1392. int Load_Bitmap_File(BITMAP_FILE_PTR bitmap, char *filename)
1393. {
1395.   int file_handle,
1396.       index;
1398.   UCHAR *temp_buffer = NULL;
1399.   OFSTRUCT file_data;   
1400.   
1401.   if((file_handle = OpenFile(filename,&file_data,OF_READ))==-1)
1402.     return(0);
1404.   //读位图文件头
1405.   _lread(file_handle,&bitmap->bitmapfileheader,sizeof(BITMAPFILEHEADER));
1407.   //bmp文件标志 'bm'(0x4D42)
1408.   if (bitmap->bitmapfileheader.bfType!=BITMAP_ID)
1409.   {
1410.     _lclose(file_handle);
1412.     return(0);
1413.   }
1415.   //读信息头结构
1416.   _lread(file_handle,&bitmap->bitmapinfoheader,sizeof(BITMAPINFOHEADER));
1418.   //如果位图有调色板则加载它
1419.   if (bitmap->bitmapinfoheader.biBitCount == 8)
1420.   {
1421.     _lread(file_handle,&bitmap->palette,MAX_COLORS_PALETTE*sizeof(PALETTEENTRY));
1423.     for (index=0;index<MAX_COLORS_PALETTE;index++)
1424.     {
1425.       //位图图像调色板数据格式为(B.G.R)
1427.       BYTE temp_color = bitmap->palette[index].peRed;
1428.       bitmap->palette[index].peRed = bitmap->palette[index].peBlue;
1429.       bitmap->palette[index].peBlue = temp_color;
1431.       bitmap->palette[index].peFlags = PC_NOCOLLAPSE;
1432.     }
1433.   }
1434.   
1435.   //定位文件指针(定位到文件末再向上移动biSizeImage字节)
1436.   _lseek(file_handle,-(int)(bitmap->bitmapinfoheader.biSizeImage),SEEK_END);
1438.   //位图像素格式为8位或16位
1439.   if (bitmap->bitmapinfoheader.biBitCount==8 || bitmap->bitmapinfoheader.biBitCount==16)
1440.   {
1441.     //16位难道不用对调 R&B ??
1443.     if (bitmap->buffer)
1444.     {
1445.       free(bitmap->buffer);
1446.     }
1448.     if (!(bitmap->buffer = (UCHAR*)malloc(bitmap->bitmapinfoheader.biSizeImage)))
1449.     {
1450.       _lclose(file_handle);
1451.       return(0);
1452.     }
1453.     
1454.     //读位图数据到bitmap对象的缓冲区
1455.     _lread(file_handle,bitmap->buffer,bitmap->bitmapinfoheader.biSizeImage);
1457.   }
1459.   else
1460.   if (bitmap->bitmapinfoheader.biBitCount==24)
1461.   {
1462.     //取得位图数据大小并为其开辟内存 首地址置于临时缓冲区
1463.     if (!(temp_buffer = (UCHAR*)malloc(bitmap->bitmapinfoheader.biSizeImage)))
1464.     {
1465.       _lclose(file_handle);
1466.       return(0);
1467.     }
1468.     
1469.     //开辟16位位图数据区首地址置于bitmap对象的缓冲区(biWidth/biHeight以像素为单位)
1470.     if (!(bitmap->buffer=(UCHAR*)malloc(2*bitmap->bitmapinfoheader.biWidth*bitmap->bitmapinfoheader.biHeight)))
1471.     {
1472.       _lclose(file_handle);
1473.       free(temp_buffer);
1475.       return(0);
1476.     }
1477.     
1478.     //位图数据copy到临时缓冲区
1479.     _lread(file_handle,temp_buffer,bitmap->bitmapinfoheader.biSizeImage);
1481.     for (index=0;index<bitmap->bitmapinfoheader.biWidth*bitmap->bitmapinfoheader.biHeight;index++)
1482.     {
1483.       USHORT color;
1485.       //位图图像数据
1487.       if (dd_pixel_format==DD_PIXEL_FORMAT555)
1488.       {
1489.         UCHAR blue  = (temp_buffer[index*3+0]>>3),
1490.               green = (temp_buffer[index*3+1]>>3),
1491.               red  = (temp_buffer[index*3+2]>>3);
1493.         color = _RGB16BIT555(red,green,blue);
1494.       } 
1495.       else
1496.       if (dd_pixel_format==DD_PIXEL_FORMAT565)
1497.       {
1498.         UCHAR blue  = (temp_buffer[index*3+0]>>3),
1499.               green = (temp_buffer[index*3+1]>>2),
1500.               red   = (temp_buffer[index*3+2]>>3);
1502.         color = _RGB16BIT565(red,green,blue);
1504.       }
1505.       
1506.       ((USHORT*)bitmap->buffer)[index] = color;
1508.      }// end for index
1510.     bitmap->bitmapinfoheader.biBitCount = 16;
1512.     free(temp_buffer);
1514.   }// end if 24 bit
1516.   else
1517.   {
1518.     return(0);
1519.   }
1521. #if 0
1522. // write the file info out 
1523. printf("/nfilename:%s /nsize=%d /nwidth=%d /nheight=%d /nbitsperpixel=%d /ncolors=%d /nimpcolors=%d",
1524.         filename,
1525.         bitmap->bitmapinfoheader.biSizeImage,
1526.         bitmap->bitmapinfoheader.biWidth,
1527.         bitmap->bitmapinfoheader.biHeight,
1528.         bitmap->bitmapinfoheader.biBitCount,
1529.         bitmap->bitmapinfoheader.biClrUsed,
1530.         bitmap->bitmapinfoheader.biClrImportant);
1531. #endif
1533.   _lclose(file_handle);
1535.   //颠倒bitmap对象中的位图数据
1536.   Flip_Bitmap(bitmap->buffer,
1537.               bitmap->bitmapinfoheader.biWidth*(bitmap->bitmapinfoheader.biBitCount/8),
1538.               bitmap->bitmapinfoheader.biHeight);
1540.   return(1);
1542. }
1544. int Unload_Bitmap_File(BITMAP_FILE_PTR bitmap)
1545. {
1547.   if (bitmap->buffer)
1548.   {
1549.     free(bitmap->buffer);
1550.     
1551.     bitmap->buffer = NULL;
1552.   }
1554.   return(1);
1555. }
1557. int Flip_Bitmap(UCHAR *image, int bytes_per_line, int height)
1558. {
1559.   //颠倒位图数据
1561.   UCHAR *buffer;
1562.   int index;
1564.   if(!(buffer = (UCHAR*)malloc(bytes_per_line*height)))
1565.     return(0);
1567.   memcpy(buffer,image,bytes_per_line*height);
1569.   for (index=0;index<height;index++)
1570.   {
1571.     memcpy(&image[((height-1)-index)*bytes_per_line],
1572.            &buffer[index*bytes_per_line],bytes_per_line);
1573.   }
1575.   free(buffer);
1577.   buffer = NULL;
1578.   
1579.   return(1);
1581. }
1583. int Create_Bitmap(BITMAP_IMAGE_PTR image, int x, int y, int width, int height, int bpp/* =8 */)
1584. {
1585.   //创建一个宽width高height色深为bpp在屏幕(x,y)处的空的位图图像
1587.   if(!(image->buffer = (UCHAR*)malloc(width*height*(bpp>>3))))
1588.     return(0);
1590.   image->state     = BITMAP_STATE_ALIVE;
1591.   image->attr      = 0;
1592.   image->width     = width;
1593.   image->height    = height;
1594.   image->bpp       = bpp;
1595.   image->x         = x;
1596.   image->y         = y;
1597.   image->num_bytes = width*height*(bpp>>3);
1599.   memset(image->buffer,0,image->num_bytes);
1601.   return(1);
1603. }
1605. int Destroy_Bitmap(BITMAP_IMAGE_PTR image)
1606. {
1607.   //销毁位图图像
1608.   
1609.   if (image && image->buffer)
1610.   {
1611.     free(image->buffer);
1613.     image->buffer = NULL;
1615.     memset(image,0,sizeof(BITMAP_IMAGE));
1617.     return(1);
1618.   }
1619.   else
1620.     return(0);
1621. }
1623. int Draw_Bitmap(BITMAP_IMAGE_PTR source_bitmap,UCHAR *dest_buffer, int lpitch, int transparent)
1624. {
1625.   //绘制位图
1626.   //当创建好一个大小指定内容为空的位图内存区后从位图文件的缓冲区中读入指定的位图图像数据与空内存区
1627.   //然后将此内存区的位图图像经过本函数绘制在指定区域(dest_buffer)
1629.   //位图是否被加载
1630.   if (!(source_bitmap->attr & BITMAP_ATTR_LOADED))
1631.     return(0);
1633.   UCHAR *dest_addr,    //目标地址
1634.         *source_addr;  //源地址
1636.   UCHAR pixel;
1638.   int index,
1639.       pixel_x;
1641.   dest_addr = dest_buffer + source_bitmap->y*lpitch + source_bitmap->x;
1642.   source_addr =source_bitmap->buffer;
1644.   if (transparent)
1645.   { 
1646.     //如果位图图像透明,则逐字节copy,此处height/width单位为像素
1648.     for (index=0;index<source_bitmap->height;index++)
1649.     {
1650.       for (pixel_x=0;pixel_x<source_bitmap->width;pixel_x++)
1651.       {
1652.         if ((pixel = source_addr[pixel_x])!=0)
1653.             dest_addr[pixel_x]=pixel;
1654.       }
1656.       dest_addr +=lpitch;                   //目标地址向下移动一行
1657.       source_addr += source_bitmap->width;  //源地址(位图图像)向下移动一行
1658.     }
1660.   }
1662.   else
1663.   {
1664.     //位图不透明的情况则逐行copy
1666.     for (index=0;index<source_bitmap->height;index++)
1667.     {
1668.       memcpy(dest_addr,source_addr,source_bitmap->width);
1670.       dest_addr  +=lpitch;
1671.       source_addr+=source_bitmap->width;
1672.     }
1673.   }
1675.   return(1);
1676.     
1677. }
1680. int Draw_Bitmap16(BITMAP_IMAGE_PTR source_bitmap,UCHAR *dest_buffer, int lpitch, int transparent)
1681. {
1682.   //绘制位图(16位)
1683.   //当创建好一个大小指定内容为空的位图内存区后从位图文件的缓冲区中读入指定的位图图像数据与空内存区
1684.   //然后将此内存区的位图图像经过本函数绘制在指定区域(dest_buffer)
1686.   //位图是否被加载
1687.   if (!(source_bitmap->attr & BITMAP_ATTR_LOADED))
1688.     return(0);
1690.   USHORT *dest_addr,       //目标地址
1691.          *source_addr;     //源地址
1693.   USHORT  pixel;
1695.   int index,
1696.       pixel_x,
1697.       lpitch_2 = lpitch >> 1;
1699.   dest_addr = ((USHORT*)dest_buffer) + source_bitmap->y*lpitch_2 + source_bitmap->x;
1700.   source_addr = (USHORT*) source_bitmap->buffer;
1702.   if (transparent)
1703.   { 
1704.     //如果位图图像透明,则逐字节copy,此处height/width单位为像素
1706.     for (index=0;index<source_bitmap->height;index++)
1707.     {
1708.       for (pixel_x=0;pixel_x<source_bitmap->width;pixel_x++)
1709.       {
1710.         if ((pixel = source_addr[pixel_x])!=0)
1711.             dest_addr[pixel_x]=pixel;
1712.       }
1714.       dest_addr +=lpitch;                   //目标地址向下移动一行
1715.       source_addr += source_bitmap->width;  //源地址(位图图像)向下移动一行
1716.     }
1718.   }
1720.   else
1721.   {
1722.     //位图不透明的情况则逐行copy
1724.     int source_bytes_per_line = source_bitmap->width*2;
1726.     for (index=0;index<source_bitmap->height;index++)
1727.     {
1728.       memcpy(dest_addr,source_addr,source_bytes_per_line);
1730.       dest_addr  +=lpitch_2;
1731.       source_addr+=source_bitmap->width;
1732.     }
1733.   }
1735.   return(1);
1736.     
1737. }
1739. int Load_Image_Bitmap(BITMAP_IMAGE_PTR image,BITMAP_FILE_PTR bitmap,int cx,int cy,int mode)
1740. {
1741.   //此函数从一个位图文件对象(BITMAP_FILE)的buffer区读入位图图像数据至image对象的buffer区
1743.   //如果没有创建位图图像内存区(BITMAP_IMAGE)
1744.   if(!image)
1745.     return(0);
1747.   UCHAR *source_ptr,
1748.         *dest_ptr;
1750.   if (mode==BITMAP_EXTRACT_MODE_CELL)
1751.   {
1752.     //如果是位图图像模板模式则计算选择的目标图像的实际坐标
1753.     cx = cx*(image->width+1) + 1;
1754.     cy = cy*(image->height+1) +1;
1755.   }
1757.   source_ptr = bitmap->buffer + cy*bitmap->bitmapinfoheader.biWidth+cx;
1759.   dest_ptr = (UCHAR*) image->buffer;
1761.   for (int index_y=0;index_y<image->height;index_y++)
1762.   {
1763.     memcpy(dest_ptr,source_ptr,image->width);
1765.     dest_ptr   += image->width;
1766.     source_ptr += bitmap->bitmapinfoheader.biWidth;
1767.   }
1769.   image->attr |=BITMAP_ATTR_LOADED;
1771.  return(1);
1773. }
1775. int Load_Image_Bitmap16(BITMAP_IMAGE_PTR image,BITMAP_FILE_PTR bitmap,int cx,int cy,int mode)
1776. {
1777.   //此函数从一个位图文件对象(BITMAP_FILE)的buffer区读入位图图像数据至image对象的buffer区(16位)
1779.   //如果没有创建位图图像内存区(BITMAP_IMAGE)
1780.   if(!image)
1781.     return(0);
1783.   USHORT *source_ptr,
1784.          *dest_ptr;
1786.   if (mode==BITMAP_EXTRACT_MODE_CELL)
1787.   {
1788.     //如果是位图图像模板模式则计算选择的目标图像的实际坐标
1789.     cx = cx*(image->width+1) + 1;
1790.     cy = cy*(image->height+1) +1;
1791.   }
1793.   source_ptr =(USHORT*)bitmap->buffer + cy*bitmap->bitmapinfoheader.biWidth+cx;
1795.   dest_ptr = (USHORT*) image->buffer;
1797.   int bytes_per_line = image->width*2;
1799.   for (int index_y=0;index_y<image->height;index_y++)
1800.   {
1801.     memcpy(dest_ptr,source_ptr,bytes_per_line);
1803.     dest_ptr   += image->width;
1804.     source_ptr += bitmap->bitmapinfoheader.biWidth;
1805.   }
1807.   image->attr |=BITMAP_ATTR_LOADED;
1809.  return(1);
1811. }
1814. int Scroll_Bitmap(BITMAP_IMAGE_PTR image, int dx, int dy/* =0 */)
1815. {
1816.   //卷动位图图像(自适应8位和16位)
1818.   BITMAP_IMAGE temp_image;  //临时位图图像对象
1820.   if (!image || (dx==0 && dy==0))
1821.     return(0);
1823.   if (dx!=0)
1824.   {
1825.     dx %= image->width;
1827.     if (dx>0)
1828.     {
1829.       //向右卷动
1831.       //创建一个宽dx,高height的位图图像
1832.       Create_Bitmap(&temp_image,0,0,dx,image->height,image->bpp);
1833.       
1834.       //将源位图图像从(width-dx,0)坐标开始,copy宽为dx高为height的图像数据至临时位图图像
1835.       Copy_Bitmap(&temp_image,0,0,
1836.                   image,image->width-dx,0,
1837.                   dx,image->height);
1839.       UCHAR *source_ptr = image->buffer;
1840.       int shift         = (image->bpp>>3)*dx;  //适应8/16位
1842.       for (int y=0;y<image->height;y++)
1843.       {
1844.         //从source_ptr地址向右移动(width-dx)个像素至source_ptr+shift地址处    
1845.         memmove(source_ptr+shift,source_ptr,(image->width-dx)*(image->bpp>>3));
1847.         source_ptr+=((image->bpp>>3)*image->width);
1848.       }
1849.       
1850.       //将临时位图图像的数据copy回源位图图像
1851.       Copy_Bitmap(image,0,0,&temp_image,0,0,dx,image->height);
1853.     }
1855.     else
1856.     {
1857.        // 向左卷动
1859.       dx = -dx; 
1861.       Create_Bitmap(&temp_image, 0, 0, dx, image->height, image->bpp);
1863.       Copy_Bitmap(&temp_image,0,0, 
1864.                   image, 0,0, 
1865.                   dx, image->height);
1867.      UCHAR *source_ptr = image->buffer;  
1868.      int shift         = (image->bpp >> 3)*dx;
1870.      for (int y=0; y < image->height; y++)
1871.       {
1872.         memmove(source_ptr, source_ptr+shift, (image->width-dx)*(image->bpp >> 3));
1873.         source_ptr+=((image->bpp >> 3)*image->width);
1875.       } // end for
1876.    
1877.      Copy_Bitmap(image, image->width-dx,0, &temp_image,0,0, 
1878.                dx, image->height);     
1879.     }
1881.   }
1882.   
1883.   return(1);
1885. }
1888. int Copy_Bitmap(BITMAP_IMAGE_PTR dest_bitmap, int dest_x, int dest_y, 
1889.                 BITMAP_IMAGE_PTR source_bitmap, int source_x, int source_y,
1890.                 int width, int height)
1891. {
1892.   //copy源位图指定坐标位置开始宽width高height到指定位图图像的指定位置
1893.   //同时满足8位和16位
1895.   if (!dest_bitmap || !source_bitmap)
1896.     return(0);
1898.   //每像素的字节数
1899.   int bytes_per_pixel = (source_bitmap->bpp >> 3);
1901.   UCHAR* source_ptr = source_bitmap->buffer + (source_x+source_y*source_bitmap->width)*bytes_per_pixel;
1902.   UCHAR* dest_ptr = dest_bitmap->buffer + (dest_x + dest_y*dest_bitmap->width)*bytes_per_pixel;
1904.   for (int y=0;y<height;y++)
1905.   {
1906.     memcpy(dest_ptr,source_ptr,bytes_per_pixel*width);
1908.     source_ptr += (source_bitmap->width*bytes_per_pixel);
1909.     dest_ptr   += (dest_bitmap->width*bytes_per_pixel);
1910.   }
1912.   return(1);
1914. }
1918. void HLine16(int x1,int x2,int y,int color, UCHAR *vbuffer, int lpitch)
1919. {
1920.   //画从(x1,y)至(x2,y)颜色为color的直线(16位)
1922.   int temp;
1924.   USHORT *vbuffer2 = (USHORT*)vbuffer;
1926.   lpitch = lpitch >> 1;
1928.   if (y>max_clip_y || y<min_clip_y)
1929.       return;
1931.   if (x1>x2)
1932.   {
1933.     temp = x1;
1934.     x1 = x2;
1935.     x2 = temp;
1936.   }
1938.   if (x1>max_clip_x || x2<min_clip_x)
1939.     return;
1941.   x1 = ((x1<min_clip_x)?min_clip_x:x1);
1942.   x2 = ((x2>max_clip_x)?max_clip_x:x2);
1944.   Mem_Set_WORD((vbuffer2+(y*lpitch)+x1),color,x2-x1+1);
1946. }
1948. void HLine(int x1,int x2,int y,int color, UCHAR *vbuffer, int lpitch)
1949. {
1950.   //画从(x1,y)至(x2,y)颜色为color的直线(8位)
1952.   int temp;
1954.   lpitch = lpitch >> 1;
1956.   if (y>max_clip_y || y<min_clip_y)
1957.       return;
1959.   if (x1>x2)
1960.   {
1961.     temp = x1;
1962.     x1 = x2;
1963.     x2 = temp;
1964.   }
1966.   if (x1>max_clip_x || x2<min_clip_x)
1967.     return;
1969.   x1 = ((x1<min_clip_x)?min_clip_x:x1);
1970.   x2 = ((x2>max_clip_x)?max_clip_x:x2);
1972.   memset((UCHAR*)(vbuffer+(y*lpitch)+x1),(UCHAR)color,x2-x1+1);
1974. }
1977. void VLine16(int y1,int y2,int x,int color, UCHAR *vbuffer, int lpitch)
1978. {
1979.   //画从(x,y1)至(x,y2)的颜色为color的直线(16位)
1981.   USHORT *start_offset;
1982.   int index,
1983.       temp;
1985.   lpitch = lpitch >>1;
1987.   if (x>max_clip_x || x<min_clip_x)
1988.     return;
1990.   if (y1>y2)
1991.   {
1992.     temp = y1;
1993.     y1 = y2;
1994.     y2 = temp;
1995.   }
1997.   if (y1>max_clip_y || y2<min_clip_y)
1998.     return;
2000.   y1 = ((y1<min_clip_y)?min_clip_y:y1);
2001.   y2 = ((y2>max_clip_y)?max_clip_y:y2);
2003.   start_offset = (USHORT*)vbuffer + (y1*lpitch) + x;
2005.   for (index=0;index<=y2-y1;index++)
2006.   {
2007.     *start_offset = color;
2008.     start_offset += lpitch;
2009.   }
2011. }
2013. void VLine(int y1,int y2,int x,int color, UCHAR *vbuffer, int lpitch)
2014. {
2015.   //画从(x,y1)至(x,y2)的颜色为color的直线(8位)
2017.   UCHAR *start_offset;
2018.   int index,
2019.       temp;
2021.   if (x>max_clip_x || x<min_clip_x)
2022.     return;
2024.   if (y1>y2)
2025.   {
2026.     temp = y1;
2027.     y1 = y2;
2028.     y2 = temp;
2029.   }
2031.   if (y1>max_clip_y || y2<min_clip_y)
2032.     return;
2034.   y1 = ((y1<min_clip_y)?min_clip_y:y1);
2035.   y2 = ((y2>max_clip_y)?max_clip_y:y2);
2037.   start_offset = vbuffer + (y1*lpitch) + x;
2039.   for (index=0;index<=y2-y1;index++)
2040.   {
2041.     *start_offset = (UCHAR)color;
2042.     start_offset += lpitch;
2043.   }
2045. }
2048. void Screen_Transitions(int effect, UCHAR *vbuffer, int lpitch)
2049. {
2051.   int pal_reg;      //循环变量
2052.   int index;        //循环变量
2053.   int red,green,blue;
2055.   PALETTEENTRY color;
2056.   PALETTEENTRY work_palette[MAX_COLORS_PALETTE];
2057.   //PALETTEENTRY work_color;
2059.   switch(effect)
2060.   {
2062.   case SCREEN_DARKNESS:
2063.     { 
2064.       //逐渐变暗
2066.       for (index=0;index<80;index++)
2067.       {
2068.         Save_Palette(work_palette);
2070.         for (pal_reg=1;pal_reg<MAX_COLORS_PALETTE;pal_reg++)
2071.         {
2072.           color = work_palette[pal_reg];
2074.           if (color.peRed>4) color.peRed-=3;
2075.           else 
2076.             color.peRed = 0;
2077.           if (color.peGreen>4) color.peGreen-=3;
2078.           else
2079.             color.peGreen = 0;
2080.           if (color.peBlue>4) color.peBlue-=3;
2081.           else
2082.             color.peBlue =0;
2084.           work_palette[pal_reg] = color;
2085.         }
2086.         
2087.         Set_Palette(work_palette);
2089.         //等一段时间(让变化看得见)
2090.         Start_Clock();
2091.         Wait_Clock(12);
2093.       }
2094.       
2095.     } break;
2097.   case SCREEN_WHITENESS:
2098.     {
2100.       //逐渐变亮    
2102.       for (index=0;index<64;index++)
2103.       {
2104.         Save_Palette(work_palette);
2106.         for (pal_reg=0;pal_reg<MAX_COLORS_PALETTE;pal_reg++)
2107.         {
2108.           color = work_palette[pal_reg];
2110.           red = color.peRed;
2111.           green = color.peGreen;
2112.           blue =color.peBlue;
2114.           if ((red+=4)>=255)
2115.             red = 255;
2116.           if ((green+=4)>=255)
2117.             green = 255;
2118.           if ((blue+=4)>=255)
2119.             blue = 255;
2121.           color.peRed = red;
2122.           color.peGreen =green;
2123.           color.peBlue = blue;
2125.           work_palette[pal_reg] = color;
2127.         }
2129.         Set_Palette(work_palette);
2131.         Start_Clock();
2132.         Wait_Clock(12);
2133.         
2134.       }
2135.     } break;
2136.     
2137.   case SCREEN_REDNESS:
2138.     {
2139.       //逐渐变红
2141.       for (index=0;index<64;index++)
2142.       {
2143.         Save_Palette(work_palette);
2145.         for (pal_reg=0;pal_reg<MAX_COLORS_PALETTE;pal_reg++)
2146.         {
2147.           color = work_palette[pal_reg];
2149.           red = color.peRed;
2150.           green = color.peGreen;
2151.           blue =color.peBlue;
2153.           if ((red+=6)>=255)
2154.             red = 255;
2155.           if ((green-=4)<0)
2156.             green = 0;
2157.           if ((blue-=4)<0)
2158.             blue = 0;
2160.           color.peRed = red;
2161.           color.peGreen =green;
2162.           color.peBlue = blue;
2164.           work_palette[pal_reg] = color;
2166.         }
2168.         Set_Palette(work_palette);
2170.         Start_Clock();
2171.         Wait_Clock(12);
2172.         
2173.       }
2174.     } break;
2175.     
2176.   case SCREEN_BLUENESS:
2177.     {
2178.       //逐渐变蓝
2180.       for (index=0;index<64;index++)
2181.       {
2182.         Save_Palette(work_palette);
2184.         for (pal_reg=0;pal_reg<MAX_COLORS_PALETTE;pal_reg++)
2185.         {
2186.           color = work_palette[pal_reg];
2188.           red = color.peRed;
2189.           green = color.peGreen;
2190.           blue =color.peBlue;
2192.           if ((red-=4)<0)
2193.             red = 0;
2194.           if ((green-=4)<0)
2195.             green = 0;
2196.           if ((blue+=6)>=255)
2197.             blue = 255;
2199.           color.peRed = red;
2200.           color.peGreen =green;
2201.           color.peBlue = blue;
2203.           work_palette[pal_reg] = color;
2205.         }
2207.         Set_Palette(work_palette);
2209.         Start_Clock();
2210.         Wait_Clock(12);
2211.         
2212.       }
2213.     } break;
2215.   case SCREEN_GREENNESS:
2216.     {
2217.       //逐渐变绿
2219.       for (index=0;index<64;index++)
2220.       {
2221.         Save_Palette(work_palette);
2223.         for (pal_reg=0;pal_reg<MAX_COLORS_PALETTE;pal_reg++)
2224.         {
2225.           color = work_palette[pal_reg];
2227.           red = color.peRed;
2228.           green = color.peGreen;
2229.           blue =color.peBlue;
2231.           if ((red-=4)<0)
2232.             red = 0;
2233.           if ((green+=6)>=255)
2234.             green = 255;
2235.           if ((blue-=4)<0)
2236.             blue = 0;
2238.           color.peRed = red;
2239.           color.peGreen =green;
2240.           color.peBlue = blue;
2242.           work_palette[pal_reg] = color;
2244.         }
2246.         Set_Palette(work_palette);
2248.         Start_Clock();
2249.         Wait_Clock(12);
2250.         
2251.       }
2253.     } break;
2255.   case SCREEN_SWIPE_X:
2256.     {
2257.       //纵向画线(先右后左)
2258.       
2259.       for (index=0;index<(screen_width/2);index+=2)
2260.       {
2261.         Start_Clock();
2262.         Wait_Clock(12);
2264.         if (screen_bpp==8)
2265.         {
2266.           //分别从右左两边画两条纵向直线
2267.           VLine(0,(screen_height-1),(screen_width-1)-index,0,vbuffer,lpitch);
2268.           VLine(0,(screen_height-1),index,0,vbuffer,lpitch);
2269.           VLine(0,(screen_height-1),(screen_width-1)-(index+1),0,vbuffer,lpitch);
2270.           VLine(0,(screen_height-1),index+1,0,vbuffer,lpitch);
2271.         }
2272.         else
2273.         if (screen_bpp==16)
2274.         {
2275.           VLine16(0,(screen_height-1),(screen_width-1)-index,0,vbuffer,lpitch);
2276.           VLine16(0,(screen_height-1),index,0,vbuffer,lpitch);
2277.           VLine16(0,(screen_height-1),(screen_width-1)-(index+1),0,vbuffer,lpitch);
2278.           VLine16(0,(screen_height-1),index+1,0,vbuffer,lpitch);
2279.         }
2280.           
2281.       }// end for index
2283.     } break;
2285.   case SCREEN_SWIPE_Y:
2286.     {
2287.       //横向画线(先下后上)
2289.       for (index=0;index<(screen_height/2);index+=2)
2290.       {
2291.         Start_Clock();
2292.         Wait_Clock(12);
2294.         if (screen_bpp==8)
2295.         {
2296.           HLine(0,(screen_width-1),(screen_height-1)-index,0,vbuffer,lpitch);
2297.           HLine(0,(screen_width-1),index,0,vbuffer,lpitch);
2298.           HLine(0,(screen_width-1),(screen_height-1)-(index+1),0,vbuffer,lpitch);
2299.           HLine(0,(screen_width-1),index+1,0,vbuffer,lpitch);
2300.         }
2301.         else
2302.         if (screen_bpp==16)
2303.         {
2304.           HLine16(0,(screen_width-1),(screen_height-1)-index,0,vbuffer,lpitch);
2305.           HLine16(0,(screen_width-1),index,0,vbuffer,lpitch);
2306.           HLine16(0,(screen_width-1),(screen_height-1)-(index+1),0,vbuffer,lpitch);
2307.           HLine16(0,(screen_width-1),index+1,0,vbuffer,lpitch);
2308.         }
2309.           
2310.       }// end for index
2312.     } break;
2314.   case SCREEN_SCRUNCH:
2315.     {
2316.       //横向/纵向都会画线
2318.       for (index=0;index<(screen_width/2);index+=2)
2319.       {
2320.         Start_Clock();
2321.         Wait_Clock(12);
2323.         if (screen_bpp==8)
2324.         {
2325.           //这里取模运算因为索引index可能大于(screen_height/2)
2326.           HLine(0,(screen_width-1),(screen_height-1)-index%(screen_height/2),0,vbuffer,lpitch);
2327.           HLine(0,(screen_width-1),index%(screen_height/2),0,vbuffer,lpitch);
2328.           HLine(0,(screen_width-1),(screen_height-1)-(index%(screen_height/2)+1),0,vbuffer,lpitch);
2329.           HLine(0,(screen_width-1),index%(screen_height/2)+1,0,vbuffer,lpitch);
2331.           VLine(0,(screen_height-1),(screen_width-1)-index,0,vbuffer,lpitch);
2332.           VLine(0,(screen_height-1),index,0,vbuffer,lpitch);
2333.           VLine(0,(screen_height-1),(screen_width-1)-(index+1),0,vbuffer,lpitch);
2334.           VLine(0,(screen_height-1),index+1,0,vbuffer,lpitch);  
2335.         }
2336.         else
2337.         if (screen_bpp==16)
2338.         {
2339.           HLine16(0,(screen_width-1),(screen_height-1)-index%(screen_height/2),0,vbuffer,lpitch);
2340.           HLine16(0,(screen_width-1),index%(screen_height/2),0,vbuffer,lpitch);
2341.           HLine16(0,(screen_width-1),(screen_height-1)-(index%(screen_height/2)+1),0,vbuffer,lpitch);
2342.           HLine16(0,(screen_width-1),index%(screen_height/2)+1,0,vbuffer,lpitch);
2343.         
2344.           VLine16(0,(screen_height-1),(screen_width-1)-index,0,vbuffer,lpitch);
2345.           VLine16(0,(screen_height-1),index,0,vbuffer,lpitch);
2346.           VLine16(0,(screen_height-1),(screen_width-1)-(index+1),0,vbuffer,lpitch);
2347.           VLine16(0,(screen_height-1),index+1,0,vbuffer,lpitch);
2349.         }
2350.           
2351.       } // end for index
2353.     } break;
2355.   case SCREEN_DISOLVE:
2356.     {
2357.       //一个无聊的效果(溶解)
2359.       if (screen_bpp==8)
2360.         for (index=0;index<=screen_width*screen_height*4;index++)
2361.           Draw_Pixel(rand()%screen_width,rand()%screen_height,0,vbuffer,lpitch);
2362.       
2363.       else
2364.       if (screen_bpp==16)   
2365.         for (index=0;index<=screen_width*screen_height*4;index++)
2366.           Draw_Pixel16(rand()%screen_width,rand()%screen_height,0,vbuffer,lpitch);
2368.     } break;
2370.   default: break;
2372.   } //end switch
2374. }
2377. int Collision_Test(int x1, int y1, int w1, int h1,
2378.                    int x2, int y2, int w2, int h2)
2379. {
2380.   //碰撞检测(仅适用于矩形)
2382.   //取得近似宽度/高度一半,为什么近似?嘿嘿 自己想去
2383.   int width1 = (w1>>1) - (w1>>3);
2384.   int height1 = (h1>>1) - (h1>>3);
2385.   int width2 = (w2>>1) - (w2>>3);
2386.   int height2 = (h2>>1) - (h2>>3);
2388.   //取得矩形中心坐标
2389.   int cx1 = x1 + width1;
2390.   int cy1 = y1 + height1;
2391.   int cx2 = x2 + width2;
2392.   int cy2 = y2 + height2;
2394.   int dx = abs(cx2 - cx1);
2395.   int dy = abs(cy2 - cy1);
2397.   //如果碰撞,返回值1
2398.   if (dx<(width1+width2)&&dy<(height1+height2))
2399.     return(1);
2401.   else
2402.     return(0);
2404. }
2407. int Color_Scan(int x1, int y1, int x2, int y2, 
2408.                UCHAR scan_start, UCHAR scan_end, 
2409.                UCHAR *scan_buffer, int scan_lpitch)
2410. {
2411.   //这个函数实现了一个粗糙的碰撞技术基于扫描一个矩形内的像素颜色
2412.   //是否在一个指定的颜色范围内
2414.   //裁剪矩形使之合理
2416.   if (x1>=screen_width)
2417.     x1 = screen_width-1;
2418.   else
2419.   if (x1<0)
2420.     x1 = 0;
2422.   if (x2>=screen_width)
2423.     x2 = screen_width-1;
2424.   else
2425.   if (x2<0)
2426.     x2 = 0;
2428.   if (y1>=screen_height)
2429.     y1 = screen_height-1;
2430.   else
2431.   if (y1<0)
2432.     y1 = 0;
2434.   if (y2>=screen_height)
2435.     y2 = screen_height-1;
2436.   else
2437.   if (y2<0)
2438.     y2 = 0;
2439.   
2440.   scan_buffer +=  y1*scan_lpitch;
2442.   for (int scan_y=y1;scan_y<=y2;scan_y++)
2443.   {
2444.     //y1<y2,x1<x2? 函数外指定.
2445.     for (int scan_x=x1;scan_x<=x2;scan_x++)
2446.     {
2447.       if (scan_buffer[scan_x]>=scan_start && scan_buffer[scan_x]<=scan_end)
2448.         return(1);
2449.     }
2451.     scan_buffer+=scan_lpitch;
2452.   }
2454.    // return failure
2455.   return(0);
2457. }
2460. int Color_Scan16(int x1, int y1, int x2, int y2, 
2461.                  USHORT scan_start, USHORT scan_end,
2462.                  UCHAR *scan_buffer, int scan_lpitch)
2463. {
2465.   USHORT *scan_buffer2 = (USHORT*)scan_buffer;
2467.   scan_lpitch = (scan_lpitch>>1);
2469.   if (x1>=screen_width)
2470.     x1 = screen_width-1;
2471.   else
2472.   if (x1<0)
2473.     x1 = 0;
2475.   if (x2>=screen_width)
2476.     x2 = screen_width-1;
2477.   else
2478.   if (x2<0)
2479.     x2 = 0;
2481.   if (y1>=screen_height)
2482.     y1 = screen_height-1;
2483.   else
2484.   if (y1<0)
2485.     y1 = 0;
2487.   if (y2>=screen_height)
2488.     y2 = screen_height-1;
2489.   else
2490.   if (y2<0)
2491.     y2 = 0;
2493.   scan_buffer2 +=y1*scan_lpitch;
2495.   for (int scan_y=y1;scan_y<=y2;scan_y++)
2496.   {
2497.     for (int scan_x=x1;scan_x<=x2;scan_x++)
2498.     {
2499.       if (scan_buffer2[scan_x] == scan_start || scan_buffer2[scan_x] == scan_end)
2500.         return(1);
2501.     }
2502.     scan_buffer2+=scan_lpitch;
2504.   }
2506.   return(0);
2508. }
2511. int Scan_Image_Bitmap(BITMAP_FILE_PTR bitmap, 
2512.                       LPDIRECTDRAWSURFACE7 lpdds, 
2513.                       int cx,int cy)
2514. {
2515.   //此函数从位图文件中提取出指定位图数据至lpdds目标表面
2516.   //适用于8位?
2518.   UCHAR *source_ptr,
2519.         *dest_ptr;
2521.   DDSURFACEDESC2 ddsd;
2522.   ddsd.dwSize = sizeof(ddsd);
2524.   lpdds->Lock(NULL,
2525.               &ddsd,
2526.               DDLOCK_WAIT | DDLOCK_SURFACEMEMORYPTR,
2527.               NULL);
2529.   cx = cx*(ddsd.dwWidth+1)+1;
2530.   cy = cy*(ddsd.dwHeight+1)+1;
2531.   
2532.   source_ptr = bitmap->buffer + cy*bitmap->bitmapinfoheader.biWidth+cx;
2533.   dest_ptr = (UCHAR*)ddsd.lpSurface;
2535.   for (int index_y=0;index_y<ddsd.dwHeight;index_y++)
2536.   {
2537.     memcpy(dest_ptr,source_ptr,ddsd.dwWidth);
2539.     dest_ptr += (ddsd.lPitch);
2540.     source_ptr += bitmap->bitmapinfoheader.biWidth;
2541.   }
2543.   lpdds->Unlock(NULL);
2545.   return(1);
2547. }
2550. void Draw_Top_Tri(int x1,int y1, 
2551.                   int x2,int y2, 
2552.                   int x3,int y3,
2553.                   int color, 
2554.                   UCHAR *dest_buffer, int mempitch)
2555. {
2556. // 画平顶三角形(8位,精确模式)
2558. float dx_right,   
2559.       dx_left,     
2560.       xs,xe,       
2561.       height;     
2563. int temp_x,       
2564.     temp_y,
2565.     right,        
2566.     left;
2568. UCHAR  *dest_addr = NULL;
2570. if (x2 < x1)
2571.    {
2572.    temp_x = x2;
2573.    x2     = x1;
2574.    x1     = temp_x;
2575.    } 
2577. height = y3-y1;
2579. dx_left  = (x3-x1)/height;
2580. dx_right = (x3-x2)/height;
2583. xs = (float)x1;
2584. xe = (float)x2+(float)0.5;
2586. if (y1 < min_clip_y)
2587.    {
2589.    xs = xs+dx_left*(float)(-y1+min_clip_y);
2590.    xe = xe+dx_right*(float)(-y1+min_clip_y);
2592.    y1=min_clip_y;
2594.    } 
2596. if (y3>max_clip_y)
2597.    y3=max_clip_y;
2599. dest_addr = dest_buffer+y1*mempitch;
2601. if (x1>=min_clip_x && x1<=max_clip_x &
2602.     x2>=min_clip_x && x2<=max_clip_x &
2603.     x3>=min_clip_x && x3<=max_clip_x)
2604.     {
2606.     for (temp_y=y1; temp_y<=y3; temp_y++,dest_addr+=mempitch)
2607.         {
2608.         memset((UCHAR *)dest_addr+(unsigned int)xs,
2609.                 color,(unsigned int)(xe-xs+1));
2612.         xs+=dx_left;
2613.         xe+=dx_right;
2615.         } 
2617.     } 
2618. else
2619.    {
2621.    for (temp_y=y1; temp_y<=y3; temp_y++,dest_addr+=mempitch)
2622.        {
2623.     
2624.        left  = (int)xs;
2625.        right = (int)xe;
2627.        xs+=dx_left;
2628.        xe+=dx_right;
2630.        if (left < min_clip_x)
2631.           {
2632.           left = min_clip_x;
2634.           if (right < min_clip_x)
2635.              continue;
2636.           }
2638.        if (right > max_clip_x)
2639.           {
2640.           right = max_clip_x;
2642.           if (left > max_clip_x)
2643.              continue;
2644.           }
2646.        memset((UCHAR  *)dest_addr+(unsigned int)left,
2647.               color,(unsigned int)(right-left+1));
2649.        } // end for
2651.    } 
2653. }
2655. /////////////////////////////////////////////////////////////////////////////
2657. void Draw_Bottom_Tri(int x1,int y1, 
2658.                      int x2,int y2, 
2659.                      int x3,int y3,
2660.                      int color,
2661.                      UCHAR *dest_buffer, int mempitch)
2662. {
2663. // 画平底三角形(8位,精确模式)
2665. float dx_right,    
2666.       dx_left,   
2667.       xs,xe,     
2668.       height;    
2670. int temp_x,       
2671.     temp_y,
2672.     right,        
2673.     left;
2675. UCHAR  *dest_addr;
2678. if (x3 < x2)
2679.    {
2680.    temp_x = x2;
2681.    x2     = x3;
2682.    x3     = temp_x;
2683.    } 
2685. height = y3-y1;
2687. dx_left  = (x2-x1)/height;
2688. dx_right = (x3-x1)/height;
2691. xs = (float)x1;
2692. xe = (float)x1; // +(float)0.5;
2694. if (y1<min_clip_y)
2695.    {
2696.    
2697.    xs = xs+dx_left*(float)(-y1+min_clip_y);
2698.    xe = xe+dx_right*(float)(-y1+min_clip_y);
2700.    y1=min_clip_y;
2702.    } 
2704. if (y3>max_clip_y)
2705.    y3=max_clip_y;
2707. dest_addr = dest_buffer+y1*mempitch;
2710. if (x1>=min_clip_x && x1<=max_clip_x &
2711.     x2>=min_clip_x && x2<=max_clip_x &
2712.     x3>=min_clip_x && x3<=max_clip_x)
2713.     {
2714.   
2715.     for (temp_y=y1; temp_y<=y3; temp_y++,dest_addr+=mempitch)
2716.         {
2717.         memset((UCHAR  *)dest_addr+(unsigned int)xs,
2718.                 color,(unsigned int)(xe-xs+1));
2720.        
2721.         xs+=dx_left;
2722.         xe+=dx_right;
2724.         } // end for
2726.     } 
2727. else
2728.    {
2730.    for (temp_y=y1; temp_y<=y3; temp_y++,dest_addr+=mempitch)
2731.        {
2733.        left  = (int)xs;
2734.        right = (int)xe;
2735.     
2736.        xs+=dx_left;
2737.        xe+=dx_right;
2740.        if (left < min_clip_x)
2741.           {
2742.           left = min_clip_x;
2744.           if (right < min_clip_x)
2745.              continue;
2746.           }
2748.        if (right > max_clip_x)
2749.           {
2750.           right = max_clip_x;
2752.           if (left > max_clip_x)
2753.              continue;
2754.           }
2756.        memset((UCHAR  *)dest_addr+(unsigned int)left,
2757.               color,(unsigned int)(right-left+1));
2759.        } // end for
2761.    } 
2763. } 
2765. ///////////////////////////////////////////////////////////////////////////////
2768. void Draw_Top_TriFP(int x1,int y1,
2769.                     int x2,int y2, 
2770.                     int x3,int y3,
2771.                     int color, 
2772.                     UCHAR *dest_buffer, int mempitch)
2773. {
2774. //绘制平顶三角形(效率模式)
2776. int dx_right,    
2777.     dx_left,     
2778.     xs,xe,       
2779.     height;     
2781. int temp_x,       
2782.     temp_y,
2783.     right,        
2784.     left;
2786. UCHAR  *dest_addr;
2789. if (y1==y3 || y2==y3)
2790.     return;
2792. if (x2 < x1)
2793.    {
2794.    temp_x = x2;
2795.    x2     = x1;
2796.    x1     = temp_x;
2797.    } 
2799. height = y3-y1;
2801. dx_left  = ((x3-x1)<<FIXP16_SHIFT)/height;
2802. dx_right = ((x3-x2)<<FIXP16_SHIFT)/height;
2804. xs = (x1<<FIXP16_SHIFT);
2805. xe = (x2<<FIXP16_SHIFT);
2807. if (y1<min_clip_y)
2808.    {
2810.    xs = xs+dx_left*(-y1+min_clip_y);
2811.    xe = xe+dx_right*(-y1+min_clip_y);
2813.    y1=min_clip_y;
2815.    } 
2817. if (y3>max_clip_y)
2818.    y3=max_clip_y;
2820. dest_addr = dest_buffer+y1*mempitch;
2822. if (x1>=min_clip_x && x1<=max_clip_x &
2823.     x2>=min_clip_x && x2<=max_clip_x &
2824.     x3>=min_clip_x && x3<=max_clip_x)
2825.     {
2826.     // 绘制三角形
2827.     for (temp_y=y1; temp_y<=y3; temp_y++,dest_addr+=mempitch)
2828.         {
2829.         memset((UCHAR *)dest_addr+((xs+FIXP16_ROUND_UP)>>FIXP16_SHIFT),
2830.                color, (((xe-xs+FIXP16_ROUND_UP)>>FIXP16_SHIFT)+1));
2832.         xs+=dx_left;
2833.         xe+=dx_right;
2835.         } 
2836.     } 
2837. else
2838.    {
2840.    for (temp_y=y1; temp_y<=y3; temp_y++,dest_addr+=mempitch)
2841.        {
2843.        left  = ((xs+FIXP16_ROUND_UP)>>16);
2844.        right = ((xe+FIXP16_ROUND_UP)>>16);
2846.        xs+=dx_left;
2847.        xe+=dx_right;
2849.        if (left < min_clip_x)
2850.           {
2851.           left = min_clip_x;
2853.           if (right < min_clip_x)
2854.              continue;
2855.           }
2857.        if (right > max_clip_x)
2858.           {
2859.           right = max_clip_x;
2861.           if (left > max_clip_x)
2862.              continue;
2863.           }
2865.        memset((UCHAR  *)dest_addr+(unsigned int)left,
2866.               color,(unsigned int)(right-left+1));
2868.        } // end for
2870.    } 
2872. } 
2874. /////////////////////////////////////////////////////////////////////////////
2876. void Draw_Bottom_TriFP(int x1,int y1, 
2877.                        int x2,int y2, 
2878.                        int x3,int y3,
2879.                        int color,
2880.                        UCHAR *dest_buffer, int mempitch)
2881. {
2882. //绘制平底三角形(效率模式)
2884. int dx_right,    
2885.     dx_left,    
2886.     xs,xe,       
2887.     height;     
2889. int temp_x,       
2890.     temp_y,
2891.     right,         
2892.     left;
2894. UCHAR  *dest_addr;
2896. if (y1==y2 || y1==y3)
2897.     return;
2899. if (x3 < x2)
2900.    {
2901.    temp_x = x2;
2902.    x2     = x3;
2903.    x3     = temp_x;
2905.    } 
2907. height = y3-y1;
2909. dx_left  = ((x2-x1)<<FIXP16_SHIFT)/height;
2910. dx_right = ((x3-x1)<<FIXP16_SHIFT)/height;
2912. xs = (x1<<FIXP16_SHIFT);
2913. xe = (x1<<FIXP16_SHIFT); 
2915. if (y1<min_clip_y)
2916.    {
2918.    xs = xs+dx_left*(-y1+min_clip_y);
2919.    xe = xe+dx_right*(-y1+min_clip_y);
2921.    y1=min_clip_y;
2923.    } 
2925. if (y3>max_clip_y)
2926.    y3=max_clip_y;
2928. dest_addr = dest_buffer+y1*mempitch;
2930. if (x1>=min_clip_x && x1<=max_clip_x &
2931.     x2>=min_clip_x && x2<=max_clip_x &
2932.     x3>=min_clip_x && x3<=max_clip_x)
2933.     {
2935.     for (temp_y=y1; temp_y<=y3; temp_y++,dest_addr+=mempitch)
2936.         {
2937.         memset((UCHAR *)dest_addr+((xs+FIXP16_ROUND_UP)>>FIXP16_SHIFT),
2938.                 color, (((xe-xs+FIXP16_ROUND_UP)>>FIXP16_SHIFT)+1));
2940.         xs+=dx_left;
2941.         xe+=dx_right;
2943.         } 
2945.     } 
2946. else
2947.    {
2949.    for (temp_y=y1; temp_y<=y3; temp_y++,dest_addr+=mempitch)
2950.        {
2952.        left  = ((xs+FIXP16_ROUND_UP)>>FIXP16_SHIFT);
2953.        right = ((xe+FIXP16_ROUND_UP)>>FIXP16_SHIFT);
2955.        xs+=dx_left;
2956.        xe+=dx_right;
2958.        if (left < min_clip_x)
2959.           {
2960.           left = min_clip_x;
2962.           if (right < min_clip_x)
2963.              continue;
2964.           }
2966.        if (right > max_clip_x)
2967.           {
2968.           right = max_clip_x;
2970.           if (left > max_clip_x)
2971.              continue;
2972.           }
2974.        memset((UCHAR *)dest_addr+left,
2975.               color, (right-left+1));
2977.        } // end for
2979.    } 
2981. }
2983. void Draw_Top_Tri16(int x1,int y1, 
2984.                     int x2,int y2, 
2985.                     int x3,int y3,
2986.                     int color, 
2987.                     UCHAR *_dest_buffer, int mempitch)
2988. {
2989. // 画平顶三角形(16位,精确模式)
2991. float dx_right,    
2992.       dx_left,     
2993.       xs,xe,       
2994.       height;   
2996. int temp_x,        
2997.     temp_y,
2998.     right,       
2999.     left;
3001. USHORT *dest_buffer = (USHORT *)_dest_buffer;
3002. mempitch = (mempitch >> 1);
3004. USHORT  *dest_addr = NULL;
3006. if (x2 < x1)
3007.    {
3008.    temp_x = x2;
3009.    x2     = x1;
3010.    x1     = temp_x;
3011.    } 
3013. height = y3-y1;
3015. dx_left  = (x3-x1)/height;
3016. dx_right = (x3-x2)/height;
3018. xs = (float)x1;
3019. xe = (float)x2+(float)0.5;
3022. if (y1 < min_clip_y)
3023.    {
3024.    
3025.    xs = xs+dx_left*(float)(-y1+min_clip_y);
3026.    xe = xe+dx_right*(float)(-y1+min_clip_y);
3029.    y1=min_clip_y;
3031.    } 
3033. if (y3>max_clip_y)
3034.    y3=max_clip_y;
3036. dest_addr = dest_buffer+y1*mempitch;
3038. if (x1>=min_clip_x && x1<=max_clip_x &
3039.     x2>=min_clip_x && x2<=max_clip_x &
3040.     x3>=min_clip_x && x3<=max_clip_x)
3041.     {
3043.     for (temp_y=y1; temp_y<=y3; temp_y++,dest_addr+=mempitch)
3044.         {
3045.    
3046.         Mem_Set_WORD(dest_addr+(unsigned int)xs,color,(unsigned int)(xe-xs+1));
3048.         xs+=dx_left;
3049.         xe+=dx_right;
3051.         } // end for
3053.     } 
3054. else
3055.    {
3057.    for (temp_y=y1; temp_y<=y3; temp_y++,dest_addr+=mempitch)
3058.        {
3060.        left  = (int)xs;
3061.        right = (int)xe;
3063.        xs+=dx_left;
3064.        xe+=dx_right;
3066.        if (left < min_clip_x)
3067.           {
3068.           left = min_clip_x;
3070.           if (right < min_clip_x)
3071.              continue;
3072.           }
3074.        if (right > max_clip_x)
3075.           {
3076.           right = max_clip_x;
3078.           if (left > max_clip_x)
3079.              continue;
3080.           }
3082.         Mem_Set_WORD(dest_addr+(unsigned int)left,color,(unsigned int)(right-left+1));
3084.        } // end for
3086.    } 
3088. } 
3090. /////////////////////////////////////////////////////////////////////////////
3092. void Draw_Bottom_Tri16(int x1,int y1, 
3093.                        int x2,int y2, 
3094.                        int x3,int y3,
3095.                        int color,
3096.                        UCHAR *_dest_buffer, int mempitch)
3097. {
3098. // 画平底三角形(16位,精确模式)
3100. float dx_right,    // 右边1/斜率(右)
3101.       dx_left,     // 左边1/斜率(左)
3102.       xs,xe,       // 左右两边起始坐标
3103.       height;      // 三角形高度
3105. int temp_x,        
3106.     temp_y,
3107.     right,         
3108.     left;
3110. //16位模式转换
3111. USHORT *dest_buffer = (USHORT *)_dest_buffer;
3112. mempitch = (mempitch >> 1);
3114. USHORT  *dest_addr = NULL;
3116. // 测试使得 x3>x2
3117. if (x3 < x2)
3118.    {
3119.    temp_x = x2;
3120.    x2     = x3;
3121.    x3     = temp_x;
3122.    } 
3124. height = y3-y1;
3126. dx_left  = (x2-x1)/height;
3127. dx_right = (x3-x1)/height;
3129. //开始坐标
3130. xs = (float)x1;
3131. xe = (float)x1; // +(float)0.5;
3133. //裁剪顶部
3134. if (y1<min_clip_y)
3135.    {
3136.    // 计算新的 xs 和 xe
3137.    xs = xs+dx_left*(float)(-y1+min_clip_y);
3138.    xe = xe+dx_right*(float)(-y1+min_clip_y);
3140.    // 重置y1
3141.    y1=min_clip_y;
3143.    } 
3145. if (y3>max_clip_y)
3146.    y3=max_clip_y;
3148. // 计算开始目标行地址
3149. dest_addr = dest_buffer+y1*mempitch;
3152. // 如果三角形三点都在裁剪区域内
3153. if (x1>=min_clip_x && x1<=max_clip_x &
3154.     x2>=min_clip_x && x2<=max_clip_x &
3155.     x3>=min_clip_x && x3<=max_clip_x)
3156.     {
3157.     // 绘制三角形
3158.     for (temp_y=y1; temp_y<=y3; temp_y++,dest_addr+=mempitch)
3159.         {
3160.         // 画横线
3161.         Mem_Set_WORD(dest_addr+(unsigned int)xs,color,(unsigned int)(xe-xs+1));
3163.         // 加上单位高度变化的x坐标
3164.         xs+=dx_left;
3165.         xe+=dx_right;
3167.         }
3169.     } 
3170. else
3171.    {
3172.    //若三角形有部分在裁剪区域外
3174.    // 绘制三角形
3175.    for (temp_y=y1; temp_y<=y3; temp_y++,dest_addr+=mempitch)
3176.        {
3177.     
3178.        left  = (int)xs;
3179.        right = (int)xe;
3181.        // 加上单位高度变化的x坐标
3182.        xs+=dx_left;
3183.        xe+=dx_right;
3185.        // 裁剪直线
3186.        if (left < min_clip_x)
3187.           {
3188.           left = min_clip_x;
3190.           if (right < min_clip_x)
3191.              continue;
3192.           }
3194.        if (right > max_clip_x)
3195.           {
3196.           right = max_clip_x;
3198.           if (left > max_clip_x)
3199.              continue;
3200.           }
3202.        //绘制直线
3203.        Mem_Set_WORD(dest_addr+(unsigned int)left,color,(unsigned int)(right-left+1));
3205.        } 
3207.    } 
3209. } 
3211. ///////////////////////////////////////////////////////////////////////////////
3213. void Draw_TriangleFP_2D(int x1,int y1,
3214.                         int x2,int y2,
3215.                         int x3,int y3,
3216.                         int color,
3217.                         UCHAR *dest_buffer, int mempitch)
3218. {
3220. //绘制任意三角形(结合画平顶和画平底的方法,效率模式)
3222. int temp_x,
3223.     temp_y,
3224.     new_x;
3227. if ((x1==x2 && x2==x3)  ||  (y1==y2 && y2==y3))
3228.    return;
3231. if (y2<y1)
3232.    {
3233.    temp_x = x2;
3234.    temp_y = y2;
3235.    x2     = x1;
3236.    y2     = y1;
3237.    x1     = temp_x;
3238.    y1     = temp_y;
3239.    }
3242. if (y3<y1)
3243.    {
3244.    temp_x = x3;
3245.    temp_y = y3;
3246.    x3     = x1;
3247.    y3     = y1;
3248.    x1     = temp_x;
3249.    y1     = temp_y;
3250.    } 
3252. if (y3<y2)
3253.    {
3254.    temp_x = x3;
3255.    temp_y = y3;
3256.    x3     = x2;
3257.    y3     = y2;
3258.    x2     = temp_x;
3259.    y2     = temp_y;
3261.    } 
3263. if ( y3<min_clip_y || y1>max_clip_y ||
3264.     (x1<min_clip_x && x2<min_clip_x && x3<min_clip_x) ||
3265.     (x1>max_clip_x && x2>max_clip_x && x3>max_clip_x) )
3266.    return;
3268. if (y1==y2)
3269.    {
3270.    Draw_Top_TriFP(x1,y1,x2,y2,x3,y3,color, dest_buffer, mempitch);
3271.    } 
3272. else
3273. if (y2==y3)
3274.    {
3275.    Draw_Bottom_TriFP(x1,y1,x2,y2,x3,y3,color, dest_buffer, mempitch);
3276.    } 
3277. else
3278.    {
3279.    new_x = x1 + (int)(0.5+(float)(y2-y1)*(float)(x3-x1)/(float)(y3-y1));
3281.    Draw_Bottom_TriFP(x1,y1,new_x,y2,x2,y2,color, dest_buffer, mempitch);
3282.    Draw_Top_TriFP(x2,y2,new_x,y2,x3,y3,color, dest_buffer, mempitch);
3284.    } 
3286. }
3288. /////////////////////////////////////////////////////////////
3290. void Draw_Triangle_2D(int x1,int y1,
3291.                       int x2,int y2,
3292.                       int x3,int y3,
3293.                       int color,
3294.                       UCHAR *dest_buffer, int mempitch)
3295. {
3296. //画任意三角形(结合画平顶和画平底的方法,8位,精确模式)
3298. int temp_x, 
3299.     temp_y,
3300.     new_x;
3302. // 检测三点是否在同一直线
3303. if ((x1==x2 && x2==x3)  ||  (y1==y2 && y2==y3))
3304.    return;
3306. // 使纵坐标方向y3>y2>y1
3307. if (y2<y1)
3308.    {
3309.    temp_x = x2;
3310.    temp_y = y2;
3311.    x2     = x1;
3312.    y2     = y1;
3313.    x1     = temp_x;
3314.    y1     = temp_y;
3315.    } 
3317. if (y3<y1)
3318.    {
3319.    temp_x = x3;
3320.    temp_y = y3;
3321.    x3     = x1;
3322.    y3     = y1;
3323.    x1     = temp_x;
3324.    y1     = temp_y;
3325.    } 
3327. if (y3<y2)
3328.    {
3329.    temp_x = x3;
3330.    temp_y = y3;
3331.    x3     = x2;
3332.    y3     = y2;
3333.    x2     = temp_x;
3334.    y2     = temp_y;
3336.    } 
3338. // 检测三角形是否在裁剪区域外
3339. if ( y3<min_clip_y || y1>max_clip_y ||
3340.     (x1<min_clip_x && x2<min_clip_x && x3<min_clip_x) ||
3341.     (x1>max_clip_x && x2>max_clip_x && x3>max_clip_x) )
3342.    return;
3344. // 是否平顶
3345. if (y1==y2)
3346.    {
3347.    Draw_Top_Tri(x1,y1,x2,y2,x3,y3,color, dest_buffer, mempitch);
3348.    } 
3349. // 是否平底
3350. else
3351. if (y2==y3)
3352.    {
3353.    Draw_Bottom_Tri(x1,y1,x2,y2,x3,y3,color, dest_buffer, mempitch);
3354.    } 
3355. //任意三角形
3356. else
3357.    {
3359.    // 从最长边找到一点将三角形一分为二(平顶和平底)
3360.    new_x = x1 + (int)(0.5+(float)(y2-y1)*(float)(x3-x1)/(float)(y3-y1));
3362.    Draw_Bottom_Tri(x1,y1,new_x,y2,x2,y2,color, dest_buffer, mempitch);
3363.    Draw_Top_Tri(x2,y2,new_x,y2,x3,y3,color, dest_buffer, mempitch);
3365.    } 
3367. } 
3369. ///////////////////////////////////////////////////////////////////////////////
3371. void Draw_Triangle_2D16(int x1,int y1,
3372.                         int x2,int y2,
3373.                         int x3,int y3,
3374.                         int color,
3375.                         UCHAR *dest_buffer, int mempitch)
3376. {
3377. //画任意三角形(结合画平顶和画平底的方法,16位,精确模式)
3380. int temp_x, 
3381.     temp_y,
3382.     new_x;
3384. // 检测三点是否在同一直线
3385. if ((x1==x2 && x2==x3)  ||  (y1==y2 && y2==y3))
3386.    return;
3388. // 使纵坐标方向y3>y2>y1
3389. if (y2<y1)
3390.    {
3391.    temp_x = x2;
3392.    temp_y = y2;
3393.    x2     = x1;
3394.    y2     = y1;
3395.    x1     = temp_x;
3396.    y1     = temp_y;
3397.    } // end if
3399. if (y3<y1)
3400.    {
3401.    temp_x = x3;
3402.    temp_y = y3;
3403.    x3     = x1;
3404.    y3     = y1;
3405.    x1     = temp_x;
3406.    y1     = temp_y;
3407.    } // end if
3409. if (y3<y2)
3410.    {
3411.    temp_x = x3;
3412.    temp_y = y3;
3413.    x3     = x2;
3414.    y3     = y2;
3415.    x2     = temp_x;
3416.    y2     = temp_y;
3418.    } // end if
3420. // 检测三角形是否在裁剪区域外
3421. if ( y3<min_clip_y || y1>max_clip_y ||
3422.     (x1<min_clip_x && x2<min_clip_x && x3<min_clip_x) ||
3423.     (x1>max_clip_x && x2>max_clip_x && x3>max_clip_x) )
3424.    return;
3426. // 是否平顶
3427. if (y1==y2)
3428.    {
3429.    Draw_Top_Tri16(x1,y1,x2,y2,x3,y3,color, dest_buffer, mempitch);
3430.    }
3431. //是否平底
3432. else
3433. if (y2==y3)
3434.    {
3435.    Draw_Bottom_Tri16(x1,y1,x2,y2,x3,y3,color, dest_buffer, mempitch);
3436.    } 
3437. //任意三角形
3438. else
3439.    {
3440.    // 从最长边找到一点将三角形一分为二(平顶和平底)
3441.    new_x = x1 + (int)(0.5+(float)(y2-y1)*(float)(x3-x1)/(float)(y3-y1));
3443.    Draw_Bottom_Tri16(x1,y1,new_x,y2,x2,y2,color, dest_buffer, mempitch);
3444.    Draw_Top_Tri16(x2,y2,new_x,y2,x3,y3,color, dest_buffer, mempitch);
3446.    } 
3448. } 
3450. ////////////////////////////////////////////////////////////////////////////////
3452. inline void Draw_QuadFP_2D(int x0,int y0,
3453.                     int x1,int y1,
3454.                     int x2,int y2,
3455.                     int x3, int y3,
3456.                     int color,
3457.                     UCHAR *dest_buffer, int mempitch)
3458. {
3459. //画2D四边形
3461. //其实就是画2个三角形
3462. Draw_TriangleFP_2D(x0,y0,x1,y1,x3,y3,color,dest_buffer,mempitch);
3463. Draw_TriangleFP_2D(x1,y1,x2,y2,x3,y3,color,dest_buffer,mempitch);
3465. } 
3467. ////////////////////////////////////////////////////////////////////////////////
3470. int Mat_Mul_3X3(MATRIX3X3_PTR ma, MATRIX3X3_PTR mb, MATRIX3X3_PTR mprod)
3471. {
3472.   // 计算两个3X3矩阵相乘的矩阵
3474.   for (int row=0;row<3;row++)
3475.   {
3476.     for (int col=0;col<3;col++)
3477.     {
3478.       float sum=0;
3480.       for (int index=0;index<3;index++)
3481.       {
3482.         sum+=(ma->M[row][index]*mb->M[index][col]);
3483.       }
3485.       mprod->M[row][col] = sum;
3487.     }
3488.   }
3490.   return(1);
3491. }
3494. int Mat_Mul_1X3_3X3(MATRIX1X3_PTR ma, MATRIX3X3_PTR mb, MATRIX1X3_PTR mprod)
3495. {
3497.   for (int col=0;col<3;col++)
3498.   {
3499.     float sum=0;
3501.     for (int index=0;index<3;index)
3502.     {
3503.       sum+=(ma->M[index]*mb->M[index][col]);
3504.     }
3506.     mprod->M[col] =sum;
3508.   }
3510.   return(1);
3512. }
3514. int Mat_Mul_1X2_3X2(MATRIX1X2_PTR ma, MATRIX3X2_PTR mb, MATRIX1X2_PTR mprod)
3515. {
3517.   for (int col=0;col<2;col++)
3518.   {
3519.      float sum = 0;
3521.      for (int index=0;index<2;index++)
3522.      {
3523.         sum+=(ma->M[index]*mb->M[index][col]);
3524.      }
3526.      sum+=mb->M[index][col];    //这句很关键,相当于ma的第3个元素看作1
3528.      mprod->M[col] = sum;
3529.   }
3531.   return(1);
3533. }
3536. inline int Mat_Init_3X2(MATRIX3X2_PTR ma, 
3537.                         float m00, float m01, 
3538.                         float m10, float m11, 
3539.                         float m20, float m21)
3540. {
3541.   //初始化3X2矩阵
3543.   ma->M[0][0] = m00; ma->M[0][1] = m01; 
3544.   ma->M[1][0] = m10; ma->M[1][1] = m11; 
3545.   ma->M[2][0] = m20; ma->M[2][1] = m21;
3547.   return(1);
3549. }
3552. int Fast_Distance_2D(int x, int y)
3553. {
3554.   // 此函数计算2点间的距离(参数x,y为两点x/y轴方向的坐标差)
3555.   //到现在还没能够利用麦克劳林级数推出:(
3557.   x = abs(x);
3558.   y = abs(y);
3560.   int mn = MIN(x,y);
3562.   // 返回距离(3.5%的误差)
3563.   return(x+y-(mn>>1)-(mn>>2)+(mn>>4));
3565. } 
3567. ///////////////////////////////////////////////////////////////////////////////
3569. float Fast_Distance_3D(float fx, float fy, float fz)
3570. {
3571.   
3572.   //计算3维中两点的距离 
3574.   int temp;  // 临时变量
3575.   int x,y,z; 
3577.   x = fabs(fx) * 1024;
3578.   y = fabs(fy) * 1024;
3579.   z = fabs(fz) * 1024;
3581.   
3582.   if (y < x) SWAP(x,y,temp);
3583.   if (z < y) SWAP(y,z,temp);
3584.   if (y < x) SWAP(x,y,temp);    // 若上一句执行,此时的y中的值为z,所以再进行比较一次
3586.   int dist = (z + 11*(y >> 5) + (x >> 2) );
3588.   // 返回距离(8%的误差)
3589.   return((float)(dist >> 10));
3591. } 
3594. int Find_Bounding_Box_Poly2D(POLYGON2D_PTR poly, 
3595.                              float &min_x, float &max_x, 
3596.                              float &min_y, float &max_y)
3597. {
3598.   //找到多边形的边界边框矩形
3600.   if (poly->num_verts==0)
3601.     return(0);
3603.   max_x = max_y = min_x = min_y =0;
3604.   
3605.   for (int index=0;index<poly->num_verts;index++)
3606.   {
3607.     if (poly->vlist[index].x > max_x)
3608.       max_x = poly->vlist[index].x;
3609.     if (poly->vlist[index].x < min_x)
3610.       min_x = poly->vlist[index].x;
3611.     if (poly->vlist[index].y > max_y)
3612.       max_y = poly->vlist[index].y;
3613.     if (poly->vlist[index].y < min_y)
3614.       min_y =poly->vlist[index].y;  
3615.   }
3617.   return(1);
3619. }
3623. int Draw_Filled_Polygon2D(POLYGON2D_PTR poly,UCHAR *vbuffer,int mempitch)
3624. {
3625.   //绘制填充多边形(8位)
3627.   int ydiff1,ydiff2,
3628.       xdiff1,xdiff2,
3629.       start,
3630.       length,
3631.       errorterm1,errorterm2,
3632.       offset1,offset2,
3633.       count1,count2,
3634.       xunit1,xunit2;
3636.   int edgecount = poly->num_verts-1;
3637.   int firstvert=0;
3638.   int min_y=poly->vlist[0].y;
3639.   
3640.   for (int index=1;index<poly->num_verts;index++)
3641.   {/*找到y轴坐标最小的顶点*/
3642.     
3643.     if ((poly->vlist[index].y)<min_y)
3644.     {
3645.       firstvert=index;
3646.       min_y=poly->vlist[index].y;
3647.     }
3648.   }
3650.   int startvert1=firstvert;
3651.   int startvert2=firstvert;
3652.   int xstart1=poly->vlist[startvert1].x+poly->x0;  //逆时针移动的初始位置
3653.   int ystart1=poly->vlist[startvert1].y+poly->y0;
3654.   int xstart2=poly->vlist[startvert2].x+poly->x0;  //顺时针移动的初始位置
3655.   int ystart2=poly->vlist[startvert2].y+poly->y0;
3657.   /*取得逆时针移动遇到的第1个顶点坐标*/
3658.   int endvert1=startvert1-1;
3659.   if (endvert1<0)
3660.     endvert1=poly->num_verts-1;
3661.   int xend1=poly->vlist[endvert1].x+poly->x0;
3662.   int yend1=poly->vlist[endvert1].y+poly->y0;
3663.   
3664.   /*取得顺时针移动遇到的第1个顶点坐标*/
3665.   int endvert2=startvert2+1;
3666.   if(endvert2==(poly->num_verts))
3667.     endvert2=0;
3668.   int xend2=poly->vlist[endvert2].x+poly->x0;
3669.   int yend2=poly->vlist[endvert2].y+poly->y0;
3671.   //绘制并填充多边形
3672.   while (edgecount>0)
3673.   {
3674.     offset1=mempitch*ystart1+xstart1; //左边缘偏移量
3675.     offset2=mempitch*ystart2+xstart2; //右边缘偏移量
3676.     
3677.     //初始化误差额
3678.     errorterm1=0;
3679.     errorterm2=0;
3680.     
3681.     //初始化左边与右边x&y方向的偏移差
3682.     if ((ydiff1=yend1-ystart1)<0)
3683.       ydiff1=-ydiff1;
3684.     if ((ydiff2=yend2-ystart2)<0)
3685.       ydiff2=-ydiff2;
3686.     if ((xdiff1=xend1-xstart1)<0)
3687.     {
3688.       xunit1=-1;
3689.       xdiff1=-xdiff1;
3690.     }
3691.     else
3692.     {
3693.       xunit1=1;
3694.     }
3695.     if ((xdiff2=xend2-xstart2)<0)
3696.     {
3697.       xunit2=-1;
3698.       xdiff2=-xdiff2;
3699.     }
3700.     else
3701.     {
3702.       xunit2=1;
3703.     }
3704.     
3705.     //选择使用哪种情况
3706.     if (xdiff1>ydiff1)
3707.     {/*|k1|<1*/
3708.       if (xdiff2>ydiff2)
3709.       {/*|k2|<1*/
3711.         count1=xdiff1;    //左边X的增量
3712.         count2=xdiff2;    //右边X的增量
3714.         while (count1&&count2)
3715.         {
3716.           while ((errorterm1<xdiff1)&&(count1>0))
3717.           {
3718.             if(count1--)
3719.             {
3720.               offset1+=xunit1;
3721.               xstart1+=xunit1;
3722.             }
3723.             errorterm1+=ydiff1;
3724.             if (errorterm1<xdiff1)
3725.             {
3726.               vbuffer[offset1]=(UCHAR)poly->color;
3727.             }
3728.           }
3730.           errorterm1-=xdiff1;
3732.           while ((errorterm2<xdiff2)&&(count2>0))
3733.           {
3734.             if (count2--)
3735.             {
3736.               offset2+=xunit2;
3737.               xstart2+=xunit2;
3738.             }
3739.             errorterm2+=ydiff2;
3741.             if (errorterm2<xdiff2)
3742.             {
3743.               vbuffer[offset2]=(UCHAR)poly->color;
3744.             }
3745.           }
3747.           errorterm2-=xdiff2;
3749.           length=offset2-offset1;
3750.           if (length<0)
3751.           {
3752.             length=-length;
3753.             start=offset2;
3754.           }
3755.           else
3756.             start=offset1;
3758.           for (int index=start;index<start+length+1;index++)
3759.           {
3760.             vbuffer[index]=(UCHAR)poly->color;
3761.           }
3763.           offset1+=mempitch;
3764.           ystart1++;
3765.           offset2+=mempitch;
3766.           ystart2++;
3768.         }
3770.       }
3771.       else
3772.       {/*|k2|>1*/
3774.         count1=xdiff1;
3775.         count2=ydiff2;
3777.         while (count1&&count2)
3778.         {
3779.           while ((errorterm1<xdiff1)&&(count1>0))
3780.           {
3781.             if(count1--)
3782.             {
3783.               offset1+=xunit1;
3784.               xstart1+=xunit1;
3785.             }
3786.             errorterm1+=ydiff1;
3787.             if (errorterm1<xdiff1)
3788.             {
3789.               vbuffer[offset1]=(UCHAR)poly->color;
3790.             }
3791.           }
3793.           errorterm1-=xdiff1;
3794.           
3795.           errorterm2+=xdiff2;
3796.           if (errorterm2>=ydiff2)
3797.           {
3798.             errorterm2-=ydiff2;
3799.             offset2+=xunit2;
3800.             xstart2+=xunit2;
3801.           }
3802.           count2--;
3804.           length=offset2-offset1;
3805.           if (length<0)
3806.           {
3807.             length=-length;
3808.             start=offset2;
3809.           }
3810.           else
3811.             start=offset1;
3812.           
3813.           for (int index=start;index<start+length+1;index++)
3814.           {
3815.             vbuffer[index]=(UCHAR)poly->color;
3816.           }
3818.           offset1+=mempitch;
3819.           ystart1++;
3820.           offset2+=mempitch;
3821.           ystart2++;
3822.         }
3823.       }
3824.     }
3826.     else
3827.     {/*|k1|>1*/
3828.       if (xdiff2>ydiff2)
3829.       {/*|k2|<1*/
3831.         count1=ydiff1;
3832.         count2=xdiff2;
3834.         while (count1&&count2)
3835.         {
3836.           errorterm1+=xdiff1;
3837.           if (errorterm1>=ydiff1)
3838.           {
3839.             errorterm1-=ydiff1;
3840.             offset1+=xunit1;
3841.             xstart1+=xunit1;
3842.           }
3844.           count1--;
3845.           
3846.           while ((errorterm2<xdiff2)&&(count2>0))
3847.           {
3848.             if (count2--)
3849.             {
3850.               offset2+=xunit2;
3851.               xstart2+=xunit2;
3852.             }
3853.             errorterm2+=ydiff2;
3854.             if (errorterm2<xdiff2)
3855.             {
3856.               vbuffer[offset2]=(UCHAR)poly->color;
3857.             }
3858.         
3859.           }
3860.           errorterm2-=xdiff2;
3862.           length=offset2-offset1;
3863.           if (length<0)
3864.           {
3865.             length=-length;
3866.             start=offset2;
3867.           }
3868.           else
3869.             start=offset1;
3871.           for (int index=start;index<start+length+1;index++)
3872.           {
3873.             vbuffer[index]=(UCHAR)poly->color;
3874.           }
3876.           offset1+=mempitch;
3877.           ystart1++;
3878.           offset2+=mempitch;
3879.           ystart2++;
3880.         }
3881.       }
3882.       else
3883.       {/*|k2|>1*/
3884.         
3885.         count1=ydiff1;
3886.         count2=ydiff2;
3887.         while (count1&&count2)
3888.         {
3889.           errorterm1+=xdiff1;
3890.           if (errorterm1>=ydiff1)
3891.           {
3892.             errorterm1-=ydiff1;
3893.             offset1+=xunit1;
3894.             xstart1+=xunit1;
3895.           }
3896.           count1--;
3898.           errorterm2+=xdiff2;
3899.           if (errorterm2>=ydiff2)
3900.           {
3901.             errorterm2-=ydiff2;
3902.             offset2+=xunit2;
3903.             xstart2+=xunit2;
3904.           }
3905.           count2--;
3907.           length=offset2-offset1;
3908.           if (length<0)
3909.           {
3910.             length=-length;
3911.             start=offset2;
3912.           }
3913.           else
3914.             start=offset1;
3916.           for (int index=start;index<start+length+1;index++)
3917.           {
3918.             vbuffer[index]=(UCHAR)poly->color;
3919.           }
3921.           offset1+=mempitch;
3922.           ystart1++;
3923.           offset2+=mempitch;
3924.           ystart2++;
3925.         }
3926.       }
3927.     }
3929.     if (!count1)
3930.     {/*首先到达逆时针顶点*/
3932.       --edgecount;
3933.       startvert1=endvert1;
3934.       --endvert1;
3936.       if (endvert1<0)
3937.         endvert1=poly->num_verts-1;
3939.       xend1=poly->vlist[endvert1].x+poly->x0;
3940.       yend1=poly->vlist[endvert1].y+poly->y0;
3941.     }
3943.     if (!count2)
3944.     {/*首先到达顺时针顶点*/
3946.       --edgecount;
3947.       startvert2=endvert2;
3948.       ++endvert2;
3950.       if(endvert2==(poly->num_verts))
3951.         endvert2=0;
3953.       xend2=poly->vlist[endvert2].x+poly->x0;
3954.       yend2=poly->vlist[endvert2].y+poly->y0;
3956.     }
3957.     
3959.   }
3960.   
3961.   return(1);
3962. }
3965. int Draw_Filled_Polygon2D16(POLYGON2D_PTR poly, UCHAR *_vbuffer, int mempitch)
3966. {
3967.   //绘制填充多边形(16位)
3969.   int ydiff1,ydiff2,
3970.       xdiff1,xdiff2,
3971.       start,
3972.       length,
3973.       errorterm1,errorterm2,
3974.       offset1,offset2,
3975.       count1,count2,
3976.       xunit1,xunit2;
3978.   USHORT *vbuffer = (USHORT*)_vbuffer;
3980.   mempitch = mempitch>>1;
3982.   int edgecount = poly->num_verts-1;
3983.   int firstvert=0;
3984.   int min_y=poly->vlist[0].y;
3985.   
3986.   for (int index=1;index<poly->num_verts;index++)
3987.   {/*找到y轴坐标最小的顶点*/
3988.     
3989.     if ((poly->vlist[index].y)<min_y)
3990.     {
3991.       firstvert=index;
3992.       min_y=poly->vlist[index].y;
3993.     }
3994.   }
3996.   int startvert1=firstvert;
3997.   int startvert2=firstvert;
3998.   int xstart1=poly->vlist[startvert1].x+poly->x0;  //逆时针移动的初始位置
3999.   int ystart1=poly->vlist[startvert1].y+poly->y0;
4000.   int xstart2=poly->vlist[startvert2].x+poly->x0;  //顺时针移动的初始位置
4001.   int ystart2=poly->vlist[startvert2].y+poly->y0;
4003.   /*取得逆时针移动遇到的第1个顶点坐标*/
4004.   int endvert1=startvert1-1;
4005.   if (endvert1<0)
4006.     endvert1=poly->num_verts-1;
4007.   int xend1=poly->vlist[endvert1].x+poly->x0;
4008.   int yend1=poly->vlist[endvert1].y+poly->y0;
4009.   
4010.   /*取得顺时针移动遇到的第1个顶点坐标*/
4011.   int endvert2=startvert2+1;
4012.   if(endvert2==(poly->num_verts))
4013.     endvert2=0;
4014.   int xend2=poly->vlist[endvert2].x+poly->x0;
4015.   int yend2=poly->vlist[endvert2].y+poly->y0;
4017.   //绘制并填充多边形
4018.   while (edgecount>0)
4019.   {
4020.     offset1=mempitch*ystart1+xstart1; //左边缘偏移量
4021.     offset2=mempitch*ystart2+xstart2; //右边缘偏移量
4022.     
4023.     //初始化误差额
4024.     errorterm1=0;
4025.     errorterm2=0;
4026.     
4027.     //初始化左边与右边x&y方向的偏移差
4028.     if ((ydiff1=yend1-ystart1)<0)
4029.       ydiff1=-ydiff1;
4030.     if ((ydiff2=yend2-ystart2)<0)
4031.       ydiff2=-ydiff2;
4032.     if ((xdiff1=xend1-xstart1)<0)
4033.     {
4034.       xunit1=-1;
4035.       xdiff1=-xdiff1;
4036.     }
4037.     else
4038.     {
4039.       xunit1=1;
4040.     }
4041.     if ((xdiff2=xend2-xstart2)<0)
4042.     {
4043.       xunit2=-1;
4044.       xdiff2=-xdiff2;
4045.     }
4046.     else
4047.     {
4048.       xunit2=1;
4049.     }
4050.     
4051.     //选择使用哪种情况
4052.     if (xdiff1>ydiff1)
4053.     {/*|k1|<1*/
4054.       if (xdiff2>ydiff2)
4055.       {/*|k2|<1*/
4057.         count1=xdiff1;    //左边X的增量
4058.         count2=xdiff2;    //右边X的增量
4060.         while (count1&&count2)
4061.         {
4062.           while ((errorterm1<xdiff1)&&(count1>0))
4063.           {
4064.             if(count1--)
4065.             {
4066.               offset1+=xunit1;
4067.               xstart1+=xunit1;
4068.             }
4069.             errorterm1+=ydiff1;
4070.             if (errorterm1<xdiff1)
4071.             {
4072.               vbuffer[offset1]=(USHORT)poly->color;
4073.             }
4074.           }
4076.           errorterm1-=xdiff1;
4078.           while ((errorterm2<xdiff2)&&(count2>0))
4079.           {
4080.             if (count2--)
4081.             {
4082.               offset2+=xunit2;
4083.               xstart2+=xunit2;
4084.             }
4085.             errorterm2+=ydiff2;
4087.             if (errorterm2<xdiff2)
4088.             {
4089.               vbuffer[offset2]=(USHORT)poly->color;
4090.             }
4091.           }
4093.           errorterm2-=xdiff2;
4095.           length=offset2-offset1;
4096.           if (length<0)
4097.           {
4098.             length=-length;
4099.             start=offset2;
4100.           }
4101.           else
4102.             start=offset1;
4104.           for (int index=start;index<start+length+1;index++)
4105.           {
4106.             vbuffer[index]=(USHORT)poly->color;
4107.           }
4109.           offset1+=mempitch;
4110.           ystart1++;
4111.           offset2+=mempitch;
4112.           ystart2++;
4114.         }
4116.       }
4117.       else
4118.       {/*|k2|>1*/
4120.         count1=xdiff1;
4121.         count2=ydiff2;
4123.         while (count1&&count2)
4124.         {
4125.           while ((errorterm1<xdiff1)&&(count1>0))
4126.           {
4127.             if(count1--)
4128.             {
4129.               offset1+=xunit1;
4130.               xstart1+=xunit1;
4131.             }
4132.             errorterm1+=ydiff1;
4133.             if (errorterm1<xdiff1)
4134.             {
4135.               vbuffer[offset1]=(USHORT)poly->color;
4136.             }
4137.           }
4139.           errorterm1-=xdiff1;
4140.           
4141.           errorterm2+=xdiff2;
4142.           if (errorterm2>=ydiff2)
4143.           {
4144.             errorterm2-=ydiff2;
4145.             offset2+=xunit2;
4146.             xstart2+=xunit2;
4147.           }
4148.           count2--;
4150.           length=offset2-offset1;
4151.           if (length<0)
4152.           {
4153.             length=-length;
4154.             start=offset2;
4155.           }
4156.           else
4157.             start=offset1;
4158.           
4159.           for (int index=start;index<start+length+1;index++)
4160.           {
4161.             vbuffer[index]=(USHORT)poly->color;
4162.           }
4164.           offset1+=mempitch;
4165.           ystart1++;
4166.           offset2+=mempitch;
4167.           ystart2++;
4168.         }
4169.       }
4170.     }
4172.     else
4173.     {/*|k1|>1*/
4174.       if (xdiff2>ydiff2)
4175.       {/*|k2|<1*/
4177.         count1=ydiff1;
4178.         count2=xdiff2;
4180.         while (count1&&count2)
4181.         {
4182.           errorterm1+=xdiff1;
4183.           if (errorterm1>=ydiff1)
4184.           {
4185.             errorterm1-=ydiff1;
4186.             offset1+=xunit1;
4187.             xstart1+=xunit1;
4188.           }
4190.           count1--;
4191.           
4192.           while ((errorterm2<xdiff2)&&(count2>0))
4193.           {
4194.             if (count2--)
4195.             {
4196.               offset2+=xunit2;
4197.               xstart2+=xunit2;
4198.             }
4199.             errorterm2+=ydiff2;
4200.             if (errorterm2<xdiff2)
4201.             {
4202.               vbuffer[offset2]=(USHORT)poly->color;
4203.             }
4204.         
4205.           }
4206.           errorterm2-=xdiff2;
4208.           length=offset2-offset1;
4209.           if (length<0)
4210.           {
4211.             length=-length;
4212.             start=offset2;
4213.           }
4214.           else
4215.             start=offset1;
4217.           for (int index=start;index<start+length+1;index++)
4218.           {
4219.             vbuffer[index]=(USHORT)poly->color;
4220.           }
4222.           offset1+=mempitch;
4223.           ystart1++;
4224.           offset2+=mempitch;
4225.           ystart2++;
4226.         }
4227.       }
4228.       else
4229.       {/*|k2|>1*/
4230.         
4231.         count1=ydiff1;
4232.         count2=ydiff2;
4233.         while (count1&&count2)
4234.         {
4235.           errorterm1+=xdiff1;
4236.           if (errorterm1>=ydiff1)
4237.           {
4238.             errorterm1-=ydiff1;
4239.             offset1+=xunit1;
4240.             xstart1+=xunit1;
4241.           }
4242.           count1--;
4244.           errorterm2+=xdiff2;
4245.           if (errorterm2>=ydiff2)
4246.           {
4247.             errorterm2-=ydiff2;
4248.             offset2+=xunit2;
4249.             xstart2+=xunit2;
4250.           }
4251.           count2--;
4253.           length=offset2-offset1;
4254.           if (length<0)
4255.           {
4256.             length=-length;
4257.             start=offset2;
4258.           }
4259.           else
4260.             start=offset1;
4262.           for (int index=start;index<start+length+1;index++)
4263.           {
4264.             vbuffer[index]=(USHORT)poly->color;
4265.           }
4267.           offset1+=mempitch;
4268.           ystart1++;
4269.           offset2+=mempitch;
4270.           ystart2++;
4271.         }
4272.       }
4273.     }
4275.     if (!count1)
4276.     {/*首先到达逆时针顶点*/
4278.       --edgecount;
4279.       startvert1=endvert1;
4280.       --endvert1;
4282.       if (endvert1<0)
4283.         endvert1=poly->num_verts-1;
4285.       xend1=poly->vlist[endvert1].x+poly->x0;
4286.       yend1=poly->vlist[endvert1].y+poly->y0;
4287.     }
4289.     if (!count2)
4290.     {/*首先到达顺时针顶点*/
4292.       --edgecount;
4293.       startvert2=endvert2;
4294.       ++endvert2;
4296.       if(endvert2==(poly->num_verts))
4297.         endvert2=0;
4299.       xend2=poly->vlist[endvert2].x+poly->x0;
4300.       yend2=poly->vlist[endvert2].y+poly->y0;
4302.     }
4303.     
4305.   }
4306.   
4307.   return(1);
4309. }
4313. void Build_Sin_Cos_Tables(void)
4314. {
4315.   //创建三角函数表
4317.   for (int ang=0;ang<=360;ang++)
4318.   {
4319.     float theta = float(ang)*PI/(float)180;
4321.     cos_look[ang] = cos(theta);
4322.     sin_look[ang] = sin(theta);
4323.   }
4325. }
4329. int Translate_Polygon2D(POLYGON2D_PTR poly,int dx,int dy)
4330. {
4331.   //移动多边形
4333.   if(!poly)
4334.     return(0);
4335.   poly->x0+=dx;
4336.   poly->y0+=dy;
4338.   return(1);
4339. }
4341. int Scale_Polygon2D(POLYGON2D_PTR poly,float sx,float sy)
4342. {
4343.   //缩放多边形
4345.   if(!poly)
4346.     return(0);
4347.   for (int cur_vest=0;cur_vest<poly->num_verts;cur_vest++)
4348.   {
4349.     poly->vlist[cur_vest].x*=sx;
4350.     poly->vlist[cur_vest].y*=sy;
4351.   }
4353.   return(1);
4354. }
4356. int Rotate_Polygon2D(POLYGON2D_PTR poly,int theta)
4357. {
4358.   //旋转多边形
4360.   if(!poly)
4361.     return(0);
4362.   for(int curr_vert=0;curr_vert<poly->num_verts;curr_vert++)
4363.   {
4364.     float xr=poly->vlist[curr_vert].x*cos_look[theta]-
4365.               poly->vlist[curr_vert].y*sin_look[theta];
4366.     float yr=poly->vlist[curr_vert].x*sin_look[theta]+
4367.               poly->vlist[curr_vert].y*cos_look[theta];
4369.     poly->vlist[curr_vert].x=xr;
4370.     poly->vlist[curr_vert].y=yr;
4371.   }
4373.   return(1);
4374. }
4378. int Draw_Polygon2D(POLYGON2D_PTR poly,UCHAR *vbuffer,int lpitch)
4379. {
4380.   //绘制2D多边形(8位)
4382.   if(poly->state)
4383.   {
4384.     for(int index=0;index<poly->num_verts-1;index++)
4385.     {/*依次连接1～n-1个顶点*/
4386.       Draw_Clip_Line(poly->vlist[index].x+poly->x0,
4387.                      poly->vlist[index].y+poly->y0,
4388.                      poly->vlist[index+1].x+poly->x0,
4389.                      poly->vlist[index+1].y+poly->y0,
4390.                      poly->color,
4391.                      vbuffer,lpitch);
4392.     }
4393.     //连接顶点1和顶点n
4394.     Draw_Clip_Line(poly->vlist[0].x+poly->x0,
4395.                    poly->vlist[0].y+poly->y0,
4396.                    poly->vlist[index].x+poly->x0,
4397.                    poly->vlist[index].y+poly->y0,
4398.                    poly->color,
4399.                    vbuffer,lpitch);
4400.     return(1);
4402.   }
4403.   else
4404.     return(0);
4406. }
4409. int Draw_Polygon2D16(POLYGON2D_PTR poly,UCHAR *vbuffer,int lpitch)
4410. {
4411.   //绘制2D多边形(16位)
4413.   if(poly->state)
4414.   {
4415.     for(int index=0;index<poly->num_verts-1;index++)
4416.     {/*依次连接1～n-1个顶点*/
4417.       Draw_Clip_Line16(poly->vlist[index].x+poly->x0,
4418.                       poly->vlist[index].y+poly->y0,
4419.                       poly->vlist[index+1].x+poly->x0,
4420.                       poly->vlist[index+1].y+poly->y0,
4421.                       poly->color,
4422.                       vbuffer,lpitch);
4423.     }
4424.     //连接顶点1和顶点n
4425.     Draw_Clip_Line16(poly->vlist[0].x+poly->x0,
4426.                      poly->vlist[0].y+poly->y0,
4427.                      poly->vlist[index].x+poly->x0,
4428.                      poly->vlist[index].y+poly->y0,
4429.                      poly->color,
4430.                      vbuffer,lpitch);
4431.     return(1);
4433.   }
4434.   else
4435.     return(0);
4437. }
4441. /*以下三个函数以矩阵运算实现2D多边形的平移,缩放,旋转*/
4443. int Translate_Polygon2D_Mat(POLYGON2D_PTR poly,int dx,int dy)
4444. {
4445.   if (!poly)
4446.     return(0);
4447.   MATRIX3X2 mt;
4448.   Mat_Init_3X2(&mt,1,0,0,1,dx,dy);
4450.   MATRIX1X2 p0={float(poly->x0),float(poly->y0)};
4451.   MATRIX1X2 p1={0,0};
4453.   Mat_Mul_1X2_3X2(&p0,&mt,&p1);
4454.   
4455.   poly->x0=p1.M[0];
4456.   poly->y0=p1.M[1];
4458.   return(1);
4459.     
4460. }
4462. int Scale_Polygon2D_Mat(POLYGON2D_PTR poly,float sx,float sy)
4463. {
4464.   if(!poly)
4465.     return(0);
4466.   MATRIX3X2 ms;
4467.   Mat_Init_3X2(&ms,sx,0,0,sy,0,0);
4468.   for (int cur_vest=0;cur_vest<poly->num_verts;cur_vest++)
4469.   {
4470.     MATRIX1X2 p0={poly->vlist[cur_vest].x,poly->vlist[cur_vest].y};
4471.     MATRIX1X2 p1={0,0};
4473.     Mat_Mul_1X2_3X2(&p0,&ms,&p1);
4475.     poly->vlist[cur_vest].x=p1.M[0];
4476.     poly->vlist[cur_vest].y=p1.M[1];
4477.   }
4479.   return(1);
4480. }
4482. int Rotate_Polygon2D_Mat(POLYGON2D_PTR poly,int theta)
4483. {
4484.   if(!poly)
4485.     return(0);
4487.   if(theta<0)
4488.     theta+=360;
4490.   MATRIX3X2 mr;
4491.   Mat_Init_3X2(&mr,cos_look[theta],sin_look[theta],-sin_look[theta],cos_look[theta],0,0);
4492.   for (int cur_vest=0;cur_vest<poly->num_verts;cur_vest++)
4493.   {
4494.     MATRIX1X2 p0={poly->vlist[cur_vest].x,poly->vlist[cur_vest].y};
4495.     MATRIX1X2 p1={0,0};
4496.     Mat_Mul_1X2_3X2(&p0,&mr,&p1);
4498.     poly->vlist[cur_vest].x=p1.M[0];
4499.     poly->vlist[cur_vest].y=p1.M[1];
4500.   }
4502.   return(1);
4503. }
4506. //////////////////////////////////////////////////////////
4509. int Create_BOB(BOB_PTR bob,                     //须创建的BOB对象
4510.                int x, int y,                    //初始位置
4511.                int width, int height,           //宽,高
4512.                int num_frames,                  //帧数
4513.                int attr,                        //属性
4514.                int mem_flags/* =0 */,           //存储方式(默认在显存)
4515.                USHORT color_key_value/* =0 */,  //默认色彩键为黑色
4516.                int bpp/* =8 */)                 //默认色深为8位
4517. {
4518.   DDSURFACEDESC2 ddsd;
4519.   int index;
4521.   //初始化BOB对象
4522.   bob->state      = BOB_STATE_ALIVE;
4523.   bob->attr       = attr;
4524.   bob->anim_state = 0;
4525.   bob->counter_1  = 0;
4526.   bob->counter_2  = 0;
4527.   bob->max_count_1= 0;
4528.   bob->max_count_2= 0;
4529.   bob->curr_frame = 0;
4530.   bob->num_frames = num_frames;
4531.   bob->bpp        = bpp;
4532.   bob->curr_animation= 0;
4533.   bob->anim_counter  = 0;
4534.   bob->anim_index    = 0;
4535.   bob->anim_count_max= 0;
4536.   bob->x             = x;
4537.   bob->y             = y;
4538.   bob->xv            = 0;
4539.   bob->yv            = 0;
4541.   bob->width  = width;
4542.   bob->height = height;
4544.   for (index=0;index<MAX_BOB_FRAMES;index++)
4545.     bob->images[index] = NULL;
4547.   for (index=0;index<MAX_BOB_ANIMATIONS;index++)
4548.     bob->animations[index] = NULL;
4550.   #if 0
4551.   // 须保证显示表面宽为8的倍数,一些旧版本的DD那样做,现在不需要
4552.   bob->width_fill = ((width%8!=0) ? (8-width%8) : 0);
4553.   Write_Error("/nCreate BOB: width_fill=%d",bob->width_fill);
4554.   #endif
4556.   //创建表面
4557.   for (index=0;index<bob->num_frames;index++)
4558.   {
4559.     DDRAW_INIT_STRUCT(ddsd);
4560.     ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
4562.     ddsd.dwWidth = bob->width + bob->width_fill;
4563.     ddsd.dwHeight= bob->height;
4565.     ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | mem_flags;
4567.     if (FAILED(lpdd->CreateSurface(&ddsd,&(bob->images[index]),NULL)))
4568.       return(0);
4570.     DDCOLORKEY color_key;
4571.     color_key.dwColorSpaceLowValue  = color_key_value;
4572.     color_key.dwColorSpaceHighValue = color_key_value;
4574.     (bob->images[index])->SetColorKey(DDCKEY_SRCBLT,&color_key);
4576.   } // end for index
4578.   return(1);
4580. }
4583. int Clone_BOB(BOB_PTR source, BOB_PTR dest)
4584. {
4585.   //克隆BOB对象,所克隆的对象和源对象数据一样,指针指向同一块内存区
4586.   //克隆的对象有一个BOB_ATTR_CLONE标记
4588.   if ((source && dest) && (source!=dest))
4589.   {
4590.     memcpy(dest,source,sizeof(BOB));
4591.     dest->attr |= BOB_ATTR_CLONE;
4592.   }
4593.   else
4594.     return(0);
4596.   return(1);
4598. }
4601. int Destroy_BOB(BOB_PTR bob)
4602. {
4603.   //销毁BOB对象,对克隆的对象,将指针赋NULL.对源对象,需释放内存.
4605.   int index;
4607.   if (!bob)
4608.     return(0);
4610.   if (bob->attr & BOB_ATTR_CLONE)
4611.   {
4612.     for (index=0;index<MAX_BOB_FRAMES;index++)
4613.       if (bob->images[index])
4614.         bob->images[index]=NULL;
4616.     for (index=0;index<MAX_BOB_ANIMATIONS;index++)
4617.       if (bob->animations[index])
4618.         bob->animations[index]=NULL;
4619.   }
4620.   else
4621.   {
4623.     for (index=0;index<MAX_BOB_FRAMES;index++)
4624.       if (bob->images[index])
4625.         (bob->images[index])->Release();
4627.     for (index=0;index<MAX_BOB_ANIMATIONS;index++)
4628.       if (bob->animations[index])
4629.         free(bob->animations[index]);
4630.       
4631.   }
4633.   return(1);
4635. } 
4638. int Draw_BOB(BOB_PTR bob, LPDIRECTDRAWSURFACE7 dest)
4639. {
4641.   RECT dest_rect,
4642.        source_rect;
4644.   if (!bob)
4645.     return(0);
4647.   if (!(bob->attr & BOB_ATTR_VISIBLE))
4648.     return(1);
4650.   dest_rect.left  = bob->x;
4651.   dest_rect.top   = bob->y;
4652.   dest_rect.right = bob->x+bob->width;
4653.   dest_rect.bottom= bob->y+bob->height;
4655.   source_rect.left    = 0;
4656.   source_rect.top     = 0;
4657.   source_rect.right   = bob->width;
4658.   source_rect.bottom  = bob->height;
4660.   //绘制过程
4661.   if (FAILED(dest->Blt(&dest_rect,bob->images[bob->curr_frame],
4662.               &source_rect,(DDBLT_WAIT | DDBLT_KEYSRC),
4663.               NULL)))
4664.       return(0);
4665.   
4666.   return(1);
4668. }
4671. int Draw_BOB16(BOB_PTR bob, LPDIRECTDRAWSURFACE7 dest)
4672. {
4674.   RECT dest_rect,
4675.        source_rect;
4677.   if (!bob)
4678.     return(0);
4680.   if (!(bob->attr & BOB_ATTR_VISIBLE))
4681.     return(1);
4683.   dest_rect.left  = bob->x;
4684.   dest_rect.top   = bob->y;
4685.   dest_rect.right = bob->x+bob->width;
4686.   dest_rect.bottom= bob->y+bob->height;
4688.   source_rect.left    = 0;
4689.   source_rect.top     = 0;
4690.   source_rect.right   = bob->width;
4691.   source_rect.bottom  = bob->height;
4693.   //绘制过程
4694.   if (FAILED(dest->Blt(&dest_rect,bob->images[bob->curr_frame],
4695.               &source_rect,(DDBLT_WAIT | DDBLT_KEYSRC),
4696.               NULL)))
4697.       return(0);
4698.   
4699.   return(1);
4701. }
4703. int Draw_Scaled_BOB(BOB_PTR bob, int swidth, int sheight,
4704.                     LPDIRECTDRAWSURFACE7 dest)
4705. {
4706.   //绘制经缩放的BOB对象
4708.   RECT dest_rect,
4709.        source_rect;
4711.   if (!bob)
4712.     return(0);
4714.   if (!(bob->attr & BOB_ATTR_VISIBLE))
4715.     return(1);
4717.   dest_rect.left  = bob->x;
4718.   dest_rect.top   = bob->y;
4719.   dest_rect.right = bob->x+swidth;
4720.   dest_rect.bottom= bob->y+sheight;
4722.   source_rect.left    = 0;
4723.   source_rect.top     = 0;
4724.   source_rect.right   = bob->width;
4725.   source_rect.bottom  = bob->height;
4727.   //绘制过程
4728.   if (FAILED(dest->Blt(&dest_rect,bob->images[bob->curr_frame],
4729.               &source_rect,(DDBLT_WAIT | DDBLT_KEYSRC),
4730.               NULL)))
4731.       return(0);
4732.   
4733.   return(1);
4735. }
4738. int Draw_Scaled_BOB16(BOB_PTR bob, int swidth, int sheight,
4739.                       LPDIRECTDRAWSURFACE7 dest)
4740. {
4741.   //绘制经缩放的BOB对象
4743.   RECT dest_rect,
4744.        source_rect;
4746.   if (!bob)
4747.     return(0);
4749.   if (!(bob->attr & BOB_ATTR_VISIBLE))
4750.     return(1);
4752.   dest_rect.left  = bob->x;
4753.   dest_rect.top   = bob->y;
4754.   dest_rect.right = bob->x+swidth;
4755.   dest_rect.bottom= bob->y+sheight;
4757.   source_rect.left    = 0;
4758.   source_rect.top     = 0;
4759.   source_rect.right   = bob->width;
4760.   source_rect.bottom  = bob->height;
4762.   //绘制过程
4763.   if (FAILED(dest->Blt(&dest_rect,bob->images[bob->curr_frame],
4764.               &source_rect,(DDBLT_WAIT | DDBLT_KEYSRC),
4765.               NULL)))
4766.       return(0);
4767.   
4768.   return(1);
4770. }
4773. int Load_Frame_BOB(BOB_PTR bob, 
4774.                    BITMAP_FILE_PTR bitmap, 
4775.                    int frame,
4776.                    int cx,int cy,
4777.                    int mode)
4778. {
4779.   //此函数将位图数据加载到BOB对象中的一帧(8位)
4780.   
4781.   DDSURFACEDESC2 ddsd;
4783.   if (!bob)
4784.     return(0);
4785.   
4786.   UCHAR *source_ptr,
4787.         *dest_ptr;
4789.   //计算须加载位图的绝对坐标
4790.   if (mode==BITMAP_EXTRACT_MODE_CELL)
4791.   {
4792.     cx = cx*(bob->width+1) + 1;
4793.     cy = cy*(bob->height+1) + 1;
4794.   }
4796.   //定位加载地址
4797.   source_ptr = bitmap->buffer + cy*bitmap->bitmapinfoheader.biWidth+cx;
4799.   ddsd.dwSize = sizeof(ddsd);
4801.   (bob->images[frame])->Lock(NULL,
4802.                              &ddsd,
4803.                              DDLOCK_WAIT | DDLOCK_SURFACEMEMORYPTR,
4804.                              NULL);
4806.   dest_ptr = (UCHAR*)ddsd.lpSurface;
4808.   //完成位图copy
4809.   for (int index_y=0;index_y<bob->height;index_y++)
4810.   {
4811.     memcpy(dest_ptr,source_ptr,bob->width);
4813.     dest_ptr += ddsd.lPitch;  // (bob->width+bob->width_fill);
4814.     source_ptr += bitmap->bitmapinfoheader.biWidth;
4816.   }
4818.   (bob->images[frame])->Unlock(NULL);
4820.   bob->attr |= BOB_ATTR_LOADED;
4822.   return(1);
4824. }
4827. int Load_Frame_BOB16(BOB_PTR bob, 
4828.                     BITMAP_FILE_PTR bitmap, 
4829.                     int frame,
4830.                     int cx,int cy,
4831.                     int mode)
4832. {
4833.   //此函数将位图数据加载到BOB对象中的一帧(16位)
4834.   
4835.   DDSURFACEDESC2 ddsd;
4837.   if (!bob)
4838.     return(0);
4839.   
4840.   USHORT *source_ptr,
4841.          *dest_ptr;
4843.   //计算须加载位图的绝对坐标
4844.   if (mode==BITMAP_EXTRACT_MODE_CELL)
4845.   {
4846.     cx = cx*(bob->width+1) + 1;
4847.     cy = cy*(bob->height+1) + 1;
4848.   }
4850.   //定位加载地址
4851.   source_ptr =(USHORT*)bitmap->buffer + cy*bitmap->bitmapinfoheader.biWidth+cx;
4853.   ddsd.dwSize = sizeof(ddsd);
4855.   (bob->images[frame])->Lock(NULL,
4856.                              &ddsd,
4857.                              DDLOCK_WAIT | DDLOCK_SURFACEMEMORYPTR,
4858.                              NULL);
4860.   dest_ptr = (USHORT*)ddsd.lpSurface;
4862.   // 完成位图copy
4863.   for (int index_y=0;index_y<bob->height;index_y++)
4864.   {
4865.     memcpy(dest_ptr,source_ptr,(bob->width*2));
4867.     dest_ptr += (ddsd.lPitch>>1);  // (bob->width+bob->width_fill);
4868.     source_ptr += bitmap->bitmapinfoheader.biWidth;
4870.   }
4872.   (bob->images[frame])->Unlock(NULL);
4874.   bob->attr |= BOB_ATTR_LOADED;
4876.   return(1);
4878. }
4881. int Animate_BOB(BOB_PTR bob)
4882. {
4884.   if (!bob)
4885.     return(0);
4887.   //BOB对象只有一帧
4888.   if(bob->attr & BOB_ATTR_SINGLE_FRAME)
4889.   {
4890.     bob->curr_frame = 0;
4891.     return(1);
4892.   }
4894.   //使用多个帧创建BOB,但BOB以线性次序0..n执行动画
4895.   else
4896.   if (bob->attr & BOB_ATTR_MULTI_FRAME)
4897.   {
4898.     if (++bob->anim_counter>=bob->anim_count_max)
4899.     {
4900.       bob->anim_counter = 0;
4902.       if (++bob->curr_frame>=bob->num_frames)
4903.         bob->curr_frame = 0;
4904.     }
4905.   }
4907.   //创建一个多帧的,支持动画序列的BOB
4908.   else
4909.   if (bob->attr & BOB_ATTR_MULTI_ANIM)
4910.   {
4911.     if (++bob->anim_counter>=bob->anim_count_max)
4912.     {
4913.       bob->anim_counter = 0;
4914.       bob->anim_index++;
4916.       //提取动画序列的下一帧
4917.       bob->curr_frame = bob->animations[bob->curr_animation][bob->anim_index];
4919.       //到了动画序列的末尾
4920.       if (bob->curr_frame == -1)
4921.       {
4922.         //动画只播放一次
4923.         if(bob->attr & BOB_ATTR_ANIM_ONE_SHOT)
4924.         {
4925.           bob->anim_state = BOB_STATE_ANIM_DONE;
4927.           //使动画停留在最后一帧
4928.           bob->anim_index--;
4929.           bob->curr_frame = bob->animations[bob->curr_animation][bob->anim_index];
4931.         }
4932.         //动画重复播放
4933.         else
4934.         {
4935.           //从第1帧重新开始
4936.           bob->anim_index = 0;
4937.           bob->curr_frame = bob->animations[bob->curr_animation][bob->anim_index];
4938.         }
4939.       }
4940.     }
4941.   }
4942.   
4943.   return(1);
4945. }
4949. int Move_BOB(BOB_PTR bob)
4950. {
4951.   //移动BOB(考虑到边界情况)
4953.   if (!bob)
4954.     return(0);
4956.   bob->x+=bob->xv;
4957.   bob->y+=bob->yv;
4959.   //BOB对象在移出屏幕时卷到屏幕的另一边
4960.   if (bob->attr & BOB_ATTR_WRAPAROUND)
4961.   {
4962.     if (bob->x>max_clip_x)
4963.       bob->x = min_clip_x - bob->width;
4964.     else
4965.     if (bob->x < min_clip_x-bob->width)
4966.       bob->x = max_clip_x;
4968.     if (bob->y > max_clip_y)
4969.       bob->y = min_clip_y - bob->height;
4970.     else
4971.     if (bob->y < min_clip_y-bob->height)
4972.       bob->y = max_clip_y;
4974.   }
4976.   //BOB对象当碰到屏幕边界时像一个球一样反弹
4977.   else
4978.   if (bob->attr & BOB_ATTR_BOUNCE)
4979.   {
4980.     //仅仅是改变速度
4982.     if ((bob->x > max_clip_x - bob->width) || (bob->x < min_clip_x) )
4983.       bob->xv = -bob->xv;
4984.     
4985.     if ((bob->y > max_clip_y - bob->height) || (bob->y < min_clip_y) )
4986.       bob->yv = -bob->yv;
4987.   }
4989.   return(1);
4991. }
4995. int Load_Animation_BOB(BOB_PTR bob, 
4996.                        int anim_index,  //动画序列号
4997.                        int num_frames,  //动画帧数
4998.                        int *sequence)   //被加载的序列数组
4999. {
5000.   //此函数加载动画序列到BOB对象,加载的序列以-1结尾作为结束标记
5002.   if (!bob)
5003.     return(0);
5005.   if (!(bob->animations[anim_index] = (int*)malloc((num_frames+1)*sizeof(int))))
5006.     return(0);
5008.   for (int index=0;index<num_frames;index++)
5009.     bob->animations[anim_index][index] = sequence[index];
5011.   bob->animations[anim_index][index] = -1;
5013.   return(1);
5015. }
5019. int Set_Pos_BOB(BOB_PTR bob, int x, int y)
5020. {
5021.   //设置BOB对象的位置
5022.   if (!bob)
5023.     return(0);
5025.   bob->x = x;
5026.   bob->y = y;
5028.   return(1);
5030. }
5033. int Set_Anim_Speed_BOB(BOB_PTR bob,int speed)
5034. {
5035.   //设置动画播放速度
5036.   if (!bob)
5037.     return(0);
5039.   bob->anim_count_max = speed;
5041.   return(1);
5042. }
5045. int Set_Animation_BOB(BOB_PTR bob, int anim_index)
5046. {
5047.   //此函数设置须播放的动画类别
5049.   if(!bob)
5050.     return(0);
5051.   
5052.   bob->curr_animation = anim_index;
5054.   bob->anim_index =0;
5056.   return(1);
5058. }
5061. int Set_Vel_BOB(BOB_PTR bob,int xv, int yv)
5062. {
5063.   //设置BOB速度
5065.   if(!bob)
5066.     return(0);
5068.   bob->xv = xv;
5069.   bob->yv = yv;
5071.   return(1);
5073. }
5076. int Hide_BOB(BOB_PTR bob)
5077. {
5078.   //设置BOB不可见
5080.   if(!bob)
5081.     return(0);
5083.   RESET_BIT(bob->attr,BOB_ATTR_VISIBLE);
5085.   return(1);
5086. }
5089. int Show_BOB(BOB_PTR bob)
5090. {
5091.   //设置BOB可见
5093.   if(!bob)
5094.     return(0);
5096.   SET_BIT(bob->attr,BOB_ATTR_VISIBLE);
5098.   return(1);
5100. }
5103. int Collision_BOBS(BOB_PTR bob1, BOB_PTR bob2)
5104. {
5105.   //BOB对象碰撞检测
5107.   if (!bob1 || !bob2)
5108.     return(0);
5110.   int width1  = (bob1->width>>1) - (bob1->width>>3);
5111.   int height1 = (bob1->height>>1) - (bob1->height>>3);
5113.   int width2  = (bob2->width>>1) - (bob2->width>>3);
5114.   int height2 = (bob2->height>>1) - (bob2->height>>3);
5116.   //计算BOB中心坐标
5117.   int cx1 = bob1->x + width1;
5118.   int cy1 = bob1->y + height1;
5120.   int cx2 = bob2->x + width2;
5121.   int cy2 = bob2->y + height2;
5123.   int dx = abs(cx2 - cx1);
5124.   int dy = abs(cy2 - cy1);
5126.   //碰撞则返回1
5127.   if (dx < (width1+width2) && dy < (height1+height2))
5128.     return(1);
5129.   else
5130.     return(0);
5131. }