代码片-Demo 演示..

最新推荐文章于 2025-04-08 11:20:43 发布

原创最新推荐文章于 2025-04-08 11:20:43 发布 · 1.8k 阅读

0 ·

CC 4.0 BY-SA版权

本文通过一个Demo展示了Direct7.h在实际应用中的使用，涵盖了关键功能和实现细节。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Direct7.h

#ifndef ______G35IOSA__
#define ______G35IOSA__

#define _RGB32BIT(a,r,g,b)  ((b) + ((g) << 8) + ((r) << 16) + ((a) << 24))

#define _RGB16BIT555(r,g,b) ((b & 31) + ((g & 31) << 5) + ((r & 31) << 10))

#define _RGB16BIT565(r,g,b) ((b & 31) + ((g & 63) << 5) + ((r & 31) << 11))

#define _RGB24BIT(a,r,g,b)  ((b) + ((g) << 8) + ((r) << 16))

#include "g3x.h"

typedef struct TAGDIRECTRECT
{
    LONG    im_left   ;
    LONG    im_top    ;
    LONG    im_right  ;
    LONG    im_bottom ;
	LONG    wk_pos_x  ;
    LONG    wk_pos_y  ;
} GRAVERECT, *GPRECT ;

typedef struct DX7Graph_TAG
   {
	 LPDIRECTDRAWSURFACE7  Auxil_Surface   ;   
     DDSURFACEDESC2        Auxil_ddsd    ;   
	 UINT                  ExtraIO ;
	 RECT                  Hera ;
   } DX7Graph_STRUCT,*DX7Graph_STRUCT_PTR ;

struct INTS
{
  int x,y,height,width,Bit,L_BYTE ;
    
	unsigned char* image_PTR ;

	unsigned short IX_width,IX_height,IX_Pox_X,IX_Pox_Y ;

	   BITMAPFILEHEADER bitmapfileheader ;
       BITMAPINFOHEADER bitmapinfoheader ;

	 int (*Flip)(struct INTS*,unsigned char*,int,int) ;
	 int (*Load)(struct INTS*,LPWSTR) ;
     int (*Del)(struct INTS*) ; 
	void (*SetRECT)(struct INTS*,UINT,UINT,UINT,UINT,UINT,UINT) ;
	  RECT       INTS_RECT ;
	  GRAVERECT  Casion ;
} ;



void INTS_Slot(struct INTS*) ;

class DX7Graph : virtual public Gin
{
public:

     LPDIRECTDRAW7         lpdd ;
	 LPDIRECTDRAWSURFACE7  Source_Surface ;
	 LPDIRECTDRAWPALETTE   lpddpal     ;   
     LPDIRECTDRAWCLIPPER   lpddclipper ;   
     PALETTEENTRY          v_palette[256] ;        
     PALETTEENTRY          g_palette[256] ;     
     DDSURFACEDESC2        source_ddsd ;                  
     DDBLTFX               ddbltfx ;             
     DDSCAPS2              ddscaps ;              
     HRESULT               ddrval ;   
	 RECT                  source_RECT ;

	 DX7Graph::DX7Graph() ;
	 DX7Graph::~DX7Graph() ;

	 DWORD DX7Graph::InitMainSrf() ;
	 DWORD DX7Graph::InitAuxilSrf(DX7Graph_STRUCT&,bool,int) ;
	 DWORD DX7Graph::DirectDrawClipper(LPRECT) ;
	 DWORD DX7Graph::__24PixelPaint(INTS&,DX7Graph_STRUCT_PTR DX7 = NULL,UINT Pos_x = 0,UINT Pos_y = 0,UINT p_W = 0,UINT p_H = 0) ;
	 
protected:
private:

	vector <LPDIRECTDRAWSURFACE7> mT ;
	void   DX7Graph::Delete_DX7_STRUCT() ;
	DWORD  DX7Graph::ExchangeGL() ;
} ;

#endif

Direct7.cpp

#include "stdafx.h"
#include "GraphicsDevice.h"

extern HRESULT DIRECTEXTERMINATE ;

static int    mapper_Flip(struct INTS*,unsigned char*,int,int) ;

static int    mapper_Load(struct INTS*,LPWSTR) ; 

static int    mapper_Del(struct INTS*) ;

static void   mapper_SetRECT(struct INTS*,UINT,UINT,UINT,UINT,UINT,UINT) ;

static        UCHAR* CallBack_PTR = NULL ;

static        pSTK  V_K_S ;

static        ULONG V_W_Q ;

extern        RECT  DirectX_Window_Model_RECT ;

extern        RECT rectX ;

string         ClipperBitmapSize(UINT,UINT,UINT,UINT) ;

