开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 查看源码
My_DirectDraw.cpp
资源名称：斗地主_src.rar　[点击查看]
上传用户：may_xy
上传日期：2007-08-09
资源大小：1519k
文件大小：14k
源码类别：

游戏

开发平台：

C/C++

My_DirectDraw.cpp：源码内容
  2. #include "stdafx.h"
  3. #include "MainFrm.h"
  5. #include "Game.h"
  6. #include "My_DirectInput.h"
  7. #include "my_directdraw.h"
  9. #include "Draw_Cards_Engine.h"
  11. #include "Playing_Cards.h"
  14. #include <io.h>
  16. CMyDirectDraw::CMyDirectDraw()
  17. {
  18. lpdd         = NULL;   // dd object
  19. lpddclipper  = NULL;   // dd clipper
  21. bitmap.buffer = NULL; //记住!!!!!!初始化!!!!!永远的伤
  22. start_clock_count = 0; // used for timing
  24. SCREEN_BPP = 32;
  26. }
  29. int CMyDirectDraw::Flip_Bitmap(UCHAR *image, int bytes_per_line, int height)
  30. {
  31. // 将数据读入表面
  33. UCHAR *buffer; // used to perform the image processing
  34. int index;  
  36. if (!(buffer = (UCHAR *)new UCHAR[bytes_per_line*height]) )
  37. return(0);
  39. memcpy(buffer,image,bytes_per_line*height);
  41. for (index=0; index < height; index++)
  42. {
  43.     memcpy(&image[((height-1) - index)*bytes_per_line],
  44.    &buffer[index*bytes_per_line], bytes_per_line);
  45. }
  47. // release the memory
  48. delete(buffer);
  50. return(1);
  52. } // end Flip_Bitmap
  54. //读取位图的方法:
  56. int CMyDirectDraw::Load_Bitmap_File(BITMAP_FILE_PTR bitmap, char *filename)
  57. {
  58. //
  59. int file_handle;  // the file handle
  60.        
  61. UCHAR   *temp_buffer = NULL; 
  62. OFSTRUCT file_data;     
  64. // 打开文件如果它存在;
  65. if ((file_handle = OpenFile(filename,&file_data,OF_READ))==-1)
  66.    return(0);
  69. _lread(file_handle, &bitmap->bitmapfileheader,sizeof(BITMAPFILEHEADER));
  72. if (bitmap->bitmapfileheader.bfType!=BITMAP_ID)
  73. {
  74. //如果不是位图,则关闭文件,返回;
  75.   _lclose(file_handle);
  76.   return(0);
  77.     } // end if
  79. // 发现是位图,继续;
  81. // 读取文件头;
  82. _lread(file_handle, &bitmap->bitmapinfoheader,sizeof(BITMAPINFOHEADER));
  84. //如果是8位位图,则返回;
  85. if (bitmap->bitmapinfoheader.biBitCount == 8)
  86. {
  87. AfxMessageBox("本游戏不能读取8位位图!");
  88. return 0;
  89. } // end if
  91. //从文件结尾反向搜位图数据字节大小的长度;
  92. _lseek(file_handle,(int)(sizeof(BITMAPFILEHEADER)+
  93.    sizeof(BITMAPINFOHEADER)),SEEK_SET);
  95. int Image_Size = bitmap->bitmapfileheader.bfSize-
  96. (sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER));
  98. if (bitmap->bitmapinfoheader.biBitCount==8 || bitmap->bitmapinfoheader.biBitCount==16 || 
  99.     bitmap->bitmapinfoheader.biBitCount==24)
  100.     {
  101. //如果位图存在,则先释放;
  102.    if (bitmap->buffer)
  103.        free(bitmap->buffer);
  106.    if ( !(bitmap->buffer = (UCHAR *)new UCHAR [Image_Size]) )
  107.       {
  108.  
  109. _lclose(file_handle);
  110. return(0);
  111.       } 
  112.    _lread(file_handle,bitmap->buffer,Image_Size);
  114. } 
  115. else
  116. {
  117.    //见鬼了!
  118.    return(0);
  119.     } 
  121. _lclose(file_handle);
  123. // flip the bitmap
  124. Flip_Bitmap(bitmap->buffer, 
  125.             bitmap->bitmapinfoheader.biWidth*(bitmap->bitmapinfoheader.biBitCount/8), 
  126.             bitmap->bitmapinfoheader.biHeight);
  128. return(1);
  130. } 
  132. int CMyDirectDraw::Unload_Bitmap_File(BITMAP_FILE_PTR bitmap)
  133. {
  134. // this function releases all memory associated with "bitmap"
  135. if (bitmap->buffer)
  136. {
  137.    // release memory
  138.    delete(bitmap->buffer);
  140.    bitmap->buffer = NULL;
  141.     } 
  142. return(1);
  144. } 
  146. int CMyDirectDraw::Scan_Image_Bitmap(BITMAP_FILE_PTR bitmap,     // bitmap file to scan image data from
  147.                       LPDIRECTDRAWSURFACE7 lpdds, // surface to hold data
  148.                       int cx, int cy)             // cell to scan image from
  149. {
  150. //将位图像素写到表面去!
  151. DDSURFACEDESC2 ddsd;  //  direct draw surface description 
  152.  
  153. // set size of the structure
  154. ddsd.dwSize = sizeof(ddsd);
  156. // lock the display surface
  157. lpdds->Lock(NULL,
  158.             &ddsd,
  159.             DDLOCK_WAIT | DDLOCK_SURFACEMEMORYPTR,
  160.             NULL);
  162. cx = cx*(ddsd.dwWidth+1) + 1;
  163. cy = cy*(ddsd.dwHeight+1) + 1;
  165. DWORD *dest_ptr;
  166. UCHAR blue,green,red;
  167. dest_ptr = (DWORD *)ddsd.lpSurface;
  169. for (DWORD index_y = 0; index_y < ddsd.dwHeight; index_y++)
  170. {
  171. for (DWORD index_x = 0; index_x < ddsd.dwWidth; index_x++)
  172. {
  173.         // get BGR values;;;;
  174. int index = index_y*(bitmap->bitmapinfoheader.biWidth)*3 + index_x*3;
  176. blue  = bitmap->buffer[index + 0];
  177. green = bitmap->buffer[index + 1];
  178. red   = bitmap->buffer[index + 2];
  180.         // 32位RGB数;
  181. DWORD pixel = _RGB32BIT(0,red,green,blue);
  183. dest_ptr[index_x + (index_y*ddsd.lPitch >> 2)] = pixel;
  184. } 
  186. } 
  188. // unlock the surface 
  189. lpdds->Unlock(NULL);
  191. return(1);
  192. }
  194. //填充表面的方法
  195. int CMyDirectDraw::FillSurface(LPDIRECTDRAWSURFACE7 lpdds,int color)
  196. {
  197. DDBLTFX ddbltfx;
  199. //初始化ddbltfx结构;
  200. DDRAW_INIT_STRUCT(ddbltfx);
  202. // 需要填空全屏的颜色值;
  203. ddbltfx.dwFillColor = color; 
  205. // blt to surface
  206. lpdds->Blt(
  207.    NULL,       // ptr to dest rectangle
  208.            NULL,       // ptr to source surface, NA            
  209.            NULL,       // ptr to source rectangle, NA
  210.            DDBLT_COLORFILL | DDBLT_WAIT,   // fill and wait                   
  211.        &ddbltfx
  212.    );  // ptr to DDBLTFX structure
  215. return(1);
  216. } // end FillSurface
  218. //根据传入参数建立相应的表面
  219. LPDIRECTDRAWSURFACE7 CMyDirectDraw::CreateSurface(
  220.   int width,
  221.   int height,
  222.   int mem_flags,
  223.   int color = 0)
  224. {
  225. // this function creates an offscreen plain surface
  227. DDSURFACEDESC2 ddsd;         // working description
  228. LPDIRECTDRAWSURFACE7 lpdds;  // temporary surface
  229.     
  230. // set to access caps, width, and height
  231. memset(&ddsd,0,sizeof(ddsd));
  232. ddsd.dwSize  = sizeof(ddsd);
  233. ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
  235. // set dimensions of the new bitmap surface
  236. ddsd.dwWidth  =  width;
  237. ddsd.dwHeight =  height;
  239. // set surface to offscreen plain
  240. ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | mem_flags;
  242. // create the surface
  243. if (FAILED(lpdd->CreateSurface(&ddsd,&lpdds,NULL)))
  244.    return(NULL);
  246. // test if user wants a color key
  247. if (color >= 0)
  248.     {
  249.    // set color key to color 0
  250.    DDCOLORKEY color_key; // used to set color key
  251.    color_key.dwColorSpaceLowValue  = color;
  252.    color_key.dwColorSpaceHighValue = color;
  254.    // now set the color key for source blitting
  255.    lpdds->SetColorKey(DDCKEY_SRCBLT, &color_key);
  256. }  // end if
  258. // return surface
  259. return(lpdds);
  260. } // end CreateSurface
  262. int CMyDirectDraw::DrawSurface(
  263.   LPDIRECTDRAWSURFACE7 source, // source surface to draw
  264.                       int x, int y,                 // position to draw at
  265.                       int width, int height,        // size of source surface
  266.                       LPDIRECTDRAWSURFACE7 dest,    // surface to draw the surface on
  267.                       int transparent = 1)          // transparency flag
  268. {
  269. // draw a bob at the x,y defined in the BOB
  270. // on the destination surface defined in dest
  272. RECT dest_rect,   // the destination rectangle
  273.  source_rect; // the source rectangle                             
  275. // fill in the destination rect
  276. dest_rect.left   = x;
  277. dest_rect.top    = y;
  278. dest_rect.right  = x+width;
  279. dest_rect.bottom = y+height;
  281. // fill in the source rect
  282. source_rect.left    = 0;
  283. source_rect.top     = 0;
  284. source_rect.right   = width;
  285. source_rect.bottom  = height;
  287. // test transparency flag
  289. if (transparent)
  290.     {
  291.    // enable color key blit
  292.    // blt to destination surface
  293.    if (FAILED(dest->Blt(&dest_rect, source,
  294.                      &source_rect,(DDBLT_WAIT | DDBLT_KEYSRC),
  295.                      NULL)))
  296.             return(0);
  298. } // end if
  299. else
  300.     {
  301.    // perform blit without color key
  302.    // blt to destination surface
  303. if (FAILED(dest->Blt(&dest_rect, source,
  304.                      &source_rect,(DDBLT_WAIT),
  305.                      NULL)))
  306.            return(0);
  308. } // end if
  310. // return success
  311. return(1);
  313. } // end DrawSurface
  314. //创建剪切的方法:
  315. LPDIRECTDRAWCLIPPER CMyDirectDraw::AttachClipper(
  316.  LPDIRECTDRAWSURFACE7 lpdds,
  317.                                          int num_rects,
  318.                                          LPRECT clip_list)
  320. {
  321. // this function creates a clipper from the sent clip list and attaches
  322. // it to the sent surface
  324. int index;                         // looping var
  325. LPDIRECTDRAWCLIPPER lpddclipper;   // pointer to the newly created dd clipper
  326. LPRGNDATA region_data;             // pointer to the region data that contains
  327.                                    // the header and clip list
  329. // first create the direct draw clipper
  330. if (FAILED(lpdd->CreateClipper(0,&lpddclipper,NULL)))
  331.    return(NULL);
  333. // now create the clip list from the sent data
  335. // first allocate memory for region data
  336. region_data = (LPRGNDATA)malloc(sizeof(RGNDATAHEADER)+num_rects*sizeof(RECT));
  338. // now copy the rects into region data
  339. memcpy(region_data->Buffer, clip_list, sizeof(RECT)*num_rects);
  341. // set up fields of header
  342. region_data->rdh.dwSize          = sizeof(RGNDATAHEADER);
  343. region_data->rdh.iType           = RDH_RECTANGLES;
  344. region_data->rdh.nCount          = num_rects;
  345. region_data->rdh.nRgnSize        = num_rects*sizeof(RECT);
  347. region_data->rdh.rcBound.left    =  64000;
  348. region_data->rdh.rcBound.top     =  64000;
  349. region_data->rdh.rcBound.right   = -64000;
  350. region_data->rdh.rcBound.bottom  = -64000;
  352. // find bounds of all clipping regions
  353. for (index=0; index<num_rects; index++)
  354.     {
  355.     // test if the next rectangle unioned with the current bound is larger
  356.     if (clip_list[index].left < region_data->rdh.rcBound.left)
  357.         region_data->rdh.rcBound.left = clip_list[index].left;
  359.     if (clip_list[index].right > region_data->rdh.rcBound.right)
  360.         region_data->rdh.rcBound.right = clip_list[index].right;
  362.     if (clip_list[index].top < region_data->rdh.rcBound.top)
  363.         region_data->rdh.rcBound.top = clip_list[index].top;
  365.     if (clip_list[index].bottom > region_data->rdh.rcBound.bottom)
  366.         region_data->rdh.rcBound.bottom = clip_list[index].bottom;
  368.     } // end for index
  370. // now we have computed the bounding rectangle region and set up the data
  371. // now let's set the clipping list
  373. if (FAILED(lpddclipper->SetClipList(region_data, 0)))
  374.     {
  375.    // release memory and return error
  376. free(region_data);
  377. return(NULL);
  378. } // end if
  380. // now attach the clipper to the surface
  381. if (FAILED(lpdds->SetClipper(lpddclipper)))
  382.     {
  383.    // release memory and return error
  384.    free(region_data);
  385.    return(NULL);
  386. } // end if
  388. // all is well, so release memory and send back the pointer to the new clipper
  389. free(region_data);
  390. return(lpddclipper);
  392. } 
  393. //调试用;
  394. int CMyDirectDraw::DebugText(char* text,int time)
  395. {
  396. HDC xdc; // the working dc
  399. if (FAILED(lpddsprimary->GetDC(&xdc)))
  400.    return(0);
  402. SetBkMode(xdc, TRANSPARENT);
  404. TextOut(xdc,140,500,text,strlen(text));
  406. lpddsprimary->ReleaseDC(xdc);
  408. ::Sleep(time);
  410. return 1;
  411. }
  413. int CMyDirectDraw::TextGDI(
  414. char *text,
  415. int x,
  416. int y,
  417. COLORREF color,
  418. int size,
  419. char* type,
  420. LPDIRECTDRAWSURFACE7 lpdds)
  421. {
  422. HDC xdc; 
  423. if (FAILED(lpdds->GetDC(&xdc)))
  424.    return(0);
  426. LOGFONT my_font;
  427. memset(&my_font,0,sizeof(LOGFONT));
  429. my_font.lfCharSet = DEFAULT_CHARSET;
  430. my_font.lfHeight = size;
  431. // lstrcpyn(my_font.lfFaceName, type, _countof(my_font.lfFaceName));
  432. sprintf(my_font.lfFaceName,type);
  434. POINT pt;
  435. pt.y = ::GetDeviceCaps(xdc, LOGPIXELSY) * my_font.lfHeight;
  436. pt.y /= 720;    // 72 points/inch, 10 decipoints/point
  437. ::DPtoLP(xdc, &pt, 1);
  438. POINT ptOrg = { 0, 0 };
  439. ::DPtoLP(xdc, &ptOrg, 1);
  440. my_font.lfHeight = -abs(pt.y - ptOrg.y);
  443. HFONT hFont;
  444. hFont = ::CreateFontIndirect(&my_font);
  446. // dc.m_hDC  = xdc;
  447. //新字体对象及指针;
  448. // CFont my_font;
  449. //把新建字体选进描述中;
  450. // my_font.CreatePointFont(size,type,NULL);//创建自己的字体;
  451. // old_font = dc.SelectObject(&my_font);  //选择新的字体;
  454. SelectObject(xdc,hFont);
  455. SetTextColor(xdc,color);
  456. SetBkMode(xdc,TRANSPARENT);
  457. TextOut(xdc,x,y,text,strlen(text));
  459. //恢复原设备描述符表的字体;
  460. DeleteObject(hFont);
  461. lpdds->ReleaseDC(xdc);
  463. return 1;
  464. }
  465. //初始化DD平台;
  466. int CMyDirectDraw::Init()
  467. {
  468. // pCMainFrame = *)AfxGetMainWnd();
  470. if (FAILED(DirectDrawCreateEx(NULL, (void **)&lpdd, IID_IDirectDraw7, NULL)))
  471. {
  472.    return(0);
  473. }
  474. // set cooperation to full screen
  475. if(FAILED(lpdd->SetCooperativeLevel(::pCMainFrame->m_hWnd, 
  476.  DDSCL_ALLOWMODEX | DDSCL_FULLSCREEN |
  477.                                      DDSCL_EXCLUSIVE | DDSCL_ALLOWREBOOT)) )  // 
  478. {
  479.    return(0);
  480. }
  482. if (FAILED(lpdd->SetDisplayMode(Screen_Width, Screen_Height, SCREEN_BPP,0,0)))
  483. {
  484.    return(0);
  485. }
  487. DDRAW_INIT_STRUCT(ddsd);  //清零的宏;
  489. // enable valid fields
  490. ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
  492. // set the backbuffer count field to 1, use 2 for triple buffering
  493. ddsd.dwBackBufferCount = 1;
  495. // request a complex, flippable
  496. ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_COMPLEX | DDSCAPS_FLIP;
  498. // 创建主表面;
  499. if (FAILED(lpdd->CreateSurface(&ddsd, &lpddsprimary, NULL)))
  500. return(0);
  502. ddsd.ddsCaps.dwCaps = DDSCAPS_BACKBUFFER;
  504. if (FAILED(lpddsprimary->GetAttachedSurface(&ddsd.ddsCaps, &lpddsback)))
  505.   return(0);
  507. //设置后备缓冲区的剪裁区;
  508. RECT screen_rect= {0,0,Screen_Width,Screen_Height};
  509. lpddclipper = AttachClipper(lpddsback,1,&screen_rect);
  512. return 1;
  513. } 
  515. int CMyDirectDraw::BitmapToSurface(
  516. LPDIRECTDRAWSURFACE7 Dest_Surface,  //目的表面;
  517. int Dest_x, //目的表面x座标;
  518. int Dest_y, //目的表面y座标;
  519. char* filename, //源位图文件名;
  520. int Bitmap_Width, //位图宽;
  521. int Bitmap_Height //位图长;
  522. )
  523. {
  524. HBITMAP hbitmap;
  525. HDC hdc;   //接受当前设备环境句柄;
  526. HDC dhdc;
  527. CString str;
  529. hdc = ::CreateCompatibleDC(NULL);
  531. hbitmap = (HBITMAP)::LoadImage(NULL,filename,IMAGE_BITMAP,Bitmap_Width,Bitmap_Height,LR_LOADFROMFILE); 
  533. if(hbitmap==NULL)
  534. {
  535. str.Format("无法载入位图%s",filename);
  536. AfxMessageBox(str);
  537. return 0;
  538. }
  540. ::SelectObject(hdc,hbitmap);
  542. Dest_Surface->GetDC( &dhdc );
  543. ::BitBlt( dhdc , Dest_x , Dest_y ,Bitmap_Width,Bitmap_Height, hdc , 0 , 0 , SRCCOPY );
  544. Dest_Surface->ReleaseDC(dhdc);
  546. return 1;
  547. }
  549. CMyDirectDraw::~CMyDirectDraw()
  550. {
  551. // now the primary surface
  552. // if (lpddsprimary)
  553.  //   {
  554. // lpddsprimary->Release();
  555. // lpddsprimary = NULL;
  556. // } // end if
  557. //后备缓冲
  558. // if(lpddsback)
  559. // {
  560. // lpddsback->Release();
  561. // lpddsback = NULL;
  562. // }
  563. //离屏表面;
  564. // if(lpddsbackground)
  565. // {
  566. // lpddsbackground->Release();
  567. // lpddsbackground = NULL;
  568. // }
  569. // now blow away the IDirectDraw4 interface
  570. if (lpdd)
  571.     {
  572. lpdd->Release();
  573. lpdd = NULL;
  574.     } // end if
  575. }