现在的位置: 首页 > 综合 > 正文

填充实心多边形(二)

2013年03月24日 ⁄ 综合 ⁄ 共 16375字 ⁄ 字号 小 中 大 ⁄ 评论关闭

 上一篇文章介绍了填充四边形及三角形，那么对于五边形，六边形呢？当然也可以把五边形分解成3个三角形，六边形分解成4个三角形进行填充。推而广之，可以把n边形分解成n-2个三角形来进行填充。这里介绍另一个方法。如图所示。

这是更为一般化的填充(光栅化?)实心多边形方法。找到多边形各顶点中y轴坐标最小的点作为起始点，按顺时针设置各顶点标号，然后从逆时针方向和顺时针方向同时出发，当一条边到达一个终点(另一个顶点)时，重新计算插值，继续下去直到完成光栅化。代码清单如下：

  1. /* 2008/9/6 
  2. 代码功能：光栅化
  3. 多边形的一般方法*/
  5. #define WIN32_LEAN_AND_MEAN   //不使用MFC
  7. #define INITGUID      //使用GUID
  9. #include <windows.h>
  10. #include <windowsx.h>
  11. #include <mmsystem.h> //多媒体API
  12. #include <iostream.h>
  13. #include <conio.h>    //控制台IO支持
  14. #include <stdlib.h>   //声明定义的一些常用标准函数库
  15. #include <malloc.h>   //声明或定义一些内存的函数
  16. #include <memory.h>   //提供了内存操作相关的一些函数及声明
  17. #include <string.h>   //字符串的一些功能
  18. #include <stdarg.h>   //defines ANSI-style macros for variable argument functions
  19. #include <stdio.h>    //efinitions/declarations for standard I/O routines
  20. #include <math.h>     //一些数学方法
  21. #include <io.h>       //declarations for low-level file handling and I/O functions
  22. #include <fcntl.h>    //file control options used by open()
  24. #include <ddraw.h>
  26. //windows类名
  27. #define  WINDOW_CLASS_NAME "WINCLASS1"
  28. //宽,高,色深(像素)
  29. #define  SCREEN_WIDTH   640
  30. #define  SCREEN_HEIGHT   480
  31. #define  SCREEN_BPP     8
  33. #define  MAX_COLORS_PALETTE   256
  34. #define  PI 3.1415926535
  36. typedef unsigned short USHORT;
  37. typedef unsigned short WORD;
  38. typedef unsigned char UCHAR;
  39. typedef unsigned char BYTE;
  41. typedef struct VERTEX2DF_TYP 
  42. {
  43.   float x,y;
  44. }VERTEX2DF,*VERTEX2DF_PTR;
  46. typedef struct POLYGON2D_TYP 
  47. {
  48.   int state;
  49.   int num_vert;
  50.   int x0,y0;
  51.   int xv,yv;
  52.   DWORD color;
  53.   VERTEX2DF* vlist;
  54. }POLYGON2D,*POLYGON2D_PTR;
  56. //GDI文字函数
  57. int Draw_Text_GDI(char* text,int x,int y,int color,LPDIRECTDRAWSURFACE7 lpdds);
  58. //填充表面
  59. int DDraw_Fill_Surface(LPDIRECTDRAWSURFACE7 lpdds,int color);
  60. //旋转图形
  61. int Rotate_Polygon2D(POLYGON2D_PTR poly,int theta);
  62. //填充2D图形
  63. int Draw_Filled_Polygon2D(POLYGON2D_PTR poly,UCHAR* vbuffer,int mempitch);
  64. //设置调色板入口
  65. int Set_Palette_Entry(int color_index,LPPALETTEENTRY color);
  68. //键盘按键宏
  69. #define  KEYDOWN(vk_code) ((GetAsyncKeyState(vk_code)&0x8000)?1:0)
  70. #define  KEYUP(vk_code)   ((GetAsyncKeyState(vk_code)&0x8000)?0:1)
  71. //初始化结构体
  72. #define  DDRAW_INIT_STRUCT(ddstruct) { memset(&ddstruct,0,sizeof(ddstruct));ddstruct.dwSize=sizeof(ddstruct); }
  74. HWND main_window_handle =NULL;
  75. int  window_closed =0;
  76. HINSTANCE hinstance_app =NULL;
  78. LPDIRECTDRAW7 lpdd =NULL;
  79. LPDIRECTDRAWSURFACE7 lpddsprimary =NULL;  //主缓存
  80. LPDIRECTDRAWSURFACE7 lpddsback =NULL;     //后备缓冲
  81. LPDIRECTDRAWPALETTE  lpddpal =NULL;       //调色板接口
  82. LPDIRECTDRAWCLIPPER  lpddclipper =NULL;   //裁剪器
  83. PALETTEENTRY         palette[256];        //调色板
  84. DDSURFACEDESC2       ddsd;
  85. DDBLTFX              ddbltfx;
  86. DDSCAPS2             ddscaps;
  88. /*裁剪区域*/
  89. int min_clip_x = 0,
  90.     max_clip_x =SCREEN_WIDTH-1, 
  91.     min_clip_y = 0,
  92.     max_clip_y = SCREEN_HEIGHT-1;
  94. char buffer[80];
  96. float cos_look[360],
  97.       sin_look[360];
  99. POLYGON2D object;
  101. int Draw_Text_GDI(char* text,int x,int y,int color,LPDIRECTDRAWSURFACE7 lpdds)
  102. {
  103.   HDC xdc;
  104.   if(FAILED(lpdds->GetDC(&xdc)))
  105.     return(0);
  106.   SetTextColor(xdc,RGB(palette[color].peRed,palette[color].peGreen,palette[color].peBlue));
  107.   SetBkMode(xdc,TRANSPARENT);
  108.   TextOut(xdc,x,y,text,strlen(text));
  109.   lpdds->ReleaseDC(xdc);
  110.   return(1);
  111. }
  113. int DDraw_Fill_Surface(LPDIRECTDRAWSURFACE7 lpdds,int color)
  114. {
  115.   DDRAW_INIT_STRUCT(ddbltfx);
  116.   ddbltfx.dwFillColor=color;
  117.   lpdds->Blt(NULL,
  118.              NULL,
  119.              NULL,
  120.              DDBLT_COLORFILL|DDBLT_WAIT,
  121.              &ddbltfx);
  122.   return(1);
  123. }
  125. int Set_Palette_Entry(int color_index,LPPALETTEENTRY color)
  126. {
  128.   lpddpal->SetEntries(0,color_index,1,color);
  130.   memcpy(&palette[1],color,sizeof(PALETTEENTRY));
  132.   return(1);
  133. }
  135. int Rotate_Polygon2D(POLYGON2D_PTR poly, int theta)
  136. {
  137. // this function rotates the local coordinates of the polygon
  139. // test for valid pointer
  140. if (!poly)
  141.    return(0);
  143. // loop and rotate each point, very crude, no lookup!!!
  144. for (int curr_vert = 0; curr_vert < poly->num_vert; curr_vert++)
  145.     {
  147.     // perform rotation
  148.     float xr = (float)poly->vlist[curr_vert].x*cos_look[theta] - 
  149.                     (float)poly->vlist[curr_vert].y*sin_look[theta];
  151.     float yr = (float)poly->vlist[curr_vert].x*sin_look[theta] + 
  152.                     (float)poly->vlist[curr_vert].y*cos_look[theta];
  154.     // store result back
  155.     poly->vlist[curr_vert].x = xr;
  156.     poly->vlist[curr_vert].y = yr;
  158.     } // end for curr_vert
  160. // return success
  161. return(1);
  163. } // end Rotate_Polygon2D
  165. int Draw_Filled_Polygon2D(POLYGON2D_PTR poly,UCHAR *vbuffer,int mempitch)
  166. {
  167.   int ydiff1,ydiff2,
  168.       xdiff1,xdiff2,
  169.       start,
  170.       length,
  171.       errorterm1,errorterm2,
  172.       offset1,offset2,
  173.       count1,count2,
  174.       xunit1,xunit2;
  176.   int edgecount = poly->num_vert-1;
  177.   int firstvert=0;
  178.   int min_y=poly->vlist[0].y;
  179.   
  180.   for (int index=1;index<poly->num_vert;index++)
  181.   {/*找到y轴坐标最小的顶点*/
  182.     
  183.     if ((poly->vlist[index].y)<min_y)
  184.     {
  185.       firstvert=index;
  186.       min_y=poly->vlist[index].y;
  187.     }
  188.   }
  190.   int startvert1=firstvert;
  191.   int startvert2=firstvert;
  192.   int xstart1=poly->vlist[startvert1].x+poly->x0;  //逆时针移动的初始位置
  193.   int ystart1=poly->vlist[startvert1].y+poly->y0;
  194.   int xstart2=poly->vlist[startvert2].x+poly->x0;  //顺时针移动的初始位置
  195.   int ystart2=poly->vlist[startvert2].y+poly->y0;
  197.   /*取得逆时针移动遇到的第1个顶点坐标*/
  198.   int endvert1=startvert1-1;
  199.   if (endvert1<0)
  200.     endvert1=poly->num_vert-1;
  201.   int xend1=poly->vlist[endvert1].x+poly->x0;
  202.   int yend1=poly->vlist[endvert1].y+poly->y0;
  203.   
  204.   /*取得顺时针移动遇到的第1个顶点坐标*/
  205.   int endvert2=startvert2+1;
  206.   if(endvert2==(poly->num_vert))
  207.     endvert2=0;
  208.   int xend2=poly->vlist[endvert2].x+poly->x0;
  209.   int yend2=poly->vlist[endvert2].y+poly->y0;
  211.   //绘制并填充多边形
  212.   while (edgecount>0)
  213.   {
  214.     offset1=mempitch*ystart1+xstart1; //左边缘偏移量
  215.     offset2=mempitch*ystart2+xstart2; //右边缘偏移量
  216.     
  217.     //初始化误差额
  218.     errorterm1=0;
  219.     errorterm2=0;
  220.     
  221.     //初始化左边与右边x&y方向的偏移差
  222.     if ((ydiff1=yend1-ystart1)<0)
  223.       ydiff1=-ydiff1;
  224.     if ((ydiff2=yend2-ystart2)<0)
  225.       ydiff2=-ydiff2;
  226.     if ((xdiff1=xend1-xstart1)<0)
  227.     {
  228.       xunit1=-1;
  229.       xdiff1=-xdiff1;
  230.     }
  231.     else
  232.     {
  233.       xunit1=1;
  234.     }
  235.     if ((xdiff2=xend2-xstart2)<0)
  236.     {
  237.       xunit2=-1;
  238.       xdiff2=-xdiff2;
  239.     }
  240.     else
  241.     {
  242.       xunit2=1;
  243.     }
  244.     
  245.     //选择使用哪种情况
  246.     if (xdiff1>ydiff1)
  247.     {/*|k1|<1*/
  248.       if (xdiff2>ydiff2)
  249.       {/*|k2|<1*/
  251.         count1=xdiff1;    //左边X的增量
  252.         count2=xdiff2;    //右边X的增量
  254.         while (count1&&count2)
  255.         {
  256.           while ((errorterm1<xdiff1)&&(count1>0))
  257.           {
  258.             if(count1--)
  259.             {
  260.               offset1+=xunit1;
  261.               xstart1+=xunit1;
  262.             }
  263.             errorterm1+=ydiff1;
  264.             if (errorterm1<xdiff1)
  265.             {
  266.               vbuffer[offset1]=(UCHAR)poly->color;
  267.             }
  268.           }
  270.           errorterm1-=xdiff1;
  272.           while ((errorterm2<xdiff2)&&(count2>0))
  273.           {
  274.             if (count2--)
  275.             {
  276.               offset2+=xunit2;
  277.               xstart2+=xunit2;
  278.             }
  279.             errorterm2+=ydiff2;
  281.             if (errorterm2<xdiff2)
  282.             {
  283.               vbuffer[offset2]=(UCHAR)poly->color;
  284.             }
  285.           }
  287.           errorterm2-=xdiff2;
  289.           length=offset2-offset1;
  290.           if (length<0)
  291.           {
  292.             length=-length;
  293.             start=offset2;
  294.           }
  295.           else
  296.             start=offset1;
  298.           for (int index=start;index<start+length+1;index++)
  299.           {
  300.             vbuffer[index]=(UCHAR)poly->color;
  301.           }
  303.           offset1+=mempitch;
  304.           ystart1++;
  305.           offset2+=mempitch;
  306.           ystart2++;
  308.         }
  310.       }
  311.       else
  312.       {/*|k2|>1*/
  314.         count1=xdiff1;
  315.         count2=ydiff2;
  317.         while (count1&&count2)
  318.         {
  319.           while ((errorterm1<xdiff1)&&(count1>0))
  320.           {
  321.             if(count1--)
  322.             {
  323.               offset1+=xunit1;
  324.               xstart1+=xunit1;
  325.             }
  326.             errorterm1+=ydiff1;
  327.             if (errorterm1<xdiff1)
  328.             {
  329.               vbuffer[offset1]=(UCHAR)poly->color;
  330.             }
  331.           }
  333.           errorterm1-=xdiff1;
  334.           
  335.           errorterm2+=xdiff2;
  336.           if (errorterm2>=ydiff2)
  337.           {
  338.             errorterm2-=ydiff2;
  339.             offset2+=xunit2;
  340.             xstart2+=xunit2;
  341.           }
  342.           count2--;
  344.           length=offset2-offset1;
  345.           if (length<0)
  346.           {
  347.             length=-length;
  348.             start=offset2;
  349.           }
  350.           else
  351.             start=offset1;
  352.           
  353.           for (int index=start;index<start+length+1;index++)
  354.           {
  355.             vbuffer[index]=(UCHAR)poly->color;
  356.           }
  358.           offset1+=mempitch;
  359.           ystart1++;
  360.           offset2+=mempitch;
  361.           ystart2++;
  362.         }
  363.       }
  364.     }
  366.     else
  367.     {/*|k1|>1*/
  368.       if (xdiff2>ydiff2)
  369.       {/*|k2|<1*/
  371.         count1=ydiff1;
  372.         count2=xdiff2;
  374.         while (count1&&count2)
  375.         {
  376.           errorterm1+=xdiff1;
  377.           if (errorterm1>=ydiff1)
  378.           {
  379.             errorterm1-=ydiff1;
  380.             offset1+=xunit1;
  381.             xstart1+=xunit1;
  382.           }
  384.           count1--;
  385.           
  386.           while ((errorterm2<xdiff2)&&(count2>0))
  387.           {
  388.             if (count2--)
  389.             {
  390.               offset2+=xunit2;
  391.               xstart2+=xunit2;
  392.             }
  393.             errorterm2+=ydiff2;
  394.             if (errorterm2<xdiff2)
  395.             {
  396.               vbuffer[offset2]=(UCHAR)poly->color;
  397.             }
  398.         
  399.           }
  400.           errorterm2-=xdiff2;
  402.           length=offset2-offset1;
  403.           if (length<0)
  404.           {
  405.             length=-length;
  406.             start=offset2;
  407.           }
  408.           else
  409.             start=offset1;
  411.           for (int index=start;index<start+length+1;index++)
  412.           {
  413.             vbuffer[index]=(UCHAR)poly->color;
  414.           }
  416.           offset1+=mempitch;
  417.           ystart1++;
  418.           offset2+=mempitch;
  419.           ystart2++;
  420.         }
  421.       }
  422.       else
  423.       {/*|k2|>1*/
  424.         
  425.         count1=ydiff1;
  426.         count2=ydiff2;
  427.         while (count1&&count2)
  428.         {
  429.           errorterm1+=xdiff1;
  430.           if (errorterm1>=ydiff1)
  431.           {
  432.             errorterm1-=ydiff1;
  433.             offset1+=xunit1;
  434.             xstart1+=xunit1;
  435.           }
  436.           count1--;
  438.           errorterm2+=xdiff2;
  439.           if (errorterm2>=ydiff2)
  440.           {
  441.             errorterm2-=ydiff2;
  442.             offset2+=xunit2;
  443.             xstart2+=xunit2;
  444.           }
  445.           count2--;
  447.           length=offset2-offset1;
  448.           if (length<0)
  449.           {
  450.             length=-length;
  451.             start=offset2;
  452.           }
  453.           else
  454.             start=offset1;
  456.           for (int index=start;index<start+length+1;index++)
  457.           {
  458.             vbuffer[index]=(UCHAR)poly->color;
  459.           }
  461.           offset1+=mempitch;
  462.           ystart1++;
  463.           offset2+=mempitch;
  464.           ystart2++;
  465.         }
  466.       }
  467.     }
  469.     if (!count1)
  470.     {/*首先到达逆时针顶点*/
  472.       --edgecount;
  473.       startvert1=endvert1;
  474.       --endvert1;
  476.       if (endvert1<0)
  477.         endvert1=poly->num_vert-1;
  479.       xend1=poly->vlist[endvert1].x+poly->x0;
  480.       yend1=poly->vlist[endvert1].y+poly->y0;
  481.     }
  483.     if (!count2)
  484.     {/*首先到达顺时针顶点*/
  486.       --edgecount;
  487.       startvert2=endvert2;
  488.       ++endvert2;
  490.       if(endvert2==(poly->num_vert))
  491.         endvert2=0;
  493.       xend2=poly->vlist[endvert2].x+poly->x0;
  494.       yend2=poly->vlist[endvert2].y+poly->y0;
  496.     }
  497.     
  499.   }
  500.   
  501.   return(1);
  502. }
  505. LRESULT CALLBACK WindowProc(HWND hwnd,
  506.                             UINT msg,
  507.                             WPARAM wparam,
  508.                             LPARAM lparam)
  509. {
  510. PAINTSTRUCT     ps;     
  511. HDC             hdc;    
  512.        
  513. switch(msg)
  514.     {   
  515.     case WM_CREATE: 
  516.         {
  517.         return(0);
  518.         } break;
  519.    
  520.     case WM_PAINT: 
  521.         {
  522.         hdc = BeginPaint(hwnd,&ps);  
  523.         
  524.         EndPaint(hwnd,&ps);
  526.         return(0);
  527.         } break;
  529.     case WM_DESTROY: 
  530.         {
  532.         PostQuitMessage(0);
  534.         return(0);
  535.         } break;
  537.     default:break;
  539.     }
  541. return (DefWindowProc(hwnd, msg, wparam, lparam));
  543. }
  545. int Game_Init(void *parms=NULL,int num_parms=0)
  546. {
  547.   if(FAILED(DirectDrawCreateEx(NULL,(void **)&lpdd,IID_IDirectDraw7,NULL)))
  548.     return(0);
  550.   if(FAILED(lpdd->SetCooperativeLevel(main_window_handle,
  551.                                       DDSCL_FULLSCREEN|DDSCL_ALLOWMODEX|
  552.                                       DDSCL_EXCLUSIVE|DDSCL_ALLOWREBOOT)))
  553.     return(0);
  555.   if(FAILED(lpdd->SetDisplayMode(SCREEN_WIDTH,SCREEN_HEIGHT,SCREEN_BPP,0,0)))
  556.     return(0);
  558.   DDRAW_INIT_STRUCT(ddsd);
  559.   ddsd.dwFlags=DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
  560.   ddsd.dwBackBufferCount=1;
  561.   ddsd.ddsCaps.dwCaps=DDSCAPS_PRIMARYSURFACE|DDSCAPS_COMPLEX|
  562.                         DDSCAPS_FLIP;
  563.   
  564.   if(FAILED(lpdd->CreateSurface(&ddsd,&lpddsprimary,NULL)))
  565.     return(0);
  567.   ddsd.ddsCaps.dwCaps=DDSCAPS_BACKBUFFER;
  568.   if(FAILED(lpddsprimary->GetAttachedSurface(&ddsd.ddsCaps,&lpddsback)))
  569.     return(0);
  571.   for (int color=1; color < 255; color++)
  572.     {
  573.     palette[color].peRed   = rand()%256;
  574.     palette[color].peGreen = rand()%256;
  575.     palette[color].peBlue  = rand()%256;
  577.     palette[color].peFlags = PC_NOCOLLAPSE;
  578.     } 
  580. palette[0].peRed     = 0;
  581. palette[0].peGreen   = 0;
  582. palette[0].peBlue    = 0;
  583. palette[0].peFlags   = PC_NOCOLLAPSE;
  585. palette[255].peRed   = 255;
  586. palette[255].peGreen = 255;
  587. palette[255].peBlue  = 255;
  588. palette[255].peFlags = PC_NOCOLLAPSE;
  590. palette[1].peRed     = 0;
  591. palette[1].peGreen   = 16;
  592. palette[1].peBlue    = 0;
  593. palette[1].peFlags   = PC_NOCOLLAPSE;
  596. if(FAILED(lpdd->CreatePalette(DDPCAPS_8BIT|DDPCAPS_ALLOW256|
  597.                               DDPCAPS_INITIALIZE,palette,&lpddpal,NULL)))
  598.     return(0);
  600. if(FAILED(lpddsprimary->SetPalette(lpddpal)))
  601.     return(0);
  603. DDraw_Fill_Surface(lpddsprimary,0);
  604. DDraw_Fill_Surface(lpddsback,0);
  606. //顺时针画出各点!!!
  607. VERTEX2DF object_vertices[4]={-100,-100,100,-100,100,100,-100,100};
  609. object.state=1;
  610. object.num_vert=4;
  611. object.color=1;
  612. object.xv=0;
  613. object.yv=0;
  614. object.x0=SCREEN_WIDTH/2;
  615. object.y0=SCREEN_HEIGHT/2;
  616. object.vlist=new VERTEX2DF[object.num_vert];
  618. for (int index=0;index<object.num_vert;index++)
  619.   object.vlist[index]=object_vertices[index];
  621. for (int ang=0;ang<360;ang++)
  622. {
  623.   float theta=(float)ang*PI/(float)180;
  624.   cos_look[ang]=cos(theta);
  625.   sin_look[ang]=sin(theta);
  626. }
  629. return(1);  
  631. }
  633. int Game_Main(void *parms = NULL, int num_parms = 0)
  634. {
  636.   static int green_inc=4;
  638.   if(window_closed)
  639.     return(0);
  640.   if(KEYDOWN(VK_ESCAPE))
  641.   {
  642.     PostMessage(main_window_handle,WM_CLOSE,0,0);
  643.     window_closed=1;
  644.   }
  646.   DDraw_Fill_Surface(lpddsback,0);
  647.   DDRAW_INIT_STRUCT(ddsd);
  649.   if(FAILED(lpddsback->Lock(NULL,&ddsd,DDLOCK_WAIT|DDLOCK_SURFACEMEMORYPTR,NULL)))
  650.     return(0);
  652.   Draw_Filled_Polygon2D(object, (UCHAR *)ddsd.lpSurface, ddsd.lPitch);
  654.   Rotate_Polygon2D(object,5);
  656.   if (FAILED(lpddsback->Unlock(NULL)))
  657.    return(0);
  659.   Set_Palette_Entry(1, &palette[1]);
  661.   palette[1].peGreen+=green_inc;
  663.   if (palette[1].peGreen > 255 || palette[1].peGreen < 16)
  664.    {
  665.     green_inc=-green_inc;
  666.     palette[1].peGreen+=green_inc;    
  667.    } 
  669. while(FAILED(lpddsprimary->Flip(NULL,DDFLIP_WAIT)));
  670.   
  671. Sleep(33);
  673. return(1);
  675. }
  677. int Game_Shutdown(void *parms = NULL, int num_parms = 0)
  678. {/*清除资源*/
  680. if (lpddpal)
  681.    {
  682.    lpddpal->Release();
  683.    lpddpal = NULL;
  684.    }
  685. if(lpddsback)
  686.   {
  687.   lpddsback->Release();
  688.   lpddsback=NULL;
  689.   }
  690. if (lpddsprimary)
  691.    {
  692.    lpddsprimary->Release();
  693.    lpddsprimary = NULL;
  694.    } 
  695. if (lpdd)
  696.    {
  697.    lpdd->Release();
  698.    lpdd = NULL;
  699.    } 
  701. return(1);
  703. }
  706. int WINAPI WinMain( HINSTANCE hinstance,
  707.                     HINSTANCE hprevinstance,
  708.                     LPSTR lpcmdline,
  709.                     int ncmdshow)
  710. {
  712. WNDCLASSEX winclass; 
  713. HWND       hwnd;    
  714. MSG        msg;      
  715. //HDC        hdc;    
  717. winclass.cbSize         = sizeof(WNDCLASSEX);
  718. winclass.style          = CS_DBLCLKS | CS_OWNDC | 
  719.                           CS_HREDRAW | CS_VREDRAW;
  720. winclass.lpfnWndProc    = WindowProc;
  721. winclass.cbClsExtra     = 0;
  722. winclass.cbWndExtra     = 0;
  723. winclass.hInstance      = hinstance;
  724. winclass.hIcon          = LoadIcon(NULL, IDI_APPLICATION);
  725. winclass.hCursor        = LoadCursor(NULL, IDC_ARROW); 
  726. winclass.hbrBackground  = (HBRUSH)GetStockObject(BLACK_BRUSH);
  727. winclass.lpszMenuName   = NULL;
  728. winclass.lpszClassName  = WINDOW_CLASS_NAME;
  729. winclass.hIconSm        = LoadIcon(NULL, IDI_APPLICATION);
  731. hinstance_app = hinstance;
  733. if (!RegisterClassEx(&winclass))
  734.     return(0);
  736. if (!(hwnd = CreateWindowEx(NULL,                  
  737.                             WINDOW_CLASS_NAME,    
  738.                             "DirectDraw 8-Bit Line Drawing Demo", 
  739.                             WS_POPUP | WS_VISIBLE,
  740.                             0,0,    
  741.                             SCREEN_WIDTH,SCREEN_HEIGHT,  
  742.                             NULL,     
  743.                             NULL,  
  744.                             hinstance,
  745.                             NULL))) 
  746. return(0);
  748. main_window_handle = hwnd;
  750. Game_Init();
  752. while(TRUE)
  753.     {
  754.   
  755.     if (PeekMessage(&msg,NULL,0,0,PM_REMOVE))
  756.        { 
  757.        if (msg.message == WM_QUIT)
  758.            break;
  759.     
  760.        TranslateMessage(&msg);
  762.        DispatchMessage(&msg);
  763.        }
  764.      Game_Main();
  765.        
  766.     } 
  768. Game_Shutdown();
  770. return(msg.wParam);
  772. }

一定要注意调用光栅化函数时传入的参数为顺时针在笛卡尔坐标系中设置的各多边形坐标！！！

返回
【上篇】
【下篇】

作者:

抱歉!评论已关闭.

返回首页

Copyright © 2013-2018 学步园  保留所有权利.
软文销售 QQ客服：2265327166 点击这里给我发消息（其他合作也可洽谈）
必威体育
必威电竞