HRESULT       CheckDirectDrawError(HRESULT DIR_IVAS) // Error Msg
{
	switch(DIR_IVAS)
	{
    	case DDERR_DIRECTDRAWALREADYCREATED :
          MsgErr("DDERR_DIRECTDRAWALREADYCREATED","IDirectDraw7 0x88760232")
			  return DIR_IVAS ;

		case DDERR_GENERIC :
		  MsgErr("DDERR_GENERIC","IDirectDraw7 0x80004005")
			  return DIR_IVAS ;

        case DDERR_INVALIDDIRECTDRAWGUID:
		  MsgErr("DDERR_INVALIDDIRECTDRAWGUID","IDirectDraw7 0x88760231")
			  return DIR_IVAS ;

		case DDERR_INVALIDPARAMS:
		  MsgErr("DDERR_INVALIDPARAMS","IDirectDraw7 0x80070057")
			  return DIR_IVAS ;

        case DDERR_NODIRECTDRAWHW:
		  MsgErr("DDERR_NODIRECTDRAWHW","IDirectDraw7 0x88760233")
			  return DIR_IVAS ;

        case DDERR_OUTOFMEMORY:
		  MsgErr("DDERR_OUTOFMEMORY","IDirectDraw7 0x8007000E")
			  return DIR_IVAS ;

		case DDERR_EXCLUSIVEMODEALREADYSET:
		  MsgErr("DDERR_EXCLUSIVEMODEALREADYSET","IDirectDraw7 0x88760245")
			  return DIR_IVAS ;

        case DDERR_INVALIDOBJECT:
		  MsgErr("DDERR_INVALIDOBJECT","IDirectDraw7 0x88760082")
			  return DIR_IVAS ;

		case DDERR_OUTOFVIDEOMEMORY:
		  MsgErr("DDERR_OUTOFVIDEOMEMORY","IDirectDraw7 0x8876017C")
			  return DIR_IVAS ;

		case DDERR_PRIMARYSURFACEALREADYEXISTS:
		  MsgErr("DDERR_PRIMARYSURFACEALREADYEXISTS","IDirectDraw7 0x88760234")
			  return DIR_IVAS ;
		  
		default:
		  MsgErr("Unknown Error","IDirectDraw7 Unknown")
			  return DIR_IVAS ;
	}
}

/*-----------------------------------------------------------

       懒得写的了 .... 太多了 .. 自己去看 DirectX SDK文档吧...

       DDERR_INCOMPATIBLEPRIMARY    0x8876005F
       DDERR_INVALIDCAPS            0x88760064
       DDERR_INVALIDPIXELFORMAT     0x88760091
       DDERR_NOALPHAHW              0x887600B4
       DDERR_NOCOOPERATIVELEVELSET  0x887600D4
       DDERR_NODIRECTDRAWHW         0x88760233
       DDERR_NOEMULATION            0x88760235

--------------------------------------------------------------*/

DX7Graph::DX7Graph() // 构造函数 填NULL  初始化 DDSURFACEDESC2 Struct
{
	 lpdd           = NULL ;
	 Source_Surface = NULL ;
	 lpddpal        = NULL ;   
     lpddclipper    = NULL ;   
     ddrval         = 0 ; 

     _asm0(source_ddsd) ;                  

	 RtlZeroMemory(v_palette,1024) ;
	 RtlZeroMemory(g_palette,1024) ;
}

DWORD DX7Graph::InitMainSrf() // 初始化主表面..
{
	if (FAILED(DirectDrawCreateEx(NULL,(void**)(&lpdd),IID_IDirectDraw7,NULL)))
	{
	    __asm MOV DIRECTEXTERMINATE,EAX
	  CheckDirectDrawError(DIRECTEXTERMINATE) ;
	}

      if (FAILED(lpdd->SetCooperativeLevel(hWnd,DDSCL_NORMAL)))

	        {
	             __asm MOV DIRECTEXTERMINATE,EAX
	            CheckDirectDrawError(DIRECTEXTERMINATE) ;
	         }

	   source_ddsd.dwFlags        = DDSD_CAPS  ;

       source_ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE ;

	         if(FAILED(lpdd->CreateSurface(&source_ddsd,&Source_Surface,NULL)))
			
			    {
	                __asm MOV DIRECTEXTERMINATE,EAX
	               CheckDirectDrawError(DIRECTEXTERMINATE) ;
	           }
	  
			 return 5 ;
}
DX7Graph::~DX7Graph() // Destroy IDIRECTDRAW7 Object..
{
	
	Delete_DX7_STRUCT() ;

	if(Source_Surface)
		Source_Surface->Release() ;

	if(lpdd)
		lpdd->Release() ;
}

void  DX7Graph::Delete_DX7_STRUCT()
{
	vector<LPDIRECTDRAWSURFACE7>::reverse_iterator msmT_iter = mT.rbegin() ;

    while(msmT_iter != mT.rend())

	     (*msmT_iter++)->Release() ;
}

DWORD DX7Graph::InitAuxilSrf(DX7Graph_STRUCT& ddsdk,bool V,int Gx) // 离屏缓冲
{	_asm0(ddsdk.Auxil_ddsd) ;

	if(V == true)
	{
	   ddsdk.Auxil_ddsd.ddckCKSrcBlt.dwColorSpaceLowValue  = Gx ;
       ddsdk.Auxil_ddsd.ddckCKSrcBlt.dwColorSpaceHighValue = Gx ;
	} 
	      ddsdk.Auxil_ddsd.dwFlags        = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_CKSRCBLT ;
	      ddsdk.Auxil_ddsd.dwWidth        = wicket_width ;
          ddsdk.Auxil_ddsd.dwHeight       = wicket_height ;
		  ddsdk.Auxil_ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_VIDEOMEMORY ;

	   if(FAILED(lpdd->CreateSurface(&(ddsdk.Auxil_ddsd),&(ddsdk.Auxil_Surface),NULL)))

           MessageBox(NULL,TEXT("创建离屏表面失败"),TEXT("DirectDraw7"),MB_ICONERROR) ; 
	   else 
		   mT.push_back(ddsdk.Auxil_Surface) ;

	return 0 ;
}

void INTS_Slot(struct INTS* st)	 // mapper..	
{  
   st->Flip    = mapper_Flip ;
   st->Load    = mapper_Load ;
   st->Del     = mapper_Del ;
   st->SetRECT = mapper_SetRECT ;
}

int mapper_Flip(struct INTS *st,unsigned char *image,int bytes_per_line,int height)
{
   unsigned char* buffer ; 
   int index ;    

          if (!(buffer = (UCHAR *)malloc(bytes_per_line*height)))

                 MessageBox(NULL,TEXT("malloc buffer failed"),TEXT("DirectDraw7"),MB_ICONERROR | MB_ICONERROR) ;

       memcpy(buffer,image,bytes_per_line*height);

                      for (index=0; index < height ; index++)

                              memcpy(&image[((height-1) - index)*bytes_per_line],&buffer[index*bytes_per_line],bytes_per_line) ;

   free(buffer) ;

   return(1) ;
}
  // 
int mapper_Load(struct INTS *st,LPWSTR TRG)
{
   	 static int correct = 65535 ;

	  
   FILE* fp ;
      _wfopen_s(&fp,TRG,TEXT("rb")) ;

         if(fp == 0) 

	           MessageBox(NULL,TEXT("Open bmp failed"),TEXT("DirectDraw7"),MB_ICONERROR | MB_ICONERROR) ;

   fread(&st->bitmapfileheader,sizeof(BITMAPFILEHEADER),1,fp) ;
   fread(&st->bitmapinfoheader,sizeof(BITMAPINFOHEADER),1,fp) ;

       if (st->bitmapinfoheader.biHeight < 0)

			     correct = (-(st->bitmapinfoheader.biHeight)) ;
	   else 
		         correct = st->bitmapinfoheader.biHeight ;

     st->height = correct ;
     st->width = st->bitmapinfoheader.biWidth ;
     st->Bit = st->bitmapinfoheader.biBitCount ;

        if(st->Bit == 8)
 	      
			MessageBox(NULL,TEXT("没写调色板代码...禁止使用8位图元.."),TEXT("载入位图错误"),MB_ICONERROR) ;

     st->L_BYTE = ((st->width)*((st->Bit)/8) + 3)/4*4 ;

     st->image_PTR = (unsigned char*)malloc((st->L_BYTE)*(correct)) ;
	   
          if(fread(st->image_PTR,1,(st->L_BYTE)*(correct),fp) == 0)

	           MessageBox(NULL,TEXT("read image data failed"),TEXT("s_Load"),MB_ICONERROR) ; 

		  if (st->bitmapinfoheader.biHeight > 0)

			     st->Flip(st,st->image_PTR,st->L_BYTE,st->height) ; 
			   
 fclose(fp) ;

                        st->INTS_RECT.left    = 0  ;
	                    st->INTS_RECT.top     = 0  ;
	                    st->INTS_RECT.right   = st->width  ;
	                    st->INTS_RECT.bottom  = st->height ;

   st->Casion.im_left    = 0  ;
   st->Casion.im_top     = 0  ;
   st->Casion.im_right   = st->width  ;
   st->Casion.im_bottom  = st->height ;
   st->Casion.wk_pos_x   = DirectX_Window_Model_RECT.left ;
   st->Casion.wk_pos_y   = DirectX_Window_Model_RECT.top ;

                                         return 0 ;
}
	// Release Buffer
int mapper_Del(struct INTS *st)
{
	free(st->image_PTR) ;
	return 0 ;
}

DWORD DX7Graph::DirectDrawClipper(LPRECT clip_list)// Cl Window
{                     
   LPRGNDATA           region_data ;        

if (FAILED(lpdd->CreateClipper(0,&lpddclipper,NULL)))
    {
	  MessageBox(NULL,TEXT("CreateClipper failed"),TEXT("LPDIRECTDRAWCLIPPER"),MB_ICONERROR) ;
      return 5 ;
	}

region_data = (LPRGNDATA)malloc(sizeof(RGNDATAHEADER) + sizeof(RECT));

memcpy(region_data->Buffer,clip_list,sizeof(RECT)) ;

region_data->rdh.dwSize          = sizeof(RGNDATAHEADER) ;
region_data->rdh.iType           = RDH_RECTANGLES ;
region_data->rdh.nCount          = 1 ;
region_data->rdh.nRgnSize        = sizeof(RECT) ;

region_data->rdh.rcBound.left    =  64000 ;
region_data->rdh.rcBound.top     =  64000 ;
region_data->rdh.rcBound.right   = -64000 ;
region_data->rdh.rcBound.bottom  = -64000 ;


      if (clip_list->left < region_data->rdh.rcBound.left)
         region_data->rdh.rcBound.left   = clip_list->left ;

      if (clip_list->right > region_data->rdh.rcBound.right)
         region_data->rdh.rcBound.right  = clip_list->right ;
	   
      if (clip_list->top < region_data->rdh.rcBound.top)
         region_data->rdh.rcBound.top    = clip_list->top ;

      if (clip_list->bottom > region_data->rdh.rcBound.bottom)
         region_data->rdh.rcBound.bottom = clip_list->bottom ;



if (FAILED(lpddclipper->SetClipList(region_data,0))) 
   { 
     MessageBox(NULL,TEXT("SetClipList failed"),TEXT("LPDIRECTDRAWCLIPPER"),MB_ICONERROR) ;
     free(region_data) ;
     return 7 ;
   } 

if (FAILED(Source_Surface->SetClipper(lpddclipper)))
   {
     MessageBox(NULL,TEXT("SetClipper failed"),TEXT("LPDIRECTDRAWCLIPPER"),MB_ICONERROR) ;
     free(region_data) ;
     return 2 ;
   } // end if

   free(region_data) ;

   return  0 ;
}

DWORD DX7Graph::__24PixelPaint(INTS& Hel,DX7Graph_STRUCT_PTR DX7,UINT Pos_x,UINT Pos_y,UINT p_W,UINT p_H)
{
    CallBack_PTR = Hel.image_PTR ;  // Zero Index Pixel Pointer
 
	if(DX7 == NULL)
	{
	  V_K_S = (unsigned char*)source_ddsd.lpSurface;
	  V_W_Q = source_ddsd.lPitch;

	  if((Hel.INTS_RECT.right - Hel.Casion.wk_pos_x) == Hel.width)  // 完整图像的宽的话直接写入IDirectDrawSurface
	  {
	    for(int x = Hel.INTS_RECT.top ; x < Hel.INTS_RECT.bottom ; x++)  
         {  
           for(int y = Hel.Casion.wk_pos_x ; y < Hel.Casion.wk_pos_y; y++)  
              {
				*((DWORD*)(V_K_S + (y << 2) +  x*V_W_Q)) = _RGB32BIT(0,*(Hel.image_PTR + 2),*(Hel.image_PTR + 1),*Hel.image_PTR) ;  
                 Hel.image_PTR += 3 ; 
			  }
		 }
	  }

			 else if((Hel.Casion.wk_pos_y - Hel.Casion.wk_pos_x) < Hel.width)// 否则根据的现有图像的宽来做 移位 
			 { 
				
			    for(int x = Hel.INTS_RECT.top ; x < Hel.INTS_RECT.bottom ; x++)  
               {  
	             Hel.image_PTR = CallBack_PTR + 3 * Hel.width * (Hel.Casion.im_top + x - Hel.INTS_RECT.top) + 3*Hel.Casion.im_left   ;//adjust every line write when come to an end

                   for(int y = Hel.Casion.wk_pos_x ; y < Hel.Casion.wk_pos_y; y++)  
                   {
				      *((DWORD*)(V_K_S + (y << 2) +  x*V_W_Q)) = _RGB32BIT(0,*(Hel.image_PTR + 2),*(Hel.image_PTR + 1),*Hel.image_PTR) ;  
                      Hel.image_PTR += 3 ; 
			       }
			   }
	         } 

			 else
			  MsgErr("Error","OS") 

       Hel.image_PTR = CallBack_PTR ; // ...

                 return 5 ;
	}

	else
	{
	  V_K_S = (unsigned char*)DX7->Auxil_ddsd.lpSurface;
	  V_W_Q = DX7->Auxil_ddsd.lPitch;

	     for(int x = 0 ; x < (p_H - Pos_y) ; x++)  
               {  
	             Hel.image_PTR = CallBack_PTR + 3 * Hel.width * (Pos_y + x) + 3*Pos_x   ;//adjust every line write when come to an end

                   for(int y = 0 ; y < (p_W - Pos_x); y++)  
                   {
				      *((DWORD*)(V_K_S + (y << 2) +  x*V_W_Q)) = _RGB32BIT(0,*(Hel.image_PTR + 2),*(Hel.image_PTR + 1),*Hel.image_PTR) ;  
                      Hel.image_PTR += 3 ; 
			       }
			   }

		 DX7->Hera.left    = 0 ;
		 DX7->Hera.top     = 0 ;
		 DX7->Hera.right   = p_W - Pos_x ;
		 DX7->Hera.bottom  = p_H - Pos_y ;

		 rectX.left    = DirectX_Window_Model_RECT.left + 20 ;
		 rectX.top     = DirectX_Window_Model_RECT.top  + 20;
		 rectX.right   = p_W + DirectX_Window_Model_RECT.left - Pos_x + 20 ;
		 rectX.bottom  = p_H  + DirectX_Window_Model_RECT.top - Pos_y  + 20;

       Hel.image_PTR = CallBack_PTR ; // ...

                 return 5 ;
	}

	  
}

void  mapper_SetRECT(struct INTS* st,UINT Pos_X,UINT Pos_Y,UINT I_Pos_x,UINT I_Pos_y,UINT Qwidth,UINT Qheight)
{
	st->Casion.wk_pos_x    = DirectX_Window_Model_RECT.left + Pos_X ;
	st->INTS_RECT.top      = DirectX_Window_Model_RECT.top  + Pos_Y ;
	st->Casion.wk_pos_y    = Qwidth  + DirectX_Window_Model_RECT.left + Pos_X ;
	st->INTS_RECT.bottom   = Qheight + DirectX_Window_Model_RECT.top + Pos_Y ;

	st->Casion.im_left     = I_Pos_x ;
    st->Casion.im_top      = I_Pos_y ;
	st->Casion.im_right    = I_Pos_x + Qwidth ;
	st->Casion.im_bottom   = I_Pos_y + Qheight ;
}

string ClipperBitmapSize(UINT POS_X,UINT POS_Y,UINT WIDTH,UINT HEIGHT)
{
	return ("好烦啊 ..") ;
}

WinMain.cpp

#include "stdafx.h"
#include "g3x.h"
#include "Main.h"
#include "CSCSkin.h"
#include "m3x4.h"
#include "InputGather.h"
#include "GraphicsDevice.h"

#define MAX_LOADSTRING 100

CSCSkin m_skin ;
RECT   rectX ;

const   int FRAMES     = 60 ; // Frames
const   int SKIP_TICKS = 1000/FRAMES ;
static  int SleepTime  = 0 ;

HINSTANCE         hInst;								
TCHAR             szTitle[MAX_LOADSTRING];					
TCHAR             szWindowClass[MAX_LOADSTRING];	

DX7Graph_STRUCT   Spirit ;

DX7Graph_STRUCT   Canvas ;

DX7Graph_STRUCT   ExtraX ;


class EquipmentSet : public DX7Graph,public InputGather
{

} ;

EquipmentSet*      GraphicsControl  = new EquipmentSet ;

ATOM				MyRegisterClass(HINSTANCE hInstance);
BOOL				InitInstance(HINSTANCE,int);
LRESULT CALLBACK	WndProc(HWND,UINT,WPARAM,LPARAM);
INT_PTR CALLBACK	About(HWND,UINT,WPARAM,LPARAM);
TCHAR*              CPath(TCHAR*) ;

RECT                For_Shadow_Window_RECT ;
RECT                For_Shadow_Client_RECT ;
RECT                DirectX_Window_Model_RECT ;

void                SetDirectDrawShadow(HWND,LPRECT) ;



typedef struct m_Rect_TAG
  {
	 USHORT pos_x,
		    pos_y,
			width,
			length;

	 UINT extra_x,
		  extra_y,
		  extra_w,
		  extra_l;

	 UINT (*SetupCentreSize)(struct m_Rect_TAG*,USHORT,USHORT) ;

  } m_Rect,m_Rect_PTR;

static  UINT  mapper_SetupCentreSize(m_Rect*,USHORT,USHORT) ;

void INTS_Init(m_Rect* mST)	 // ..	
{  
   mST->SetupCentreSize = mapper_SetupCentreSize ;
}

 class BaseFont
 {
 public:

	 BaseFont():hFont(NULL) {}
	 DWORD SetFont(HDC&,int,int,int,LPCTSTR) ;
	~BaseFont() ;
	 
 private:
	 HFONT hFont ;
 } ;

 BaseFont FDS ;
 m_Rect mGx ;

 INTS MARIO,MAP ;

int APIENTRY _tWinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPTSTR    lpCmdLine,
                     int       nCmdShow)
{
	  m_skin.Init(); // MySkin
      m_skin.LoadSkinFromFile(L"TopaX.skf");// Load Skin Files
	  m_skin.ApplySkin(); // use skin

	  InitCommonControls() ;  // XP So SysLink..
	  
	RECT rect ;
	GetWindowRect(NULL,&rect) ;
 	
	MSG msg;
	HACCEL hAccelTable;



	LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
	LoadString(hInstance, IDC_SKINC, szWindowClass, MAX_LOADSTRING);
	MyRegisterClass(hInstance);


	if (!InitInstance (hInstance, nCmdShow))
	{
		return FALSE;
	}

	hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_SKINC));


	while(TRUE)
	{
    // test if there is a message in queue, if so get it
	if (PeekMessage(&msg,NULL,0,0,PM_REMOVE))
	   { 
       if (msg.message == WM_QUIT)
           break;

	   TranslateMessage(&msg);

	   DispatchMessage(&msg);
	   } // end if
    


	DWORD next_game_tick = timeGetTime() ;
	SetDirectDrawShadow(GraphicsControl->hWnd,&DirectX_Window_Model_RECT) ;
      
	static int x,y   ;
	
	GraphicsControl->lpdikey->GetDeviceState(256,(LPVOID)GraphicsControl->keyindex);
	if (GraphicsControl->keyindex[DIK_A])  
	{
	
	}

  
 	 x += 32  ;
if(x > 512)
	x = 32 ;
Sleep(180) ;
MARIO.SetRECT(&MARIO,0,0,x,2,32,48) ;

Canvas.Auxil_Surface->Lock(NULL,&Canvas.Auxil_ddsd,DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT,NULL) ;
             
Spirit.Auxil_Surface->Lock(NULL,&Spirit.Auxil_ddsd,DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT,NULL) ;

    GraphicsControl->__24PixelPaint(MARIO,&Canvas,x,0,32 + x,48) ;  

	GraphicsControl->__24PixelPaint(MAP,&Spirit,0,0,32,48) ;
  
  Canvas.Auxil_Surface->Unlock(NULL) ;
  Spirit.Auxil_Surface->Unlock(NULL) ;


    GraphicsControl->Source_Surface->Blt(&rectX,Spirit.Auxil_Surface,&Canvas.Hera,DDBLT_KEYSRC,NULL) ; 
    GraphicsControl->Source_Surface->Blt(&rectX,Canvas.Auxil_Surface,&Canvas.Hera,DDBLT_KEYSRC,NULL) ; 
	
	next_game_tick += SKIP_TICKS;
    SleepTime = next_game_tick - timeGetTime();
    if(SleepTime >= 0)

       Sleep(SleepTime) ;
       
	} // end while

	return (int) msg.wParam;
}

ATOM MyRegisterClass(HINSTANCE hInstance)
{
	WNDCLASSEX wcex;

	wcex.cbSize = sizeof(WNDCLASSEX);

	wcex.style			= CS_HREDRAW | CS_VREDRAW;
	wcex.lpfnWndProc	= WndProc;
	wcex.cbClsExtra		= 0;
	wcex.cbWndExtra		= 0;
	wcex.hInstance		= hInstance;
	wcex.hIcon			= LoadIcon(hInstance, MAKEINTRESOURCE(IDI_ICON3));
	wcex.hCursor		= LoadCursor(NULL, IDC_ARROW);
	wcex.hbrBackground	= (HBRUSH)GetStockObject(WHITE_BRUSH) ;
	wcex.lpszMenuName	= MAKEINTRESOURCE(IDC_SKINC);
	wcex.lpszClassName	= szWindowClass;
	wcex.hIconSm		= LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_ICON4));

	return RegisterClassEx(&wcex);
}

BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
   HWND hWnd;

   hInst = hInstance; 

   INTS_Init(&mGx) ;

   INTS_Slot(&MARIO) ;
   
   INTS_Slot(&MAP) ;

   MARIO.Load(&MARIO,L"Guko.bmp") ;

   MAP.Load(&MAP,L"map.bmp") ;

   mGx.SetupCentreSize(&mGx,wicket_width,wicket_height) ; //设置窗口中心显示..

   hWnd = CreateWindow(szWindowClass,szTitle,WS_CAPTION & ~WS_SIZEBOX | WS_SYSMENU,mGx.pos_x,mGx.pos_y,wicket_width,wicket_height,NULL,NULL,hInstance,NULL);
 
   GraphicsControl->eventToGainX(hInstance,hWnd) ;// Save Handle... 

   GraphicsControl->InitMainSrf() ; //Init IDirectDraw7 Main Surface..

   GraphicsControl->Input8Init() ;

   GraphicsControl->CrKeyPadDev() ;

   GraphicsControl->CrMouseDev() ;

   GraphicsControl->InitAuxilSrf(Spirit,true,_RGB32BIT(0,0,152,128)) ;

   GraphicsControl->InitAuxilSrf(Canvas,true,_RGB32BIT(0,0,152,128)) ;

   GraphicsControl->InitAuxilSrf(ExtraX,true,_RGB32BIT(0,0,152,128)) ;

   ShowWindow(hWnd,nCmdShow);

   UpdateWindow(hWnd);

   return TRUE;
}

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	int wmId, wmEvent;

	switch (message)
	{
	case WM_COMMAND:
		wmId    = LOWORD(wParam);
		wmEvent = HIWORD(wParam);

		switch (wmId)
		{
		case IDM_ABOUT:
			DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
			break;
		case IDM_EXIT:
			DestroyWindow(hWnd);
			break;
		default:
			return DefWindowProc(hWnd, message, wParam, lParam);
		}
		break;

	case WM_DESTROY:

		PostQuitMessage(0);
		break;

	default:
		return DefWindowProc(hWnd, message, wParam, lParam);
	}
	return 5;
}

INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{

	InvalidateRect(hDlg,NULL,true) ;

	switch (message)
	{
	case WM_INITDIALOG:

		return (INT_PTR)TRUE;

	case WM_COMMAND:
		if (LOWORD(wParam) == IDCANCEL)
		{
			EndDialog(hDlg,LOWORD(wParam));
			return (INT_PTR)TRUE;
		}
	case WM_CTLCOLORSTATIC:
		{
        SetBkMode((HDC)wParam, TRANSPARENT);  
        return (BOOL)((HBRUSH)GetStockObject(NULL_BRUSH)); 
		}
	case WM_NOTIFY:
      {
         LPNMHDR pnmhdr = (LPNMHDR)lParam;
		
         switch (pnmhdr->code) 
         {
           case NM_CLICK:
           case NM_RETURN:
            {
               if (pnmhdr->idFrom == IDC_SYSLINK) 
		
                ShellExecute(hDlg,TEXT("open"),TEXT("http://baid.ws/dSxa"),NULL,NULL,SW_HIDE);
			   break ;
            }
            break; 
         }
      return TRUE;
      }

		break;
	}
	return (INT_PTR)FALSE;
}

DWORD BaseFont::SetFont(HDC& hdc,int nHeight,int nWidth,int FnWeight,LPCTSTR CharName)
{
	hFont = CreateFont(nHeight,nWidth,0,0,FnWeight,false,false,false,DEFAULT_CHARSET,0,0,0,0,CharName);
	
	SelectObject(hdc,hFont);

	SetTextColor(hdc,255);

	SetBkMode(hdc,TRANSPARENT) ;
	return 0 ;
}

BaseFont::~BaseFont()
{
 DeleteObject(hFont) ;
}

UINT mapper_SetupCentreSize(m_Rect* mST,USHORT width,USHORT length)
{
	mST->pos_x  = (GetSystemMetrics(SM_CXSCREEN) - width) >> 1 ;
	mST->pos_y  = (GetSystemMetrics(SM_CYSCREEN) - length) >> 1 ;

	mST->width  = width   ;
	mST->length = length  ;

	return 0 ;
}

TCHAR* CPath(TCHAR* szST)
 {
   static TCHAR Src[240],Des[240] ;
   static USHORT Sx,Dx,est ;
   
   	   __asm PUSH ECX           __asm PUSH EDI  
       __asm PUSH EAX           __asm CLD                          
       __asm MOV  EAX,0         __asm MOV  ECX,120  
       __asm LEA  EDI,Src       __asm REP  STOSD
	   __asm MOV  ECX,120       __asm LEA  EDI,Des
	   __asm REP  STOSD         __asm POP  EAX           
	   __asm POP  EDI           __asm POP  ECX

   wcscpy(Src,szST);

   while((Src[Sx] != '\0'))
	   {
	   	 if(Src[Sx] == 0x5C)
			{
			  Des[Dx]     = Src[Sx] ;
			  Des[Dx + 1] = Src[Sx] ;
			  Sx++ ;  Dx += 2 ;
		    }
		 else
			{
			  Des[Dx] = Src[Sx] ;
			  ++ Sx ;   ++ Dx ;
		    }
       }
    Sx = 0 ; Dx = 0 ;
    return Des ;
  }

void  SetDirectDrawShadow(HWND hWnd,LPRECT RECT_PTR)
{
	GetWindowRect(hWnd,&For_Shadow_Window_RECT) ;

	GetClientRect(hWnd,&For_Shadow_Client_RECT) ;

	RECT_PTR->left     = (For_Shadow_Window_RECT.right + For_Shadow_Window_RECT.left - For_Shadow_Client_RECT.right) >> 1 ;
    RECT_PTR->right    = RECT_PTR->left + For_Shadow_Client_RECT.right ;
	RECT_PTR->top      = For_Shadow_Window_RECT.bottom  - For_Shadow_Client_RECT.bottom - RECT_PTR->left + For_Shadow_Window_RECT.left ;
    RECT_PTR->bottom   = RECT_PTR->top + For_Shadow_Client_RECT.bottom ;
}

    // test if there is a message in queue, if so get it
	if (PeekMessage(&msg,NULL,0,0,PM_REMOVE))
	   { 
       if (msg.message == WM_QUIT)
           break;

	   TranslateMessage(&msg);

	   DispatchMessage(&msg);
	   } // end if
    


	DWORD next_game_tick = timeGetTime() ;
	SetDirectDrawShadow(GraphicsControl->hWnd,&DirectX_Window_Model_RECT) ;
      
	static int x,y   ;
	
	GraphicsControl->lpdikey->GetDeviceState(256,(LPVOID)GraphicsControl->keyindex);
	if (GraphicsControl->keyindex[DIK_A])  
	{
	
	}

	IQX = 120 ;
	IQY = 250 ;

    GukoRect.left   = IQX ;
    GukoRect.top    = IQY ;
    GukoRect.right  = 32 + IQX ;
    GukoRect.bottom = 48 + IQY ;

	if(first == 0)
 	{ x += 32  ;
if(x > 480)
{
	x = 0 ;
	y = 48 ;
	++ first ;
}
Sleep(120) ;
	}
	
	else
	{
	  x += 32  ;
	  y = 48 ;
if(x > 240)
	x = 0 ;
Sleep(120) ;
	}
	


             
Canvas.Auxil_Surface->Lock(NULL,&Canvas.Auxil_ddsd,DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT,NULL) ;
Spirit.Auxil_Surface->Lock(NULL,&Spirit.Auxil_ddsd,DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT,NULL) ;


	GraphicsControl->__24PixelPaint(MAP,&Canvas,0,0,472,314) ;
    GraphicsControl->__24PixelPaint(MARIO,&Spirit,x,y,32 + x,48 + y) ;

   Canvas.Auxil_Surface->Unlock(NULL) ;
   Spirit.Auxil_Surface->Unlock(NULL) ;

   Canvas.Auxil_Surface->Blt(&GukoRect,Spirit.Auxil_Surface,&Spirit.Hera,DDBLT_KEYSRC,NULL) ;
    GraphicsControl->Source_Surface->Blt(&Canvas.Zeus,Canvas.Auxil_Surface,&Canvas.Hera,DDBLT_KEYSRC,NULL) ; 
	
	
	next_game_tick += SKIP_TICKS;
    SleepTime = next_game_tick - timeGetTime();
    if(SleepTime >= 0)

       Sleep(SleepTime) ;
       
	} // end while

	return (int) msg.wParam;
}

ATOM MyRegisterClass(HINSTANCE hInstance)
{
	WNDCLASSEX wcex;

	wcex.cbSize = sizeof(WNDCLASSEX);

	wcex.style			= CS_HREDRAW | CS_VREDRAW;
	wcex.lpfnWndProc	= WndProc;
	wcex.cbClsExtra		= 0;
	wcex.cbWndExtra		= 0;
	wcex.hInstance		= hInstance;
	wcex.hIcon			= LoadIcon(hInstance, MAKEINTRESOURCE(IDI_ICON3));
	wcex.hCursor		= LoadCursor(NULL, IDC_ARROW);
	wcex.hbrBackground	= (HBRUSH)GetStockObject(WHITE_BRUSH) ;
	wcex.lpszMenuName	= MAKEINTRESOURCE(IDC_SKINC);
	wcex.lpszClassName	= szWindowClass;
	wcex.hIconSm		= LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_ICON4));

	return RegisterClassEx(&wcex);
}

BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
   HWND hWnd;

   hInst = hInstance; 

   INTS_Init(&mGx) ;

   INTS_Slot(&MARIO) ;
   
   INTS_Slot(&MAP) ;

   MARIO.Load(&MARIO,L"Guko.bmp") ;

   MAP.Load(&MAP,L"map.bmp") ;

   mGx.SetupCentreSize(&mGx,wicket_width,wicket_height) ; //设置窗口中心显示..

   hWnd = CreateWindow(szWindowClass,szTitle,WS_CAPTION & ~WS_SIZEBOX | WS_SYSMENU,mGx.pos_x,mGx.pos_y,wicket_width,wicket_height,NULL,NULL,hInstance,NULL);
 
   GraphicsControl->eventToGainX(hInstance,hWnd) ;// Save Handle... 

   GraphicsControl->InitMainSrf() ; //Init IDirectDraw7 Main Surface..

   GraphicsControl->Input8Init() ;

   GraphicsControl->CrKeyPadDev() ;

   GraphicsControl->CrMouseDev() ;

   GraphicsControl->InitAuxilSrf(Spirit,true,_RGB32BIT(0,0,152,128)) ;

   GraphicsControl->InitAuxilSrf(Canvas,true,_RGB32BIT(0,0,152,128)) ;

   GraphicsControl->InitAuxilSrf(ExtraX,true,_RGB32BIT(0,0,152,128)) ;

   ShowWindow(hWnd,nCmdShow);

   UpdateWindow(hWnd);

   return TRUE;
}