DirectX5.0Ϸָ
ƪ
人 촺ϲ & 

    ڶϷ˵MicrosoftDirectX 5ƳһõϢ˱һϷͶýӦó
¼͹ߣΪĳԱṩһ׵ӦóӿAPIʹԱܹƸʵʱӦóDirectXʹMicrosoft 
WindowsϵͳµϷ MS-DOSϵͳµϷиߵܵĸõĽԣרõϷҲضá
    MicrosoftDirectXҪĿľҪWindowsϷԡڴ֮ǰ˵ϵĴ󲿷ϷǻMS-DOS
ģϷԱԲͬӲӿڿƲͬĳ򣬾ܴƣɱظͶDirectX Ϸ
ԱͿԻDirectXӲԵŵ㣬ͬʱֱֿӷӲDirectXҪĿṩMS-DOSֱӵӲ
ԣͬʱȥ˵µӲʱӲʶ⡣
    ΪӲǲɱģԣDirectXʵҲṩһּ弴õķˣDirectXԿʵʱӦ
ó򣬿ֱӷʼеӲͽϵͳлؾеӲ豸DirectXӲӦ֮ṩһµĽӿԼٰװõ
ԣʹӲôﵽšDirectXṩĽӿڣԱܳӲԶҪϸڡһĻ
WindowsĸϷӦܹϵͳ¼
.ΪܶרƵļٿ
.弴PnPPlug and Play
.ǶWindowsͨŷ񣬰DirectPlay
   DirectX 5߸֣ԸԼҪ˵
(1).DirectDraw  ַ֧ͨʾڴλͼӲټֱӴȡӲλ鴫ͻתܡ
(2).DirectSound ṩӲϺ¼ܡ
(3).DirectPlay   ʹϷڵƽ֮ӸӼ򵥷㡣 
(4).Direct3D    ṩ˸߼ģʽRetained-Modeӿں͵ͼʱģʽImmediate-Modeӿڡǰ׵һ
ȫάͼϵͳʹóȫɫܵ
.DirectInput   ṩ˻WindowsϷAPI֧Ŀǰļ̡ͲݸˣҲֽ֧ĻWindows
豸 
.DirectSetup   ṩDirectXһ԰װ̡
(7).AutoPlay     Windows 95ԣ㽫̷ʱԶаװϷʵϣAutoPlayҲMicrosoft Win32 
APIһ֣ǽDirectX SDKС.
    ͨѯDirectXӿڣԼϵͳаװDirectXĸ汾DirectX  SDKеķļGetDXVersion.cppе
GetDXVersionһ񡣸úһЩؼDirectX󩤩һDirectDrawһDirectDrawSurfaceһ
DirectInput󩤩 ⰲװϵͳеDirectXİ汾ϵͳаװϰ汾DirectX SDKȷҪINCLUDE
LIB·ʹDirectX 5ͷļĴͬDirectX 3ĿӺ󽫻ֲԤ֪Ĵ 
    ΪC++ԸܹԼӲֱӵķʣDirectXC++ΪԡDirectXרΪVisual C++
ƵģԱдDirectXVisual C++½СȻBorland C++5.0Ҳû⣬ֻЩͬˣ潫ᵽһ
⡣Ϊ˽ͱ̵ѶȣһЩ˾ҲDirectXڲ̻ͬеĿؼArakelian Soft˾ActiveXؼDirectStudio98 
for Visual Basic5.0Tegosoft˾TegoSoft ActiveX for Visual BasicJohn PullenPaul BearneJeff KurtzDelphiµ
Delphi Games Creatorȡǵ⣬ûʹVisual C++

һDirectXͲģCOM
1.1	ģCOMComponent Object Model
    DirectXеĴ󲿷APIɻCOMĶͽӿɡCOMǽӿõĻڶϵͳĻCOM̵ĺģͣ
Ҳһֽӿڹ淶ڲϵͳϣһģ͡
    DirectX APIΪCOMʵԽһһںӣͨӿͨţͨCOMӿڷ͸
ӶյΪ磬IDirectDraw2::GetDisplayModeͨIDirectDraw2ӿڴDirectDrawõǰʾģ
ʽʱͬһ𣬲ܹʹЩĽӿڡ֪ĳCOM󣬲֪ö֧
ĽӿڣӦóܹȷһִеķCOM󶼼̳еһQueryӿڷȷ
һֵ֧ĽӿںʹЩӿڵָ롣
1.2IUnknown ӿ
    еCOM ӿڶһΪIunknownĽӿýӿΪDirectXṩ˶ڵĿƺͲӿڷIunknown

	.AddRef	 һӿڻһӦһʱʹAddReföֵ1
	.QueryInterface		 ָͨضӿڵָѯֵ֧ԡ
	.Release	   ֵ1ֵΪ0ʱöʹڴͷš
    AddRefReleaseάֵ磬һDirectDrawSurface󣬸öֵͱ趨Ϊ1ÿ
εһظöָʱúͨطָAddReföֵ1ÿһAddRefĵö
һReleaseĵӦֵﵽ0ʱöͱöнӿڶá
    QueryInterfaceⶨһǷָ֧Ľӿڣ֧֣QueryInterfaceͷָýӿڵָ롣Ȼʹøýӿڰ
ķͬͨšQueryInterfaceɹطؽӿڵָ룬ԶAddRefӶֵڳӿָ֮ǰ
Releaseٶֵ
1.3	DirectX COM ӿ
    DirectXеĽӿ൱COM̴ġ豸ĶÿӿڶIUnknown COMӿIDirectDraw2
IDirectSoundIDirectPlayĴɶ̬ӿDLLе⺯
    ͵ǣDirectXģΪÿ豸ṩһַ֧Ķ磬DirectDrawͱ
ʾDirectDrawʾڴDirectDrawSurfaceͱӲɫDirectDrawPaletteͬ
DirectSoundƵɴԴDirectSoundBuffer
    ܹӶ⣬豸ܲⶨ豸ܣĻĴСɫǷֲ֧ϳɵȡ
1.4	C++COM ӿ
    C++Ա˵COMӿھһĻࡣC++ĻУеķΪģζûκδͬ
һ𡣴C++COMӿڶʹһֳΪvtable豸һӦӿڵк
óʹЩQueryInterfaceڵĽӿڣȡýӿڵָ룬QueryInterfaceӦû
ʵϾʹӶнյָ룬ָͨͿԵӦڸöнӿڷ
    COMC++һ֮Ƿĵһǽӿڻ֣C++гΪthisΪCOMC++ȫ
ݵģͽCOMӿͬC++ͬҾͬ﷨ʹôһЩ
1.5	ȡµĽӿ
    ģͲͨıڵĽӿеķͨչԵ½ӿ¶ĹܡڱеĽӿ״̬
£COMܹչάͬɵӦüݡDirectXѭһԭ磬DirectDraw֧IDirectDrawSurface ӿ
汾 IDirectDrawSurfaceIDirectDrawSurface2IDirectDrawSurface3Ҫ½ӿṩԣö
IUnknown::QueryInterfaceָȡĽӿڵȫͳһʶGUIDglobally unique identifierӿڵGUIDصͷļ
˵βѯһµĽӿڣ
    LPDIRECTDRAW    lpDD1;
    LPDIRECTDRAW2   lpDD2;

    ddrval = DirectDrawCreate( NULL, &lpDD1, NULL );
    if( FAILED(ddrval))
        goto ERROROUT;

    // Query for the IDirectDraw2  Interface
    ddrval = lpDD1->Queryӿ(IID_IDirectDraw2, (void **)&lpDD2);
    if( FAILED(ddrval))
        goto ERROROUT;
    
    // Now that we have an IDirectDraw2, release the original Interface
    lpDD1->Release();
    µĽӿڲ֧ǰ汾ӿṩķ٣IDirect3DDevice2ӿڸպһӿڡӦҪڰ汾
ӿṩԣϵĽӿڵGUIDʹѯýӿڡ
1.6	CȡCOM
    ʹCҲԵκCOMӿڷCԵһӿڷҪҪ£
 	.ĵһʼѾĵø÷Ķ󣨼this
	.ӿеÿָͨ
ʹCԵIDirectDraw2::CreateSurfaceһͬһDirectDrawı棺
 ret = lpDD->lpVtbl->CreateSurface (lpDD, &ddsd, &lpDDS, 
      NULL); 
 
     lpDDͬ±DirectDrawͬʱ÷һ棨SurfaceĽṹ&ddsdָ½ӿ&lpDDS
ָ롣 IDirectDraw2::CreateSurfaceҪָDirectDrawȻȡеķṩĵһ
ѾDirectDraw Ĵ˵CC++COM󷽷õĲ֮ͬ
ret = lpDD->CreateSurface(&ddsd, &lpDDS, NULL) 
 
DirectX 5е
    ֪ DirectX 5DirectX°汾ڴ֮ǰMicrosoftDirectXDirectX2DirectX3ûDirectX4ȻDirectX 
5DirectX3ṩ˸Ĺܺͷ񣬲DirectX3 APIдĳҪ޸ľͿԳɹرСDirectX5DirectX3
Ҫ֮ͬ
2.1DirectDraw 	
    DirectDrawչµƵ˿ӦóƴӲƵ˿ڴ͵ʾڴеDirectDraw⣬DirectDraw 
ӲHELHardware Emulate LayerܹPentium MMXṩļܡDirectDrawһδһʱ
ǷMMXڷǱڴļϣòԻᵼµһ¼¼Ӱܺȶԡ
DirectDrawֱ֧(Primary Surface)棨Off-screen SurfaceֻҪӲԴ㹻ı档
    DirectDrawָ֧߼ͼζ˿AGPAdvanced Graphics PortԡһAGP豸ϵͳڷǱʾڴ洴档DDSCAPS
ṹֱ֧׼أʾڴAGPǱأʾڴ֮䲻ͬı־DirectDraw Ǳʾڴλ鴫DDCAPSṹ
ĳԱϢ
2.2DirectPlay
    DirectPlayһµĽӿIDirectPlay3µķ֮⣬ͬIDirectPlay2ȫͬͬأIDirectPlayLobby2Ҳ
IdirectPlayLobby汾DirectPlay¹ܰͨӿݷʽطṩߣService ProviderԻԱ
ֿûỰĸбӦSetSessionDescõֿ֧Ựֱ֧ܷӼʹCoCreateInstanceֱӴ
DirectPlay
2.3DirectSound
    DirectSound һµĽӿIksPropertySetʹ֧ṩչ񡣻COMĺDirectSoundCapture
Ҳµģֱӷ
2.4Direct3D
    Direct3DʱģʽImmediate Mode֧Drawing PrimitiveֱڻйDirect3DģʽRetained Mode
ֲֵ֧ʹܹɫƽƶ壬񣬲ִı任ģʽҲֽ֧񣬼ȿʼһ
ڵȻϸ
5DirectInput
    DirectInputṩ˲ݸ˵COMӿڣͬʱṩ˼̺װõCOMӿڡ
6DirectSetup
    DirectSetupڰ˸ûӿڶһصṩġûصǰİװ״̬ݸװ
ͨƵûӿһϢʾװ״̬⣬DirectSetupṩ˶ҵϷķϷУҿʹ
DirectPlayLobbyעȥעϢ
6AutoPlay	AutoPlayͬDirectX3һδ䶯

DirectX5.0Ϸָ
 DirectDrawƪ

    DirectDrawDirectX SDKҪ֮һֱӶʾڴ֧Ӳλ鴫䡢Ӳǡ淭תұͬĿ
ǰĻWindowsӦóݡ
    DirectDrawһӿڣֱӶʾ豸ȡ⣬ͬWindowsͼ豸ӿGDIGraphics Device Interfaceݡ
ͼ˵һָ߼ӦóӿڡDirectDrawṩһ豸޹ԵķʹûWindowsӦϷ
άͼƵϷֱӻȡʾ豸ԡ
    DirectDrawܹڸָʾ豸Ӽ򵥵SVGAʾܹṩСͷRGBʽֵ֧ĸ߼ʾ豸DirectDraw
ӿʹӦóܷӲܲʹӲԣӲṩԽDirectX档DirectDrawṩĶʾڴ
豸޹Եķʹ׵عʾڴ档ӦóֻҪʶһЩ豸ԣǶǱ׼ӲӦãRGB
YUVʽɫ㲻ҪĹʹλ鴫ݵɫĴʹDirectDrawԺ׵زʾڴ棬
òͬʾ豸λ鴫ɫѹܣҪضӲDirectDrawWindows95/NT4.0Ժİ汾
С
    DirectDrawӲHALHardware Abstraction LayerṩͳһĽӿڣͨýӿڣֱʾڴƵڴ
ȡӲܡ
    DirectDrawƵӲܽйƣֻҪܾͻʹӲṩضܡ磬Ƶ֧λ鴫䣬DirectDrawͻ
λ鴫ίиƵCPUλ鴫Ĵʹ˳еܡ⣬DirectDrawṩӲHEL(Hardware 
Emulation Layer )ʹĳЩӲʱֱ֧ӦЩӲṩԡ
    DirectDrawWindows 95ϣܹ32λڴԽԺͲϵͳṩġƽ̹ڴģ͡DirectDrawϵͳڴƵ
Ϊ洢һСһСεʹá⣬DirectDrawΪ WindowsͼγԱǿĹܣ
  .DirectDrawʹȫģʽµӦǫ̈ҳת
  .ִ֧ģʽȫģʽµļй
  .֧ά Z
  .֧ZӲ
  .ṩͼӲĴȡ
  .ͬʱʱ׼ĺǿʾ豸ڴ
  .̬ɫ塢ռʽӲʡֱл
ЩԽһͿԽ׵رƳܳGDIı׼WindowsϷMS-DOSµϷ

һDirectDrawĻͼ
    DirectDrawṩһ鲻ͬGDIͼˣҪúDirectDrawӦ˽ейظͶDirectDraw
Ҫĸһܡ
1.1豸޹λͼDIBDevice-Independent Bitmap
     DirectXʹ豸޹λͼDIBΪҪͼļʽһDIBļҪϢͼάʹõɫ
ɫֵÿһصݡDIBļ˽õĲйļѹϢͼάDIBļչһ
ǡ.BMPʱҲǡ.DIB
    ΪDIBWindowsеӦü㷺DirectX SDKѾصĺ磬DirectX SDKṩddutil.cppļ
һWin32DirectXһ𣬸ǰһDIBļװDirectX棬£
extern "C" IDirectDrawSurface * DDLoadBitmap(IDirectDraw *pdd, 
    LPCSTR szBitmap, int dx, int dy) 
{ 
    HBITMAP             hbm; 
    BITMAP              bm; 
    DDSURFACEDESC       ddsd; 
    IDirectDrawSurface *pdds; 
    //  This is the Win32 part. 
    //   Try to load the bitmap as a resource, if that fails, try it as a file. 
    hbm = (HBITMAP)LoadImage(GetModuleHandle(NULL), szBitmap, IMAGE_BITMAP, dx, dy, LR_CREATEDIBSECTION); 
    if (hbm == NULL) 
        hbm = (HBITMAP)LoadImage(NULL, szBitmap, IMAGE_BITMAP, dx, dy, LR_LOADFROMFILE|LR_CREATEDIBSECTION); 
    if (hbm == NULL) 
        return NULL; 
    // Get the size of the bitmap. 
    GetObject(hbm, sizeof(bm), &bm); 
    // Now, return to DirectX function calls. 
    // Create a DirectDrawSurface for this bitmap. 
    ZeroMemory(&ddsd, sizeof(ddsd)); 
    ddsd.dwSize = sizeof(ddsd); 
    ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT |DDSD_WIDTH; 
    ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN; 
    ddsd.dwWidth = bm.bmWidth; 
    ddsd.dwHeight = bm.bmHeight; 
    if (pdd->CreateSurface(&ddsd, &pdds, NULL) != DD_OK) 
        return NULL; 
    DDCopyBitmap(pdds, hbm, 0, 0, 0, 0); 
    DeleteObject(hbm); 
    return pdds; 
} 

 1.2ͼ棨Drawing Surface
    ͼƵݲΪͼʾڴWindowsӦóУʹWin32ĺGetDCʻͼ
档GetDCȡ豸DCDevice Context豸ĺ󣬾ͿػˡȻWin32ͼGDIṩġ
GDIϵͳһ֣ṩ˳㣬ʹñ׼Windowsͼ
    GDIȱΪܵĶýƵģҪҵִ͵ӱGDIṩ˶ϵͳڴеƵ
ķʣṩƵڴķʡGDIڴҵǳʣڶýӦóϷԵ̫ˡ
    һ棬DirectDraw ṩʵƵڴĻͼ棬ζŵʹDirectDraw ʱֱܹƵڴдݣʹ
ͼʾٶ㹻졣ЩΪڴ飬ʹѰַʱס
1.3λ鴫Blit
   BlitǡBit Block Transferļдʾλ鴫䡣ǽڴһַһݴ͵һַһַλ鴫侭
ھ鶯СʹIDirectDrawSurface3::Blt IDirectDrawSurface3::BltFastִλ鴫䡣

1.4ҳתPage Flippingͺ̨壨Back Buffering
    ҳתǶý塢ϷеĹؼҳתǶԿͨʹͼ˶Ĺ̵ģ⡣磬һֽϻһ
Ȼһ֡Ĺ״̬ÿһֻ֡ٵظıͼ󡣵ٷתֽƬʱͼͳ˶
    еҳתĹ̡ȣ㽨һϵDirectDraw棬Щƺõı׼תĻһ汻
棨Primary Surfaceб涼Ϊ̨Ӧóд̨Ȼת棬Ą̊́
ʾƬˡϵͳʾͼʱͿ̨дݣһֱĽʹٶЧ
ɢͼɶ DirectDrawԼһЩ˫һһ̨Ҳʹýϸӵļ
ĺ̨ʹܹ׵ؽҳתĳ

1.5ΣRectangle
    ᴩDirectDrawWindows̵һҪĸǱϵĶ󩤩нΡһнȷϽǺ
ǡλ鴫ķʽĻдʱӦóʹRECTṹйнεϢRECTṹĶ£
typedef struct tagRECT { 
    LONG    left;    // This is the top-left corner's X-coordinate.
    LONG    top;     // The top-left corner's Y-coordinate.
    LONG    right;   // The bottom-right corner's X-coordinate.
    LONG    bottom;  // The bottom-right corner's Y-coordinate.
} RECT, *PRECT, NEAR *NPRECT, FAR *LPRECT; 

    lefttopԱǾϽǵXYֵrightbottom½ǵXYֵ

1.6飨Sprite 
    ƵϷʹ˾顣һĻƶͼ󡣾黭һϣеıϣ
ϳɺͼ͵Ļʾ
1.6.1͸λ鴫䣨Transparent BlittingColor Key
    鶯еѵڶԷǱ׼εľĴΪλ鴫亯ǹھηʽ£ľҲһ֮У
ĻǷΡ
    ͼǾεģȴھСλ鴫佫ͼƶĿĵʱвھؾͱ͸
Աѡһɫ飬ɫͱΪ͸ȡColor KeyһֲõɫԱڱʾ͸
ȻضɫΧ
    ʹIDirectDrawSurface3::SetColorKeyΪһ趨Color KeyColor Key󣬵 IDirectDrawSurface3::BltFast
ʹõColor KeyǷͬColor Keyƥ䡣͵Color KeyԴ Color KeyԴColor Keyֹ͸
дĿĵأԭıؾͱˣʹþ鿴ǷǾε˲Ҿ黹ڱƶ
    ⣬㻹ʹһColor KeyӰĿı棨ĿColor KeyĿColor KeyҲǱϵһɫָǷ
Աǡ
1.6.2޲ΣSprite and Patch Rectangle
    Ϊ˲˶Чڽ黭µλ֮ǰӱϲɵλϵľͼ󡣵ȻҲµ
ػ飬󽵵ͶʵϣԱεһεĹ켣ԸλػַΪ޲Patching
Ϊ޲ɵλãԭʼͼѾ뵽һ棩һػһλáʹõλ鴫
ѭнУҪõĴʱ١һ̵ļ򵥲裺
(1). þһλõ޲
(2). ʹλ鴫佫еıͼλ
(3). ¾ĿľΣӳ˾µλ
(4). λ鴫䵽¸µľλ 
(5).ظ
    DirectDrawṩǿͼֱͬʽC/C++Ĳ裬ϾͿԴһ򵥵ľ鶯
1.6.3߽ײ⣨Bounds Checking and Hit Detection
    ھ鶯У߽ײǳ൱Ҫ񡣱߽ƾķΧ߽ͨRECTṹ
龫λãжϾǷ񳬳޶ķΧ
ײǼǷռͬһλá󲿷ֵײǼľ֮Ƿǡ

DirectDrawϵ
    ýҪܵͼͨDirectDrawMicrosoftʹöͼԵĳٶȺЧ϶GDI˴ߣ
ͬʱֱ豸޹ԣDirectDrawṩĹµĹؼ
	.ʾ
	.ֱӴȡƵڴ
	.ҳת
	.̨
	.ɫĹ
	.
⣬DirectDrawʱѯʾӲȻṩʾ豸ֵܹ֧Чܡ
    DirectDrawṩ˻COMķӿڣʹIDirectDraw2IDirectDrawSurface3IDirectDrawPaletteIDirectDrawClipper
IDirectDrawVideoPortЩӿ⣬DirectDraw֧ǰ汾Ľӿڡ
    DirectDrawʾͨIDirectDrawIDirectDraw2ӿڽʾ䷽ڴ£ʹDirectDrawCreate
һDirectDrawҲʹCOMCoCreateInstance 
DirectDrawԵIDirectDraw2::CreateSurfaceΪö󴴽档ʾӲϵڴ棬ȿƵ
ڴ棬Ҳϵͳڴ档DirectDrawͨĽӿչ˶Եɫ塢мƵ˿ڵ֧֡

1DirectDrawĶ
    DirectDrawȿһĶҲǼϡ°汾DirectDraw͵Ķ
1.1DirectDraw
    DirectDrawDirectDrawӦóĺģ㴴ĵһ󡣴DirectDraw󣬿Ļϴ
صĶ󡣴DirectDrawĺDirectDrawCreate 
1.2DirectDrawSurface
    DirectDrawSurfaceһڴڸݽΪͼʾĻϻƶϡDirectDrawSurface
ķ IDirectDraw2::CreateSurfaceصķͨӿ IDirectDrawSurface, IDirectDrawSurface2IDirectDrawSurface3

1.3DirectDrawPalette
    DirectDrawPaletteʱҲָǡpaletteһڱ16ɫ256ɫɫ壬һϵͬ
صRGBɫֵDirectDrawPaletteķIDirectDraw2::CreatePaletteԴӽӿIDirectDrawPaletteȡķ
1.4DirectDrawClipper
    DirectDrawClipperʱָǡclipperֹĳһλû򳬳λÿдݣDirectDrawClipper
 IDirectDraw2::CreateClipperصķɴӽӿ IDirectDrawClipperлȡ
1.5DirectDrawVideoPort
    DirectDrawVideoPortһЩϵͳֻеƵ˿ӲӲֱӷ֡ҪCPUʹPCIߡ
ָIDDVideoPortContainer־ٵQueryInterface DirectDrawVideoPortصķɴӽӿ
IDDVideoPortContainerIDirectDrawVideoPortлá

2ӲHALHardware Abstraction Layer
    DirectDrawͨӲHALṩ豸޹ԡHALһ豸ӿڣ豸ṩDirectDrawHALֱ
ʾ豸ϹӦó򲢲ͬHAL豸쳧Windows95µ16λ32λʽṩHALWindowsNT£
HAL32λ롣HALʾһ֣Ҳ̶ͨ˽нӿͬʾͨŵĶ̬ӿDLL
DirectDraw HALоƬ忨OEM(Original Equipment Manufacturer)ṩHALֻṩ豸Դ룬ִʱûз档һ
ܲӲ֧֣HALѸùΪӲܵһִ⣬HALԲ֤ʵDirectDrawڵHAL֮ǰɲ
֤ʵ

3棨Software Emulation
    ӲHAL֧ĳһʱDirectDrawͳһԡ÷湦ӲHEL(Hardware-Emulation Layer)
ṩġȻ沢ͬӲеԡIDirectDraw2::GetCapsѯӲֵ֧ԡ
    ʱӲеԺߵĽϱȵʹٶȻҪ磬ʾ豸֧DirectDraw֧
дʽƵڴλ鴫ʱͻϵʧΪƵڴͨϵͳڴٶҪڷƵڴ
ʱCPUҪȴˣӦóʹӲδṩԣϵͳڴд棬ԱCPUƵڴʱ
ʧ

4ϵͳɣSystem Integration
    ͼʾDirectDrawͼ豸ӿGDIӲHALӲHELӲ֮Ĺϵ
 
ͼʾһDirectDrawͬGDIǲйϵ߶ͨ豸سӲͬGDIͬǣDirectDrawֻҪпܾ
ӲṩйܡӲ֧ĳһԣDirectDraw᳢HEL档DirectDrawҲ豸ģDevice 
Contextʽṩڴ棬ܹʹGDI

DirectDrawҪ
    DirectDrawҪЭȼʾģʽDirectDraw󡢱桢ɫ塢аȣԸҪһнܡ
1ЭȼCooperative Level
   ЭȼDirectDrawͬʾЩӰʾ¼ķӦʹIDirectDraw2::SetCooperativeLevel
Эȼڴ£ʹЭȼȷӦóǷڶռȫģʽ򴰿ģʽDirectDrawЭȼ
ã
	.ʹDirectDrawܹʹXģʽMode Xֱʡ
	.ûctrl + alt + delֹDirectDrawͷŶʾĶռƺڶռģʽ£
	.ʹDirectDrawܹ󻯺СӦ¼
    ׼ЭȼָDirectDrawһӦó£㲻ܸıĵɫִҳת⣬㻹
ܵЩʾƵڴӰ̶ȴķ IDirectDraw2::Compactȡ
ȫռЭȼ£ʹӲܣùõɫͶ̬ɫ壬ıʾֱʣڴʵҳתȡȫ
ռģʽֹӦ÷棬ҲֹʹDirectDrawGDIֹӦøıʾֱʺ͵ɫ塣
    ΪӦóڶരʹDirectDrawԵӦҪDDSCL_NORMALģʽʱIDirectDraw2:: SetCooperativeLevel
ҪһָĴھNULLݸھеĴڶͬʱڱ׼ģʽ¡

2ʾģʽDisplay Modes
    ʾģʽǶʾӲ洫͸ʾͼĴСλ(bit-depth)ʾģʽԿ̻Ϊߺλȡ
磬ʾʾ640أ480أÿصɫֵΪ8λͼ󣬸ʾģʽͼΪ640x480x256
ҪõķֱʻλȣҪʾڴ档
    ʾģʽͣɫģʽͷǵɫģʽڵɫʾģʽÿһضһָصɫֵʾģʽλ
˵ɫܹеɫĿ磬8λɫʾģʽÿһضһ0255ֵʾģʽ£ɫ
԰256ɫǵɫʾģʽʹõɫ壬ģʽµλָһصܵλ
    תеκα涼ӦúʾģʽĴСλȺظʽƥ䡣
2.1ֵ֧ʾģʽ
    ΪʾӲĲͬе豸֧еʾģʽҪϵͳֵ֧ʾģʽҪ
IDirectDraw2::EnumDisplayModesͨ趨ʵֵͱ־ IDirectDraw2::EnumDisplayModesгֵ֧ʾģʽ
ҲжǷ֧ĳһָʾģʽ
    ÷ĵһdwFlagsƷѡͨԽdwFlagsΪ0ѡڶlpDDSurfaceDesc
ʾģʽĽṹ DDSURFACEDESCĵַһ㽫ΪNULLгеģʽlpContextһָ룬
DirectDrawҪָ봫ݸصҪڻصжݣɽΪNULLһ
lpEnumModesCallbackDirectDrawÿһֵ֧ʾģʽõĻصĵַ
    ڵIDirectDraw2::EnumDisplayModesʱṩĻصͬEnumModesCallbackԭƥ䡣Ӳֵ֧ÿһ
ʾģʽDirectDrawĻصһDDSURFACEDESCṹĵַýṹһֵ֧ʾģʽ
ڶǵIDirectDraw2::EnumDisplayModesʱָӦöݵĵַ
    ͨDDSURFACEDESCṹֵõʾģʽйؼĳԱdwWidthdwHeightddpfPixelFormatdwWidth
dwHeightʾģʽĴСddpfPixelFormatһDDPIXELFORMATṹйλȵϢ
    DDPIXELFORMATṹʾģʽλȵϢ˵ʾģʽǷʹõɫ塣dwFlagsԱ 
DDPF_PALETTEINDEXED1DDPF_PALETTEINDEXED2DDPF_PALETTEINDEXED4DDPF_PALETTEINDEXED8־ʾģʽ
λȾ1248λÿضһ๫ɫdwFlagsDDPF_RGB־ʾģʽǷǵɫ
ʾģʽλDDPIXELFORMATṹеdwRGBBitCountԱṩ
2.2ʾģʽ
    ԵIDirectDraw2::SetDisplayModeʾģʽ÷ĸʾģʽķֱʵĴСλȺˢ
ʡʹõָģʽѡĿǰ13ģʽXģʽ320x200x8С
    ָõʾģʽλȣָʾӲڸλȵظʽҪʾӲڵǰλȵRGBλ
Σʾģʽ IDirectDraw2::GetDisplayModeǰʾģʽǷǵɫģʽͨdwRBitMask
dwGBitMaskdwBBitMaskеֵýĺ졢̡ɫλ
    㻹ͨӦıʾģʽֻҪǶͬһʾҲԸıλȣֻҪӦóܶռʽطDirectDraw
еDirectDrawSurfaceʾģʽı󶼻ͷűڴ棬ڸʾģʽ֮󣬱ʹ IDirectDrawSurface3::Restore
Ϊڴ档
2.3ָʾģʽ
    ʾģʽͨIDirectDraw2::SetDisplayMode IDirectDraw::SetDisplayModeɵģԵ
IDirectDraw2::RestoreDisplayModeָԭʾģʽӦóǶռʽЭȼ㽫ӦóЭȼر׼
ʱʾģʽͻԶָΪԭģʽʹDirectDrawӿڣʽػָʾģʽ
2.4Xģʽ13ģʽ
    DirectDraw֧Xģʽ13ģʽʾģʽ13ģʽ320x200ÿ8λĵɫģʽ16BIOSģʽΪ13ģʽ
XǴӱ׼VGA 13ģʽĻģʽģʽʹ256KBʾڴ棨13ģʽʵ64KBʾڴ棩
    Windows95£DirectDrawеʾṩXģʽ320x200x8320x240x8һЩʾҲ֧Եͷֱģʽ
ԵͷֱĬĬ£ܹҲֱӷʣXģʽǲġ
   ֻҪӦóIDirectDraw2::SetCooperativeLevelʱʹ DDSCL_ALLOWMODEX,DDSCL_FULLSCREEN
DDSCL_EXCLUSIVE־XģʽͿáûָ DDSCL_ALLOWMODEX־ IDirectDraw2::EnumDisplayModesͲ
гXģʽXģʽʱIDirectDraw2::SetDisplayModeĵþͻʧܡ 
    ӦóXģʽʱʹIDirectDrawSurface3::LockIDirectDrawSurface3::BltдݣҲ
ĻDCGDIʹ IDirectDrawSurface3::GetDCXģʽDDSCAPSιеDDSCAPS_MODEX־ָDDSCAPS
ṹǵIDirectDrawSurface3::GetCapsIDirectDraw2::EnumDisplayModesصDDSURFACEDESCṹеһ֡
2.5߷ֱʺɫ
     DirectDraw֧ʾ豸ֵ֧еĻֱʺλȡDirectDrawӦóıʾģʽһּʾ
ֵ֧ʾģʽ24λ32λɫģʽ
     DirectDrawҲ֧ɫHELλ鴫䡣ʾ豸Щֱ֧λ鴫䣬ʾڴ橤ʾڴλ
佫ʹӲдʽʹHELλ鴫ܡ
     Windows95NTָʹõʾ͡DirectDraw֪ʾģʽбDirectDraw⵽Ҫģʽͬ
ʾݣ IDirectDraw2::SetDisplayModeĵýʧܡ÷IDirectDraw2::EnumDisplayModesʱֻʾ
ֵ֧ģʽŻᱻг

3DirectDraw
     DirectDrawDirectDrawӦóĺģҲDirect3DӦóһлɲ֡DirectDraw㴴ĵһ
ͨöٴضһͨDirectDrawCreateһDirectDraw󣬸úһIDirectDraw
ڡ
     DirectDrawʾ豸ʾ豸֧ӲٹܣDirectDrawӲļٹܡÿһDirectDraw
ܴʾ豸ʹڸDirectDrawı󡢵ɫͼа磬һҪ
IDirectDraw2::CreateSurfaceҪһɫڱϣҪ IDirectDraw2::CreatePalette⣬ IDirectDraw2
ڻƵĴаķ
    ͬʱһDirectDrawĶʵ򵥵Windows95ϵͳʹ˫ʾWindows95Ŀǰֶ֧
ʾΪÿһʾ豸дDirectDrawӲǿܵġWindows95GDIܹʶʾ豸ڴȱʡDirectDraw
ʵʱᱻõWindows95GDIʶʾ豸ܱһDirectDrawöõڶʾ豸ȫ
ͳһʶGUIDGlobally Unique IdentifierGUIDͨDirectDrawEnumerateá
    DirectDrawжȱʡɫ塢Color KeyӲʾģʽѾԴͱԴ
ϱǡ
    °汾DirectDrawǰİ汾µݡIDirectDraw2ӿͨIDirectDraw2::GetAvailableVidMem
IDirectDrawӿڽչ÷ʹܹѯʾ豸ܵĿƵڴ漰жڴ湩һָıʹá
IDirectDraw2::SetCooperativeLevelͬIDirectDraw2::SetDisplayMode֮ĽͬIDirectDrawӿеЩͬӦ
óʹ
    IDirectDrawӿȫռʽЭȼҸıʾģʽر׼ЭȼʱʾģʽԶָ
IDirectDraw::RestoreDisplayModeʽػָʹIDirectDraw2ӿڣRestoreDisplayModeĵþͲǱġȻ
IDirectDraw2::RestoreDisplayMode֧ʽػָԭȵʾģʽ
ΪDirectXĻCOMָһͨµĽӿṩµĹܶӰԡIDirectDraw2ӿھͿ
IDirectDrawӿڡµĽӿڿͨIDirectDraw::QueryInterfaceãC++ʾ
// Create an IDirectDraw2 interface. 
LPDIRECTDRAW  lpDD; 
LPDIRECTDRAW2 lpDD2; 
 
ddrval = DirectDrawCreate(NULL, &lpDD, NULL); 
if(ddrval != DD_OK) 
    return; 
 
ddrval = lpDD->SetCooperativeLevel(hwnd, 
    DDSCL_NORMAL); 
if(ddrval != DD_OK) 
    return; 
 
ddrval = lpDD->QueryInterface(IID_IDirectDraw2, 
    (LPVOID *)&lpDD2); 
if(ddrval != DD_OK) 
    return; 
дһDirectDrawȻIDirectDrawӿڵ IUnknown::QueryInterfaceһIDirectDraw2ӿڡ
    ȡһIDirectDraw2ӿں󣬾ͿԵķԵŵ㡣ΪһЩܻ°汾Ľӿ仯
ʹòͬ汾ĽӿڣIDirectDrawIDirectDraw2ܻᵼ²ԤĴ
3.1ÿһеĶDirectDraw
     DirectDrawһжεDirectDrawCreateÿε֮ÿΨһDirectDraw󶼷һΨһĶ
ĽӿڡÿDirectDraw󶼿裬֮ûϵÿǵڽдһ
    ÿһDirectDraw󴴽DirectDrawSurfaceDirectDrawClipper DirectDrawPalette󶼲ܱDirectDraw
ʹãΪЩ丸DirectDrawʱԶ
    ʹDirectDrawCreateClipperDirectDrawClipperһ⣬µDirectDrawClipper
DirectDrawһDirectDraw
3.2CoCreateInstanceDirectDraw
    ҲԲʹDirectDrawCreateʹCoCreateInstance IDirectDraw2::InitializeDirectDraw
CoCreateInstanceDirectDrawĲ裺
i. ӦóʼʱCoInitializeʼCOM
if (FAILED(CoInitialize(NULL)))
    return FALSE;
ii.   ʹCoCreateInstanceIDirectDraw2::InitializeDirectDraw
ddrval = CoCreateInstance(&CLSID_DirectDraw,
    NULL, CLSCTX_ALL, &IID_IDirectDraw2, &lpdd);
if(!FAILED(ddrval))
    ddrval = IDirectDraw2_Initialize(lpdd, NULL);
    ڶCoCreateInstanceĵУһCLSID_DirectDrawDirectDraw־ IID_IDirectDraw2ָ
ҪDirectDrawӿڣlpddָȡDirectDrawóɹһδʼDirectDraw
    ʹDirectDraw֮ǰIDirectDraw2::Initialize÷ʹGUIDDirectDrawCreateҪֻҪ
DirectDrawʼͿʹҲͷŸö󣬾ͺǸöDirectDrawCreateһڵ
IDirectDraw2::Initialize֮ǰʹͬDirectDrawصķᵼһDDERR_NOTINITIALIZED
    ڹرӦóǰӦʹCoUninitializeرCOMʽ£
CoUnitialize();

4棨Surface
    һDirectDrawSurfaceһڴ򡣱ͨפʾڴУȻҲԴϵͳڴСȷ
ָڴDirectDrawSurfaceʱDirectDrawDirectDrawSurfaceܹܵλáDirectDrawSurface
ʾϵ⴦ԼӿִٶȣͬϵͳCPUдһЩ
    ʹIDirectDraw2::CreateSurfaceԴһı󣬸ӵı淭תάı档ʹCreateSurfaceҪ
ıתһIDirectDrawSurfaceӿڵָ롣
    IDirectDrawSurface3ӿʹܹλ鴫䷽ֱӷڴ棬 IDirectDrawSurface3::BltFastȡһ豸
ģʹGDI⣬ʹIDirectDrawSurface3֮ʾڴ档磬ʹIDirectDrawSurface3::Lock
ʾڴ沢ȡرĵַʾڴĵַָɼڴ棨棩򲻿ɼ򸲸Ǳ棩
ɼͨפʾڴУϵͳڴⴴӲDirectDrawʹ湦ܵĻ⣬
IDirectDrawSurface3ӿչһЩЩܹûȡɫ幤ָͱ档
4.1ӿڣSurface Interface
     DirectDrawSurfaceͨIDirectDrawSurface IDirectDrawSurface2,IDirectDrawSurface3ӿ书ܡÿһ°汾Ľ
ڶͬǰ汾ͬĹܣͨµķṩ˾ɰ汾веĹܡ
IDirectDrawSurfaceӿϸӿϵİ汾ʹIDirectDraw2::CreateSurfaceһʱȱʡṩľһӿڡ
Ҫһ汾ĽӿṩµĹܣ㻹QueryInterfaceѯ°汾ĽӿڡĴʾһģ
LPDIRECTDRAWSURFACE  lpSurf; 
LPDIRECTDRAWSURFACE2 lpSurf2; 
 	 // Create surfaces. 
memset(&ddsd, 0, sizeof(ddsd)); 
ddsd.dwSize = sizeof(ddsd); 
ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT; 
ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | 
    		DDSCAPS_SYSTEMMEMORY; 
ddsd.dwWidth = 10; 
ddsd.dwHeight = 10; 
 	  
ddrval = lpDD2->CreateSurface(&ddsd, &lpSurf,  NULL); 
if(ddrval != DD_OK) 
    	return; 
 
ddrval = lpSurf->QueryInterface( 
    		IID_IDirectDrawSurface2, (LPVOID *)&lpSurf2); 
if(ddrval != DD_OK) 
    	return; 
 
ddrval = lpSurf2->PageLock(0); 
if(ddrval != DD_OK) 
    		return; 
 
ddrval = lpSurf2->PageUnlock(0); 
if(ddrval != DD_OK) 
    		return; 
 
    ڵQueryInterfaceʱָͨIID_IDirectDraw2־DirectDrawSurfaceIDirectDrawSurface2ӿڡҪ
õ IDirectDrawSurface3ӿڣIID_IDirectDrawSurface3־IID_IDirectDraw2ɡ
4.2Color Key
    DirectDraw֧λ鴫͸Ǳ淽ʽµԴColor KeyĿColor KeyͨIDirectDrawSurface3::SetColorKeyñ
Color Keyʹλ鴫ʱԴColor Keyָ˲ɫɫΧĿColor Keyָ˱滻ɫɫΧ
    һЩӲֻ֧YUVظʽɫΧYUVͨƵݣ͸תеܲһֵһɫ
    Color KeyñظʽָǵɫʽģColor KeyͱָΪķΧظʽYUV
ʽFOURCCָYUVColor KeyDDCOLORKEYṹеԱdwColorSpaceLowValuedwColorSpaceHighValue
ָֽֽڷֱVUYݡIDirectDrawSurface3::SetColorKeyеdwFlagsָColor KeyǷڸǻ
λ鴫ǷһԴColor KeyĿColor KeyĴЧColor KeyһЩʵ
// 8λɫģʽ
// ɫʵ26 color key. 
dwColorSpaceLowValue = 26; 
dwColorSpaceHighValue = 26; 
 
// 24λģʽ
// ɫ255128128color key. 
dwColorSpaceLowValue = RGBQUAD(255,128,128); 
dwColorSpaceHighValue = RGBQUAD(255,128,128); 
 
// FourCC YUVģʽ
// Any YUV color where Y is between 100 and 110 
// and U or V is between 50 and 55 is transparent. 
dwColorSpaceLowValue = YUVQUAD(100,50,50); 
dwColorSpaceHighValue = YUVQUAD(110,55,55); 

4.3ظʽPixel Format
    ظʽָκζԱڴÿ͡DirectDrawʹDDPIXELFORMATṹϢ
DDPIXELFORMATṹĳԱظʽԣ
	.ɫǵɫظʽ
	.ǷǵɫʽظʽRGBYUVʽ
	.λ
	.ظʽɲֵλ
ԵIDirectDrawSurface3::GetPixelFormatȡڵıظʽ
4.4
    DirectDrawSurfaceפʾڴеһ档ʾڴ˻ʽشñҲɴϵͳڴС
ʹIDirectDraw2::CreateSurfaceһ档CreateSurfaceʱָĴСͣǵһ滹
Ǹӱ棩ظʽ治ʹĵɫ壩еЩԶDDSURFACEDESCṹУڵʱҪýṹ
ַ͹ȥӲ֧ԻߴǰѾЩԴһDirectDrawSurface󣬵þͻʧܡ
    һıֻҪм򵥵Ĵ롣ĸҪĲ衣ÿһ趼Ҫǰһ׼
̫ѣǣ
	(1).	
	(2).	һ
	(3).	ӱͷת
	(4).	
    ȱʡ£DirectDrawڱƵڴ洴һ棬㹻ıƵڴ汣ñ棬DirectDrawͳ÷ǱƵ
ڴ棨һЩAGP豸ϵͳУڵCreateSurfaceʱDDSCAPSṹʵı־ʽָڴд档
4.4.1
    ǵǰʾϿɼĲDDSCAPS_PRIMARYSURFACE־ָı棬ÿһDirectDrawֻһ档
㴴һʱСӦͬǰʾģʽƥ䡣ˣ㲻ҪָĴСʵϣָ˱
Сʹͬǰʾģʽƥ䣬Ҳᵼ´̵ʧܡ
    ʾDDSURFACEDESCṹسԱ棺
DDSURFACEDESC ddsd; 
ddsd.dwSize = sizeof(ddsd); 
 		// Tell DirectDraw which members are valid. 
ddsd.dwFlags = DDSD_CAPS; 
    // Request a primary surface. 
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE; 
 
4.4.2
    ͨλͼĻ棬λͼλ鴫䵽̨С趨DDSC_WIDTHDDSD_HEIGHT
־趨dwWidthdwHeightԱ Ϊʵֵ˵ĴС⣬DDSCAPSṹаDDSCAPS_OFFSCREENPLAIN
־
    û㹻ʾڴʹʱDirectDrawʹϵͳڴ档DDSCAPSṹеdwCapsԱ
DDSCAPS_SYSTEMMEMORY DDSCAPS_VIDEOMEMORY־ʽָʾڴ滹ϵͳڴд档
ʾ˴һ֮ǰ׼
DDSURFACEDESC ddsd; 
ddsd.dwSize = sizeof(ddsd); 
 	
// Tell DirectDraw which members are valid. 
ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH; 
 	
// Request a simple off-screen surface, sized 
// 100 by 100 pixels. 
ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN; 
dwHeight = 100; 
dwWidth = 100; 
    DirectXǰİ汾УȲܳĿȡDirectX 5УԴȵ棬ֻҪʾ
ָСҪעǣĿʱʾڴݲıĿȣñ潫ϵͳڴд
ʽʹƵڴ棬ƵڴֲʱĹͻʧܡ
4.4.3ӱ棨Complex SurfaceͷתFlipping Chain
    һӱIDirectDraw2::CreateSurfaceһ鵥һϡڵCreateSurfaceʱ趨
DDSCAPS_COMPLEX־ʽָı⣬DirectDrawʽشһ档һһӱ
档IDirectDraw::Releaseͷеı棬IDirectDrawSurface3::RestoreὫЩָ
    õĸӱǷתͨһתһһ̨ɡDDSCAPS_FLIP־˵ĳһ
һתһְ֡취һתҪDDSCAPS_COMPLEX־Ӵһ淭תҪ׼
DDSURFACEDESC ddsd; 
ddsd.dwSize = sizeof(ddsd); 
 
// Tell DirectDraw which members are valid. 
ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT; 
 	
// Request a primary surface with a single 
// back buffer 
ddsd.ddsCaps.dwCaps = DDSCAPS_COMPLEX | DDSCAPS_FLIP | 
DDSCAPS_PRIMARYSURFACE; 
ddsd.dwBackBufferCount = 1;
    һ˫巭תIDirectDrawSurface3::Flipͺ̨ıڴ档DDSURFACEDESC
ṹеĳԱdwBackBufferCountȡֵΪ2ͻᴴ̨ÿεFlipͻѭطת棬ṩ巭ת
4.4.4棨Wide Surface
    DirectDraw棬ȻҪʾӲֲ֧СҪȷʾ豸Ƿֿ֧棬Ҫ
IDirectDraw2::GetCaps鿴һDDCAPSṹеdwCaps2ԱǷDDCAPS2_WIDESURFACES־ñ־ڣ
ͱƵڴд滹Ҫ档ñ־ڣƵڴд潫ʧܣһ
DDERR_INVALIDPARAMS
ϵͳڴ桢Ƶ˿ڱִлֿ֧档
4.4.5ת棨Flipping Surface
    DirectDrawеκα涼ԹΪһת档һתܹǰ̨front bufferͺ̨back buffer
֮以ཻһڴ档ͨǰ̨棬ⲢǱġ
ʹIDirectDrawSurface3::Flipִб淭תʱָıڴָͺ̨ıڴָ뻥ˣ
תʾ豸ָڴָĽǶԱڴĿΨһǣDirectDraw淭תʱֻǼ򵥵ؿ
档һ̨װ뵽ʾڴлӲ֧DirectDrawʱDirectDraw淭תһתһ
Ͷ̨ʱָתͲѭķʽܶʼͼʾ
 
    DirectDrawӱ治Ƿתһ֣FlipӰ졣мǣDirectDrawתͨDirectDrawSurface
ڴָʵֵģǽЩζţλ鴫䵽̨ʱһֱʹͬһDirectDrawSurface
û㴴תĺָ̨תһֱͨǰ̨Flipɵġ
4.4.6ʧ棨Losing Surface
    ڴDirectDrawSurface󲻱Ҫͷʱͬñıڴȴͷˡʧȥ˱档DirectDrawSurface
ıڴʱ෽ͲִĲDDERR_SURFACELOST
ΪıʾģʽһӦû˶ʾ豸Ķռʶͷ˵ǰбڴ棬Ϳܻᶪʧ
IDirectDrawSurface3::Restore´Щʧı沢ͬDirectDrawSurfaceᡣָ沢װ涪ʧ֮ǰڵλ
ͼˣʧı棬ȫװǰװͼΡ
4.4.7ͷű棨Releasing Surface
    еCOMӿһҪʱReleaseͷű档ÿһı涼ʽͷšһε
 IDirectDraw2::CreateSurfaceIDirectDraw::CreateSurfaceʽشĶ棨緭תȣֻҪͷǰ̨ɡ
£ָ̨κָ붼ʽͷţҲá
4.4.8±Updating Surface Characteristics
    ʹIDirectDrawSurface3::SetSurfaceDescбø÷ԸıظʽҲԸıDirectDrawSurface
ıڴϵͳڴеλãöӦóʽطġһֱʹǰĻеݶҪ
һµıڴɿͻӦ䣬ҲɸÿͻӦͷš
     IDirectDrawSurface3::SetSurfaceDescʱlpddsdµıڴĽṹDDSURFACEDESCĵַҲָ
ڴַָ롣DDSURFACEDESCṹУֻ趨dwFlagsԱӳڴλáСظʽdwFlagsֻ
DDSD_WIDTHDDSD_HEIGHTDDSD_PITCHDDSD_LPSURFACEDDSD_PIXELFORMATȱ־ϣЩ趨
ЧĽṹԱ
    ýṹֵǰڴװ档ڴĴСǳҪ 㲻Ҫ㹻ڴɱĿ͸ߣ
ҪΪ(pitch)㹻ڴռ䣬һQWORD8ֽڣø߶ȶضġ
    ýṹбֵʱlpSurfaceԱڴָ룬 dwHeightdwWidthԱصλ˱ĴСָ
ĴСҲҪIpitchԱӳࡣddpfPixelFormatԱ˱ظʽlpSurfaceԱ⣬㲻ΪЩ
Ա趨ֵIDirectDrawSurface3::SetSurfaceDescʹӵǰıʹȱʡֵ
ڵIDirectDrawSurface3::SetSurfaceDescʱҪעһЩ⡣磬lpSurfaceϵͳڴһЧָ루÷Ŀǰ֧
Ƶڴָ룩dwWidthdwHeightǷ0ֵת·档
    ΪDirectDrawSurfaceͬһڴ棬ע⵱ڴ󣬾ͲȡԸڴķ䡣
SetSurfaceDescȷʹûᵼ²ԤϵķӦˣҪڴʱסͷڵø÷ʱDirectDraw
ͷŴʱʽıڴ档
4.4.9ֱӷ֡Accessing the Frame-Buffer Directly
    ʹIDirectDrawSurface3::Lockֱӷ֡ϵͳڴеıڴ档ø÷ʱlpDestRectһRECT
ṹָ롣ýṹҪֱӷʵıϵľΡ棬ɽlpDestRectΪNULLҲָһֻ˱
һֵRECTûص̿ͬʱһеĶΡ
    LockҪʵطʱڴϢDDSURFACEDESCṹýṹйرظʽϢͬ
ظʽͬʱ˶Աķʺ󣬵IDirectDrawSurface3::Unlockн
4.4.10ʹ÷ǱƵڴ棨Using Non-local Video Memory Surfaces
    DirectDrawָ֧߼ͼζ˿AGPAdvanced Graphics PortԣܹڷǱƵڴд档AGPϵͳУ
ƵڴӦóʽҪʹ÷Ǳڴ棬DirectDrawʹ÷ǱƵڴ洴档
    ĿǰAGPϵһǡִģ͡Execute ModelһǡDMAģ͡Direct Memory Access ModelִģУ
ʾ豸ַ֧ǱƵڴͱƵڴͬԡˣʹ IDirectDraw2::GetCapsȡӲʱͬλ鴫
ı־dwNLVBCapsdwNLVBCaps2dwNLVBCKeyCapsdwNLVBFXCapsdwNLVBRopsָڱƵڴ档ִģʽ£
Ƶڴ汻ˣDirectDrawԶʹ÷ǱƵڴ档
    DMAģУԴӷǱƵڴλ鴫ͼ֧޵ġʾ豸ʹDMAģʱӲܣ
dwCapsԱΪDDCAPS2_NONLOCALVIDMEMCAPS־ͬλ鴫صı־dwNLVBCapsdwNLVBCaps2
dwNLVBCKeyCapsdwNLVBFXCapsdwNLVBRopsȳԱСʽָDirectDrawʹ÷ǱƵڴ洴档DMA
ģ͵ʵڶԷǱƵڴ֧ǲͬġִ֧ӷǱƵڴͼIDirect3DDevice2::GetCaps
ȡ3D豸ʱD3DDEVCAPS_TEXTURENONLOCALVIDMEM־趨
4.4.11תɫ͸ʽConverting Color and Format
    RGBʽĸַĴ루FOURCC codesʾӦóIDirectDrawSurface3::GetPixelFormatҪʹ
ظʽұһRGB棬 DDPF_FOURCC־ͻ趨DDPIXELFORMATṹеĳԱdwFourCCΪЧġ
FOURCCʾһYUVʽDDPF_YUV־趨dwYUVBitCountdwYBitsdwUBitsdwVBitsdwYUVAlphaBits
ԱЧ룬ڴȡϢ
    ǰRGBʽDDPF_RGB־ͻᱻ趨dwRGBBitCountdwRBitsdwGBitsdwBBitsdwRGBAlphaBitsԱ
ڴǰϢЧ롣
ɫ͸ʽתУFOURCCӦóСһӲλ鴫һӲǵ
4.4.12Ǳ棨Overlay Surfaces
    ǱǾӲ֧ı棬ͨʾƵ¼ƵֹλͼҪλ鴫䵽ı
ݡԸǱִȫӲṩDirectDraw֧ʾ豸ֵ֧ԣDirectDraw渲Ǳ档ԽǱ
ΪһƬֽǿƬϻͼɽʾǰ档ֽʾǰʱԿǺ棬ȥ
ֽ沢ûиı䡣ǱĹԭͬ͸ֽǵԭơʾһǱʱǸ豸
ʹǱɼʾ豸ɨػʾʱϵÿһأǷ񱻸档ǣʾ豸ʹ
Ǳгȡص
    ʹַʾ俨ʾ͸Ǳĺϳɱ棬 ͸ЧҪıÿݡϳ
汻Ƶֱ͵ʾΪִӲĲԲԵʧ⣬ַʹ
òͬظʽ޷غϳ͸Ǳ档
ǱҪDDSCAPSṹָ DDSCAPS_OVERLAY־ȻIDirectDraw2::CreateSurfaceǱֻ֧
д˻DDSCAPS_VIDEOMEMORY־ͬ͵ıһͨʵı־ һĸǱ棬
ҲԴɶɵķת
    ԵIDirectDraw2::GetCapsȡйֵ֧ĸԵϢ÷еϢһDDCAPSṹ
Ӳʱ豸dwCapsԱı־ָʱǿִӲṩĳ͵Լõͨ
dwCapsԱı־֪ṩԼϢDDCAPSṹ9Ա9Ա˸ǱԼϢ±гͬ
صĳԱǵı־
	
Ա
־
dwMaxVisibleOverlays
óԱʼЧ
dwCurrVisibleOverlays
óԱʼЧ
dwAlignBoundarySrc
DDCAPS_ALIGNBOUNDARYSRC
dwAlignSizeSrc
DDCAPS_ALIGNSIZESRC
dwAlignBoundaryDest
DDCAPS_ALIGNBOUNDARYDES
T
dwAlignSizeDest
DDCAPS_ALIGNSIZEDEST
dwMinOverlayStretch
DDCAPS_OVERLAYSTRETCH
dwMaxOverlayStretch
DDCAPS_OVERLAYSTRETCH

    dwMaxVisibleOverlaysdwCurrVisibleOverlaysԱָӲʾĸǵĿԼǰжٸɼ
dwAlignBoundarySrcdwAlignSizeSrcdwAlignBoundaryDestdwAlignSizeDestdwAlignStrideAlignԱӲľελúʹС
ԼЩԱֵָʾǱʱȷԴκĿľεĴСλá
dwMinOverlayStretchdwMaxOverlayStretchйӵϢ
aԴκĿľΣSource and Destination Rectangles
    ҪʾһǱ棬IDirectDrawSurface3::UpdateOverlaydwFlags ָ DDOVER_SHOW־÷Ҫ
lpSrcRectlpDestRectָһԴκĿľΡʹ棬lpSrcRectΪNULLɡĿľ
Ǳλá
   ԴĿľβشСͬһĿľαԴδһЩСһЩԣӲʾʱԶѹ졣Ҫɹʾһ
Ǳ棬ҪԴĿľεĴСλãһǷҪ豸ơ
b߽ʹСBoundary and Size Alignment
    ڲͬӲƣһЩ豸ʾǱԴκĿľεĴСλԼҪҳ豸ӦõԼ
IDirectDraw2::GetCapsȻDDCAPSṹͬصdwCapsԱı־±гָ߽ʹСԼĳԱ
ͱ־


־
Ա
߽Լ
DDCAPS_ALIGNBOUNDARYSRC
dwAlignBoundarySrc

DDCAPS_ALIGNBOUNDARYDEST
dwAlignBoundaryDest
СԼ
DDCAPS_ALIGNSIZESRC
dwAlignSizeSrc

DDCAPS_ALIGNSIZEDEST
dwAlignSizeDest

Լ֣߽ԼʹСԼԼصķʽʾܹԴκĿľΡȻڸǱ
ʽĲͬЩԼҲԲһ
    ߽ԼӰԴκĿľηõλádwAlignBoundarySrcdwAlignBoundaryDestԱֵεؾεϽǡ
ϽǵX꣨RECTṹеleftԱǱֵ
СԼӰԴκĿľεЧȡdwAlignSizeSrcdwAlignSizeDestԱֵصĸʽָؾεĿ
һСΣӦȷľȻǴСġ֮ͨԲȣͿԱС
ӡ 
cСӣMinimum and Maximum Stretch Factors
    ӲľԣһЩ豸ĿľͬصԴοȵıȽϡDirectDrawЩԼΪӡһӾԴ
ͬĿľεĿ֮ıʡṩйӵϢڵ IDirectDraw2::GetCaps ʱDDCAPSṹ
 DDCAPS_OVERLAYSTRETCH־ע⣬ӶѾ1000ֵΪ1300ʵ1.3
    ѹ츲Ŀľε豸Сͨ0
    СָĿľαԴοٻխ١СӴ1000ͱĿľεĿȡ磬Ϊ
1300ĿľεĿӦԴοȵ1.3С1000ĿľξͱԴεĿҪСĿ
ܹ磬2000ĿľεĿԴοȵ2С1000
ĿľξҪѹ֮Ŀľα豸ҪκδСԼˣڴС֮ǰĿľΡӲ
ҪĿľεĸ߶ȡӾεĸ߶ַʵĲ䡣
dColor Key
    ͵ıһǱҲʹԴĿColor KeyƱ֮͸λ鴫ΪǱʾͨλ
ɵģڵIDirectDrawSurface3::UpdateOverlayʱҪȡͬİ취ƸǱʾϵķʽ𰸾
ǸColor Keyͬλ鴫صColor KeyƣColor KeyҲԴColor KeyĿColor Keyͨ÷
IDirectDrawSurface3::SetColorKeyDDCKEY_DESTOVERLAY־ԴColor KeyĿColor KeyǱܹλ鴫
Color Keyһλ鴫͸ʾֲͬ͵Color Keyͻ
    IDirectDrawSurface3::UpdateOverlayԴColor Key鸲ǱĸӦ͸ģ͸Ǳʾͬ
÷ʹĿĸColor KeyȷʾʱĲǱǣʾЧͬλ鴫Color Keyͬ
e λǱ棨Positioning Overlay Surfaces
    ȵIDirectDrawSurface3::UpdateOverlayʾһʱ÷ IDirectDrawSurface3::SetOverlayPositionĿ
ΡȷָĿľελر߽Լ IDirectDraw2::SetOverlayPositionִмйʹ˿
Խʹø÷ʧܣ DDERR_INVALIDPOSITION
fǱ棨Creating Overlay Surfaces
    еıһԵIDirectDraw2::CreateSurfaceһǱ档Ǳ滹ҪصĽṹDDSCAPS 
 DDSCAPS_OVERLAY־֧ʾ豸˲жһظʽǷ񱻴֧֣
׼ʹܹ֮ڶظʽԵ IDirectDraw2::GetFourCCCodesֵ֧йطRGBʽϢҪ
һǱ棬ʹõظʽظʽ֧֣DirectDrawʹʾ豸ֵ֧ظʽǱ
淭תҲġ
gתǱ棨Flipping Overlay Surfaces
    ͬ͵ıһԴǱ淭תһ˸ǵķתͿԵ÷IDirectDrawSurface3::FlipתЩ
ǡѹڵFlipʾǱʱʹDDFLIP_ODD DDFLIP_EVEN־Լ˶֧橤ż
תڻDDCAPS2_CANFLIPODDEVEN־DDCAPSṹ趨һ趨
DDCAPS2_CANFLIPODDEVENͿڵIDirectDrawSurface3::UpdateOverlayʱDDOVER_BOB־֪ͨʹáBob
㷨С˶󡣴˺DDFLIP_ODD DDFLIP_EVEN־Flipʱ򽫻ԶǵԴֲ
ȡӲûDDCAPS2_CANFLIPODDEVEN־ڵUpdateOverlayʱʹ
DDOVER_BOB־ôõýʧܡ

5ɫ壨Palette
    ɫҪеɫȷʾһɫ棨ɫ꣩һЩֵļ򵥼ϣÿÿֶһ
ءֵֵһɫDirectDrawʾÿʱʹʲôɫDirectDrawPaletteͨΪɫ壬ṩ
˹ɫļ򵥷ʹ16λλظʽı治ʹõɫ塣
     DirectDrawPalette˾2416256ʵɫɫɫеÿʵ嶼һRGBԪ
飬ʾʹõɫɫ԰16λ24λRGBԪõɫ16ɫĵɫ壬ɫҲ
һ256ɫĵɫɫӦ͸ǱУǶҪкͬĵɫ塣
ԵIDirectDraw2::CreatePaletteһɫ壬÷ȡõɫIDirectDrawPaletteӿڵָ롣ȻͿøý
ڵķɫʵ壬ȡйضϢʼɫCOMCoCreateInstanceģ
    IDirectDrawSurface3::SetPaletteɽһɫ帽һϡһһĵɫӦõϡDirectDrawPalette
8λĵɫ屣ʵ0ʵ255ָ DDPCAPS_ALLOW256־Ҫʵá
IDirectDrawPalette::GetEntriesõɫʵ壬IDirectDrawPalette::SetEntries޸ĵɫʵ塣
5.1ɫ
    DirectDraw֧1λ2λ4λ8λĵɫ塣һɫֻܸͬظʽı档磬һDDPCAPS_1BIT־
2ʵɫֻܸ DDPF_PALETTEINDEXED1־1λ档⣬ҲԴȫɫĵɫ壬
ɫ塣ͬɫͬǣɫֵЩֵһɫɫλá
    Ҫһɫ壬IDirectDraw2::CreatePaletteָ DDPCAPS_8BITENTRIES־磬Ҫһ4λɫ壬
ҪָDDPCAPS_4BITDDPCAPS_8BITENTRIES־ɫʱҪһָ봫ݸֽ顣
5.2÷ϵĵɫ壨Setting Palettes on Nonprimary Surfaces
    ɫܹĵɫ棨棬̨ͼϣֻиϵĵɫӰϵͳɫ塣
עǣDirectDrawλ鴫䲻ִɫ任κθλ鴫ԴĿı涼ԡϵĵɫҪ
Direct3DӦó
5.3ɫ壨Sharing Palettes
    ɫڶ֮乲ͬһɫԸһתǰ̨ͺ̨ҲԹڶ档ʹ
IDirectDrawSurface3::SetPaletteһɫ帽һʱñͻӸõɫֵֵﵽ0ʱñ
ͻٸŵĵɫֵ⣬һɫͬһ뿪ñĵɫֵҲ١
5.4ɫ嶯Palette Animation  
    ɫ嶯ָʾʱͨıĵɫı۵Ĺ̡ظظıɫ壬濴Ǹıˣʵϣ
ʵݲޱ仯ˣɫ嶯ṩһָıʾֶıľݵķֱʽĵɫ嶯
ṩְ취
   i.	ڵһĵɫ޸ĵɫʵ
   ii.	ڶɫ֮л  
ʹǰһַԸı䵢ɫЩɫʵ壬Ȼ IDirectDrawPalette::SetEntriesһθλЩʵ塣ڶַ
Ҫ2DirectDrawPaletteȻIDirectDrawSurface3::SetPaletteһһĵɫ󸽸Ӷ
ַͬӲ޹أʹַҪǿǷʺӦó

6а壨Clipper
    аDirectDrawClipperλ鴫䵽ѡĲ֡һаκһабһаб
һнλ򼸸нУǱλ鴫䵽һ򼸿ЩRECTṹĻķʽʾ
    бһǳõĹߣõǽֹӦóݿдĻ߽ĵط磬ҪʾһĻ
룬㲻ϣһӾ͵ĻϣƽĻ߽һһƶĻ롣ûма󣬾Ҫ
λԱڴ߼ͼʾһļС
 
     ʹüа֥һĿľεһǿдģDirectDrawЩλ鴫ԼԱָļо
֮ءּзʽͼʾ
 
6.1бClip List
     DirectDrawDirectDrawClipperбһбɼһϵоΡһDirectDrawClipper
Ըκα֮ϡһھҲԸDirectDrawClipperϣ£DirectDrawʹôиµļб
޸DirectDrawClipperб
    DirectDraw HALмбɼDirectDrawҲֻþλ鴫ʱŵHALбҪ磬һ
ϽǾαеˣӦó򽫸ñдʱDirectDrawʹHALִλ鴫һǴϽǣ
ڶβǴ°벿֡
    ͨ IDirectDrawClipper::SetClipListԽб͸ּ֧УǶε
⣬ָͨĿĴڵľ IDirectDrawClipper::SetHWndа赽һһĴڡֻеӲּ֧л
ĿColor KeyûбʱǱּ֧йܡ
6.1DirectDrawClipper
    DirectDrawClipperڶ֮乲磬ͬһDirectDrawClipperͬʱڷתǰ̨ͺ̨Ӧ
IDirectDrawSurface3::SetClipperһDirectDrawClipperһʱαӸöֵһ
DirectDrawClipperͬһ棨ñIDirectDrawSurface3::SetClipperһռаӿָ봴ģ룬ñ
DirectDrawClipperֵͻݼ
6.3ļа
    ԴһֱӴκһDirectDrawDirectDrawClipperּаڶDirectDraw֮乲
ԵļаµDirectDrawDirectDrawCreateClipperӦóڴκDirectDraw֮ǰ
ú
    ΪDirectDrawӵЩDirectDrawClipperԵӦеĶͷźЩDirectDrawClipper󲢲
ͷšӦóûʽͷЩаDirectDrawڳʱͷǡ
Ȼ㻹ǿ IDirectDraw2::CreateClipperDirectDrawClipperַļаصDirectDraw
ͷźԶͷš
6.4COMDirectDrawClipper
    DirectDrawClipperȫ֧COMӦáʹñ׼IDirectDraw2::CreateClipperDirectDrawCreateClipper⣬
COM CoGetClassObject аCoCreateInstanceIDirectDrawClipper::Initializeа
ʵ
 ddrval = CoCreateInstance(&CLSID_DirectDrawClipper, 
    NULL, CLSCTX_ALL, &IID_IDirectDrawClipper, &lpClipper); 
if (!FAILED(ddrval)) 
    ddrval = IDirectDrawClipper_Initialize(lpClipper,lpDD, 0UL); 
     ڶCoCreateInstanceĵУһCLSID_DirectDrawClipperǼа־ IID_IDirectDrawClipper
˵ǰֵ֧ĽӿڣlpClipperǼаָ롣
    ӦóʹIDirectDrawClipper::Initializeʼа 0ULdwFlagsֵбʾûʹκα
־lpDDӵиüаDirectDrawNULLlpDDᴴһDirectDrawClipperҲȼ
DirectDrawCreateClipperļа󡣹رӦó֮ǰӦCoUninitializeرCOM
    DirectDrawͨΪûṩһʹķʹҳתȫռģʽӦóΨһѡһֹʵ
Ĺ꣬DirectInput豸лȡݻ򴰿ڵϢƶ顣κβʹҳתӦóҲʹϵͳ
֧֡
    ʹϵͳʱڿдһʱܻͼλ鴫УаԷֹЩĳ֡
ӦУIDirectDraw2::CreateClipperа IDirectDrawClipper::SetHWndӦõľа塣һ
а帽ˣκIDirectDrawSurface3::Bltʵֵλ鴫Ĳ
    ԽһадڡҪһֻһDirectDrawȻ󴴽һа 
IDirectDrawSurface3::SetClipperа䵽档ҪдڵĿͻclient areaҪڿд֮ǰ
IDirectDrawClipper::SetHWndа赽ڵĿͻҪдһڵĿͻ򣬾Ŀ괰ڵľٵ
IDirectDrawClipper::SetHWndһΡ

ġDirectDraw߼
1ֱڴDMA
    Щʾ豸ܹϵͳڴ֧λ鴫ЩֱڴDMADirect Memory Access 
DMA֧һĲ磬豸Դϵͳڴλ鴫䵽Ƶڴϣͬʱ׼һ֡
档
    ʹDMA֮ǰ豸Ƿ֧DMAֵ֧ĳ̶ȡ IDirectDraw2::GetCapsȡ豸Ȼ
ٲ鿴 DDCAPSṹеdwCapsԱǷDDCAPS_CANBLTSYSMEM־豸֧DMA
    豸֧DMAҪֵ֪֧ġҪ鿴йصĽṹԱЩԱйϵͳڴ桪Ƶڴ桢
Ƶڴ桪ϵͳڴϵͳڴ桪ϵͳڴ֮λ鴫ϢDDCAPSṹļԱṩЩϢ±ʾ
System-to-video
Video-to-system
System-to-system
   dwSVBCaps
   dwVSBCaps
   dwSSBCaps 
   dwSVBCKeyCaps
   dwVSBCKeyCaps
   dwSSBCKeyCaps 
   dwSVBFXCaps
   dwVSBFXCaps
   dwSSBFXCaps 
   dwSVBRops
   dwVSBRops
   dwSSBRops 

    磬ϵͳڴ浽Ƶڴλ鴫ܱ־dwSVBCapsdwSVBCKeyCapsdwSVBFXCapsdwSVBRopsṩƵڴ
ϵͳڴλ鴫ܱ־ԡdwVSBͷĳԱУϵͳڴ浽ϵͳڴ֮λ鴫ܱ־ԡdwSSBͷ
ĳԱС
    ЩԱؼǶ첽DMAλ鴫ֱ֧֧֡첽DMAλ鴫DDCAPS_BLTQUEUE 
־dwSVBCapsdwVSBCapsdwSSBCapsԱСñ־ڣͱ֧첽DMAλ鴫
    ϵͳڴ浽Ƶڴ֮SRCCOPYӲֵ֧λ鴫ˣֲ͵ӦǴϵͳڴ潫
ƶƵڴ档ϵͳڴ浽ƵڴDMAԼͬƵĴٶһ죬иŵ㣬ΪЩͬ
С
    ӲʹڴַڴַĳЩ豸Ҫṩڴַûͨ
IDirectDrawSurface3::PageLockĵɵġ豸ҪҳIDirectDraw2::GetCapsȡӲʱ
DDCAPS2_NOPAGELOCKREQUIRED־ 趨
    ҳһԷֹϵͳڴãұָñڴ治䣬ֱIDirectDrawSurface3::PageUnlock
Ϊֹ豸ҳDirectDrawֻDMAӦóѾҳ˵ϵͳڴϡû
еIDirectDrawSurface3::PageLockDirectDrawִд乤Ҫעǣı֮󽫻󽵵Windows
еЧʡˣֻȫռģʽ´϶ϵͳڴ棬ҵӦóСʱܹЩнȻӦó
ָӦ¶ϵͳڴҳ

2ڴģʽʹDirectDrawɫ
    ʾȫռʽʱIDirectDrawPaletteӿڷֱдӲġʾڴģʽʱIDirectDrawPaletteӿڷGDI
ɫ崦ʹWindowsӦóгعһ
2.1ģʽµɫʵ
   ͬȫռʽӦóһģʽӦóͬӦóɫ塣ͬ DirectDrawPaletteGDIһ
ͬPALETTEENTRY ṹһpeFlagsԱóԱϵͳӦPALETTEENTRYṹϢpeFlagsԱ
͵ĵɫʵ塣
2.1.1ھ̬ʵ
    ڱ׼ģʽ£Windowsɫʵ09ʵ246255ϵͳɫʾ˵˵ıʹڱ߽ȵȡΪʹӦó
򱣳һµۣƻӦó۱֣ҪЩĵɫʵ塣ͨԱԵWin32
GetSystemPaletteEntriesȡϵͳɫ壬ȻʽԶɫ趨ͬĵɫ壬ʹ֮ڷǰͬϵͳɫƥ䡣
ϵͳɫʵ帴ƵԶɫʼҲԹûıɫɫʱԶɫͻЧ
    Ϊ˱ûıɫɫɫЧܲṩһϵͳɫָɫֵӶʵʵ塣
ϵͳʵʹʲôɫɫ嶼ʼƥ䣬Ҫκθ¹ peFlagsԱPC_EXPLICIT־ʹ
ֱܹһϵͳɫʵ塣ʹһ־ϵͳͲΪṹԱɫϢԽpeRedԱֵ
ΪҪϵͳɫɫΪ0磬뱣֤ĵɫеʵʵͬϵͳɫɫɫƥ䣬ʹ
´룺
// Set the first and last 10 entries to match the system palette.
PALETTEENTRY pe[256];
ZeroMemory(pe, sizeof(pe));
for(int i=0;i<10;i++){
    pe[i].peFlags  = pe[i+246].peFlags = PC_EXPLICIT;
    pe[i].peRed = i;
    pe[i+246].peRed = i+246;
} 
 
    ԵWin32SetSystemPaletteUseǿWindowsֻʹõһһɫʵ0255£Ӧ
PALETTEENTRYṹֻʵ0255ΪPC_EXPLICIT
2.1.2˶ʵ壨Animated entries
    PALETTEENTRYṹʹPC_RESERVED־ָ˶ǵɫʵ塣WindowsӦóԼ
߼ɫʵӳ䵽ָɫʵ壬ӶӦó˶ɫʱӦóıǵɫ
2.1.3˶ʵ壨Nonanimated entries
    PALETTEENTRYṹʹPC_NOCOLLAPSE־ָ˶ɫʵ塣PC_NOCOLLAPSE־֪ͨWindows
˵ĵɫʵ÷˶ʵ塣
2.2ڴģʽ´ɫ
  ڷǶռģʽ´DirectDrawɫӡΪʹɫܹĹύ IDirectDraw2::CreatePalette
PALETTEENTRYṹн256ʵ嶼úá
LPDIRECTDRAW        lpDD; // Assumed to be initialized previously 
PALETTEENTRY        pPaletteEntry[256]; 
int                 index; 
HRESULT             ddrval; 
LPDIRECTDRAWPALETTE lpDDPal; 
 
// First set up the Windows static entries. 
for (index = 0; index < 10 ; index++) 
{ 
    // The first 10 static entries: 
    pPaletteEntry[index].peFlags = PC_EXPLICIT; 
    pPaletteEntry[index].peRed = index; 
    pPaletteEntry[index].peGreen = 0; 
    pPaletteEntry[index].peBlue = 0; 
 
    // The last 10 static entries: 
    pPaletteEntry[index+246].peFlags = PC_EXPLICIT; 
    pPaletteEntry[index+246].peRed = index+246; 
    pPaletteEntry[index+246].peGreen = 0; 
    pPaletteEntry[index+246].peBlue = 0; 
} 
 
// Now set up private entries. In this example, the first 16 
// available entries are animated. 
for (index = 10; index < 26; index ++) 
{ 
    pPaletteEntry[index].peFlags = PC_NOCOLLAPSE|PC_RESERVED; 
    pPaletteEntry[index].peRed = 255; 
    pPaletteEntry[index].peGreen = 64; 
    pPaletteEntry[index].peBlue = 32; 
} 
 
// Now set up the rest, the nonanimated entries. 
for (; index < 246; index ++) // Index is set up by previous for loop 
{ 
    pPaletteEntry[index].peFlags = PC_NOCOLLAPSE; 
    pPaletteEntry[index].peRed = 25; 
    pPaletteEntry[index].peGreen = 6; 
    pPaletteEntry[index].peBlue = 63; 
} 
 
// All 256 entries are filled. Create the palette. 
ddrval = lpDD->CreatePalette(DDPCAPS_8BIT, pPaletteEntry, 
    &lpDDPal,NULL); 
 
2.3ģʽõɫʵ
    IDirectDraw2::CreatePalettePALETTEENTRYеĹͬIDirectDrawPalette::SetEntriesˣά
PALETTEENTRYṹҪؽҪʱ򣬸Ľṹ鲢IDirectDrawPalette::SetEntriesڴĻУ
ģʽʱҪͼκδھ̬ʵ壬򽫻޷ԤϵĽֻڶʵ帴λʱôھ̬ʵ塣
    Ӧɫ嶯ֻҪıPALETTEENTRYṹеĺһʵ壬ЩʵύIDirectDrawPalette::SetEntries
ЩʵниλֻܸλЩPC_NOCOLLAPSE־PC_RESERVED־ǹʵ塣ͼ˶ʵ
Ԥ֪ĴǷǶռģʽµĵɫ嶯ӣ
LPDIRECTDRAW        lpDD;        // Already initialized 
PALETTEENTRY pPaletteEntry[256]; // Already initialized 
LPDIRECTDRAWPALETTE lpDDPal;     // Already initialized 
int                 index; 
HRESULT             ddrval; 
PALETTEENTRY        temp; 
 
// Animate some entries. Cycle the first 16 available entries. 
// They were already animated. 
temp = pPaletteEntry[10]; 
for (index = 10; index < 25; index ++) 
{ 
    pPaletteEntry[index] = pPaletteEntry[index+1]; 
} 
pPaletteEntry[25] = temp; 
 
// Set the values. Do not pass a pointer to the entire palette entry 
//structrue, but only to the changed entries. 
ddrval = lpDDPal->SetEntries( 
    0,                      // Flags must be zero 
    10,                     // First entry 
    16,                     // Number of entries 
    & (pPaletteEntry[10])); // Where to get the data 
 
3ʾϵͳ
    Windows 98MemphisWindows NTֵ֧һϵͳϵĶʾ豸ʾʾϵͳͨΪ MultiMonʹò
ϵͳܹʹϵʾ豸ʾһ߼档磬̨ʾMultiMonϵͳУûܹ
һʾʾӦóҲܹڴһ̨ʾϷŵһ̨ʾϡDirectDraw֧һϵṹһDirectDrawӦ
ܹгӲ豸ѡһ豸Ȼø豸GUIDΪ豸һDirectDrawһԱ֤MultiMon
ϵͳڵһʾϵͳܻѵܱ֡
    ǰĻʾ豸Ϊǡȱʡ豸ǡ豸Null DeviceΪǰʾ豸гʱNULLΪ
GUIDģеӦó򶼿Ϊ豸DirectDraw󣬼ٶ豸ӲٵġMultiMonϵͳУ豸
ӲٵģڵʱõЭȼ
    ȫռģʽ£豸Ӳٵģϵͳ֪Ѱװ豸ζţȫռģʽӦóMultiMon
ϵͳϵٶͬϵͳϵٶһ죬ʹǶĶԿԽʾ豸ͼ֧֡Ҫʹö豸ȫռģʽ
ӦóΪÿһҪʹõ豸һDirectDrawע⣬Ϊָ豸DirectDrawṩöGUID
DirectDrawEnumerateʱгÿһ豸GUID
    趨˱׼Эȼ󣬡豸ͲӲʵϣֻǽ豸Դһһ߼豸
һ棬豸ԶпԽʾͼβԣڶʾ߼λôʾʱֵǺ
ġ
    Ӧó趨˱׼ЭȼҪʵӲٹܣͱʹָ豸GUIDһһDirectDraw
ʹá豸ͲܻÿԽʾ豸ͼҲ˵Խ߽λ鴫ᱻУʹ˼а壩
ʧܣDDERR_INVALIDRECT
    ϵͳ£ӦڻȡͲѯĽӿ֮ǰDirectDraw֮ЭȼҪMultiMon
ϵͳжЭȼҪȫģʽл׼ģʽôµDirectDraw󣬶ҪʹϵDirectDraw

4Ƶ˿ڣVideo Ports
    DirectDrawƵ˿չһͼ̽ӿڣĿĲĿǰϵͳý̡Ƶ˿ڽӿڵĶƵ˾
DirectShow֮Ĺ˾ҪԼʹƵĳԱҲʹƵ˿չںܶṩĸ߼̽
ھҪˡ
    DirectDrawVideoPortĳЩϵͳаװ˵Ƶ˿Ӳһ˵Ƶ˿ڶƵ˿ӲƵ
ܵƵźֱӦõ֡ҪԴDirectDrawVideoPortƶƵͨΪÿͨ
ԷֱгãԣƵӲҪÿͨȫͬĴ
    Ƶ˿Ӳֱܹ֡жԱдȡƹCPUPCIߡֱӶ֡ĴȡʹЧزŻƵ
¼ƵװCPUСһĳУͼĻ縲һʾ Direct3DCPUĽػȡ
Ĵ
    䱸Ƶ˿豸ļУƵеܹƵԴͨƵƵ˿ֱ֡Щͨʾ
һҲΪӲһͼĴ̣

     
    ƵԴʲôأƵ˿ڼΧڣϸ˵ƵԴһӲƵ루Video Input豸ZoomƵ˿ڡMPEG
ȡЩӲԴźԲͬĸʽNTSCPALSECAMͨƵӷȥƵViceo 
DecoderһӲĹǷƵԴṩϢѭӸʽ͵Ƶ˿ڡͬƵ˿ڵ
ӣƵݡʱϢͬϢ͵Ƶ˿ڡ
    Ƶ˿ڣVideo-PortҲһӲʾVGAоƬϣֱӷ֡ڽ
Ϣ֡ԱʾڶݵĴУƵ˿ܲͼṩ仯ѹɫƺͼеȷ
֡Frame BufferƵ˿ṩƵݣȻӦóͿñ̵ķЩͼݣλ鴫䵽λ
ʹøǽʾĻϡ
    DirectDrawƵ˿չʵǰDirectDrawVideoPort󣬿ͨIDDVideoPortContainerIDirectDrawVideoPortӿ
Ƶ˿ڼṩƵDirectDrawVideoPort󲢲ܿƵֻṩԼķDirectDrawҲܿƵԴΪ
ƵԴѾƵ˿ڵķΧDirectDrawVideoPortֻǱƵ˿ڱýӿڷ趨Ĳźźͼ͵
ִ֡зתĴIDDVideoPortContainerӿڣͨIDirectDraw2::QueryInterfaceȡṩ˲ѯӲƵ˿ڶ
IDDVideoPortContainer::CreateVideoPortһƵ˿ڶ󣬸öͨIDirectDrawVideoPortӿʾ书ܡ
ЩӿڣܹƵ˿ڵ串ǱԽͼݡʼֹͣƵšӲͼʹС
ɫתźѹЧDirectDrawƵ˿չ֧ͬһ̨ϵĶƵ˿ڣƵ˿ڶ

5ȡתλ鴫״̬
    Ѿ֪IDirectDrawSurface3::Flip֮ͺ̨ͻụཻĶͻᷢ磬
ǰһתδʱ÷ͷDDERR_WASSTILLDRAWINGDirectDrawIDirectDrawSurface3::Flipеֱ
DD_OKΪֹӦóڵIDirectDrawSurface3::FlipDD_OK֮ǰһֱڵȴ״̬ôóЧʾͻǳ
͡ȡ֮ǣԴһں̨ 
    IDirectDrawSurface3::GetFlipStatusǰķתǷɡδɣصĻDDERR_WASSTILLDRAWINGӦ
Ϳһμ״̬֮һʱִһ˼ӣ
while(lpDDSBack->GetFlipStatus(DDGFS_ISFLIPDONE) == DDERR_WASSTILLDRAWING); 
 
    // Waiting for the previous flip to finish. The application can 
    // perform another task here. 
 
ddrval = lpDDSPrimary->Flip(NULL, 0); 
 
  ҲͬķIDirectDrawSurface3::GetBltStatusһλ鴫ǷɡΪIDirectDrawSurface3::GetFlipStatus
IDirectDrawSurface3::GetBltStatusܹӦóĿǰ״̬ԿڳڵʹǶ̫Ӱ
ȡ
    ִɫĹҪIDirectDrawSurface3::Blt磬ʾɫɫͿɫ 
IDirectDrawSurface3::BltDDBLT_COLORFILL־棬Ȼٽд档÷ǳٵ
õɫȻֻҪдɫִɫӣ
DDBLTFX ddbltfx; 
ddbltfx.dwSize = sizeof(ddbltfx); 
ddbltfx.dwFillColor = 0; 
ddrval = lpDDSPrimary->Blt( 
    NULL,        // Destination 
    NULL, NULL,  // Source rectangle 
    DDBLT_COLORFILL, &ddbltfx); 
 
switch(ddrval) 
{ 
    case DDERR_WASSTILLDRAWING: 
        . 
        . 
        . 
    case DDERR_SURFACELOST: 
        . 
        . 
        . 
    case DD_OK: 
        . 
        . 
        . 
    default: 
} 
 
6ʾӲ
    DirectDrawʹִЩûӲֵ֧DirectDrawܡΪDirectDrawӦóִٶȣӦڴ
DirectDrawϼʾӲȻپܵӲṩԹIDirectDraw2::GetCapsӲ
ܡеӲԶ档ʹһֽһЩӲֵ֧ԣûϵͳ֧ܲ
Ӳ׼ҲҪṩӲ֧ӲĽ

7ʾڴд洢λͼ
    ͨʾڴ浽ʾڴ֮λ鴫ȴϵͳڴ浽ʾڴ֮λ鴫ЧҪߡˣʾڴоܶ
洢Ҫõľλͼʾ㹻ĶڴԴ洢ֹһͺ̨ DDCAPSṹ
еdwVidMemTotaldwVidMemFreeԱʾڴлжڴ洢λͼDirectX SDKеDirectX Viewer
һ̡

8壨Triple Buffering
    ĳЩ£ʾбȽ϶ʾڴ棬пʹʾٶȡʹһ̨
ǳʼһӣ
// The lpDDSPrimary, lpDDSMiddle, and lpDDSBack are globally
// declared, uninitialized LPDIRECTDRAWSURFACE variables.

DDSURFACEDESC ddsd;
ZeroMemory (&ddsd, sizeof(ddsd));

// Create the primary surface with two back buffers. 
ddsd.dwSize = sizeof(ddsd); 
ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT; 
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | 
    DDSCAPS_FLIP | DDSCAPS_COMPLEX; 
ddsd.dwBackBufferCount = 2; 
ddrval = lpDD->CreateSurface(&ddsd, &lpDDSPrimary, NULL); 

// If we successfully created the flipping chain, 
// retrieve pointers to the surfaces we need for 
// flipping and blitting.
if(ddrval == DD_OK) 
{ 
    // Get the surface directly attached to the primary (the back buffer). 
    ddsd.ddsCaps.dwCaps = DDSCAPS_BACKBUFFER; 
    ddrval = lpDDSPrimary->GetAttachedSurface(&ddsd.ddsCaps, 
        &lpDDSMiddle); 
    if(ddrval != DD_OK) ;
        // Display an error message here. 
} 
 
    㲻Ҫ巭תбĹ켣ֻҪͺָ̨롣ָתڷתе棬
ָ̨λ鴫䡣Ӧóλ鴫䵽ֻ̨Ҫ̨һλ鴫Ѿɣʹת
δҲûйϵִзתһͬ¼һηתܱһηתʱ仹Ҫˣֻʹһ̨
IDirectDrawSurface3::FlipDD_OK֮ǰܻòʱ䴦ڵȴ״̬

9DirectDrawӦóʹڷ
    ӦóڴģʽʹDirectDrawͿʹκεķڡȫռģʽĳֲ WS_EX_TOOLWINDOW
ڣӦWS_EX_TOPMOSTչڷWS_VISIBLEڷȷͼȷʾַɽӦó򱣳
ZǰˣGDI滭ͼʾʹռȫģʽӦóȫУ
// Register the window class, display the window, and init all DirectX and graphic objects.
BOOL WINAPI InitApp(INT nWinMode)
{
    WNDCLASSEX wcex;

    wcex.cbSize           =    sizeof(WNDCLASSEX);
    wcex.hInstance        =    g_hinst;
    wcex.lpszClassName    =    g_szWinName;
    wcex.lpfnWndProc      =    WndProc;
    wcex.style            =    CS_VREDRAW|CS_HREDRAW|CS_DBLCLKS;
    wcex.hIcon            =    LoadIcon (NULL, IDI_APPLICATION);
    wcex.hIconSm          =    LoadIcon (NULL, IDI_WINLOGO);
    wcex.hCursor          =    LoadCursor (NULL, IDC_ARROW);
    wcex.lpszMenuName     =    MAKEINTRESOURCE(IDR_APPMENU);
    wcex.cbClsExtra       =    0 ;
    wcex.cbWndExtra       =    0 ;
    wcex.hbrBackground    =    GetStockObject (NULL_BRUSH);

    RegisterClassEx(&wcex);

    g_hwndMain = CreateWindowEx(
                        WS_EX_TOPMOST,
                        g_szWinName,
                        g_szWinCaption,
                        WS_VISIBLE|WS_POPUP,
                        0,0,CX_SCREEN,CY_SCREEN,
                        NULL,
                        NULL,
                        g_hinst,
                        NULL);

    if(!g_hwndMain)
        return(FALSE);

    SetFocus(g_hwndMain);
    ShowWindow(g_hwndMain, nWinMode);
    UpdateWindow(g_hwndMain);

    return TRUE;
} 

 DirectX5.0Ϸָ
DirectDraw̳ƪ

    DirectXΪVisual C++û׼ģҪDirectDrawϷöVCҪһ˽⡣ԸʹVCûҲ
ϢArakelian Soft˾רVisual Basic5.0ûActiveXؼDirectStudio98Tegosoft˾TegoSoft ActiveX for Visual 
BasicַDirectXܣϣֳļݣôûʹVisual C++
    Ϊ㣬ٶѾװDirectX5.0 SDK Visual C++ 5.0Ŀ¼ֱC:\DX5SDKC:\Program Files\DevStudioʹ
һֱװĿ¼£뽫ʵ޸ĲС˰װDirectX SDKȴ֪ʹãΪ
ǻVisual C++ģȴûһѺõļɿ˱Visual C++ʵơ

һDirectX SDK
1.1Microsoft Developer Studio   Ϊ˱DirectX SDKṩӣҪһµproject workspaceʵļû
ʹñܹҵҪӿͰļõȫ̡Microsoft Developer Studioװ贴
̣
   .File˵ѡNew 
   .NewԻѡProjectеWin32 ApplicationProject NameDDEX1
   .LocationıùļλãOKť
   .һµDDEX1 Classesļоͳworkspaceڵˡ
˹̺Ҫʹ²򹤳̲ʵļ
   .Project˵ѡAdd toProject|Files
   .C:\DX5SDK\SDK\SAMPLES\DDEX1 Ŀ¼ѡеļ
   .ѡOKĿ¼µDDEX1.CPPDDEX1.RCRESOURCE.Hͼ뵽ˡ
Ȼðļ·
   .Tools˵ѡOptions͵OptionsԻ
   .ѡDirectories Show Directories ForбѡInclude files
   .Directories:б˫бײĿհУC:\DX5SDK\SDK\INC. 
   .ͬټһ·C:\DX5SDK\SDK\SAMPLES\MISC
   .ѡOKť
ӿĿ¼
   .Show Directories ForбѡLibrary files
   .Directories:б˫ײհУC:\DX5SDK\SDK\LIB. 
   .OKť 
ýӦóʱӵģ飺
   .Project˵Settings.
   .ѡLink 
   .CategoryѡGeneral. 
   .Object/LibraryģбDdraw.libWinmm.lib. 
   .OK. 
1.2NMAKE·
ʱеķʽȼɻӷ㣬оĳԱԸеķʽӦóǰļӿģ
·
@echo off
set PATH=C:\Program Files\DevStudio\SharedIDE\Bin; C:\Program Files\DevStudio\Vc\Bin;%PATH%
set INCLUDE=C:\Program Files\DevStudio\Vc\include; C:\Program Files\DevStudio\Vc\Mfc\include;C:\DX5SDK\SDK\INC;%INCLUDE%
set LIB= C:\Program Files\DevStudio\SharedIDE\Vc\lib; C:\Program Files\DevStudio\Vc\Mfc\lib; C:\DX5SDK\SDK\LIB;%LIB%
set INIT= C:\Program Files\DevStudio;%INIT%
ݼAutoexec.batӵĿ¼
	NMAKE
ڵǰĿ¼´һDEBUGĿ¼ɵĿִļڸĿ¼¡
ΪѧϰĹϤDirectX SDKǽDirectX SDKṩķ˳ǳѭ򽥽
3ΪBorland C++5.0DirectX SDK
    DirectX 5 SDKҪΪVisual C++û׼ģMicrosoftδڶBorland C++ûDirectX SDKҲṩ
DirectXBorland C++⡣ܳھԵʣ²ѣװDirectX SDKвûBorland C++⡣ҪûԼ
һ˵ˡ֪DirectX 5 SDKһIDX5SDK.EXEģIDX5SDKȽѹļȫѹĳ
Ŀ¼£D:\DX5SDKȻиĿ¼µSETUP.EXEװDirectX SDKĿ¼ΪC:\DX5SDKʵϣڽѹĿ¼а
һD:\DX5SDK\SDK\LIB\BORLANDCĿ¼Ŀ¼¾Borland C++ӿļSETUPװʱװûаѸĿ
¼ƵװĿ¼Сܼ򵥣SETUPװɺٽһC:\DX5SDK\SDK\LIB\BorlandĿ¼D:\DX5SDK\SDK\LIB\Borland
µļƵC:\DX5SDK\SDK\LIB\BorlandĿ¼¡ȻBorland C++5.0ļɻͬVisual C++5.0ù


һDirectDrawʵ
    ҪʹDirectDrawȱ봴DirectDrawһʵϵʾ俨Ȼʹýӿڷ⻹
ҪһDirectDrawSurfaceʵʾϷDDEX1ȴһDirectDrawٴһ棨primary surface
һ̨back bufferȻڱ֮תDDEXxӶC++дɵģʹõC뽫ʵ
Ҫָӿڷָ롣

1ȳʼDirectDraw
DDEX1 doInitDirectDraw ĳʼ룺
// DirectDraw 
ddrval = DirectDrawCreate( NULL, &lpDD, NULL );
if( ddrval == DD_OK ) 		
    {
    // ȡռģʽ
    ddrval = lpDD->SetCooperativeLevel( hwnd, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN );
    if(ddrval == DD_OK )   
	{
        ddrval = lpDD->SetDisplayMode( 640, 480, 8 );
        if( ddrval == DD_OK )	       
		{
              //һ̨
            ddsd.dwSize = sizeof( ddsd );
            ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
            ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE |
                                  DDSCAPS_FLIP | 
                                  DDSCAPS_COMPLEX;
            ddsd.dwBackBufferCount = 1;
            ddrval = lpDD->CreateSurface( &ddsd, &lpDDSPrimary, NULL );
            if( ddrval == DD_OK )           
		 {
                //ȡָ̨
                ddscaps.dwCaps = DDSCAPS_BACKBUFFER;
				ddrval=lpDDSPrimary->GetAttachedSurface(&ddscaps, &lpDDSBack);
                if( ddrval == DD_OK )   
	             {
                    // һЩı
                    if (lpDDSPrimary->GetDC(&hdc) == DD_OK)     {
                        SetBkColor( hdc, RGB( 0, 0, 255 ) );
                        SetTextColor( hdc, RGB( 255, 255, 0 ) );
                        TextOut( hdc, 0, 0, szFrontMsg, lstrlen(szFrontMsg) );
                        lpDDSPrimary->ReleaseDC(hdc);
                    }
                    if (lpDDSBack->GetDC(&hdc) == DD_OK)    {
                        SetBkColor( hdc, RGB( 0, 0, 255 ) );
                        SetTextColor( hdc, RGB( 255, 255, 0 ) );
                        TextOut( hdc, 0, 0, szBackMsg, lstrlen(szBackMsg) );
                        lpDDSBack->ReleaseDC(hdc);
                    }
                    // תҳļʱ
                    if( SetTimer( hwnd, TIMER_ID, TIMER_RATE, NULL ) )
			   {
                         return TRUE;
                    	}
                	}
            	}
        }
    }
}
wsprintf(buf, "Direct Draw Init Failed (%08lx)\n", ddrval );
............
ϸ˵ʼDirectDraw Ĵ׼ÿһ衣

2DirectDraw 
    DirectDraw һʵӦDirectDrawCreate API ҲCOMеCoCreateInstanceDirectDrawCreate
һȫͳһ־GUID(Globally Unique IDentifier)ʾ豸ڴGUIDΪNULL(ʹϵͳȱʡʾ豸ȡ
豸ָָDirectDrawĵַNULL(չʹ)δһDirectDraw󣬲
Ƿɹ
	ddrval = DirectDrawCreate( NULL, &lpDD, NULL );
	if( ddrval == DD_OK )
       {
	 // lpDD isǺϷDirectDraw 
	}
	else
	{
	 // DirectDrawܱ
	}

3ʾģʽ
    DirectDraw ӦóʾģʽҪȵIDirectDraw::SetCooperativeLevel趨ģʽµҪһȷҪ
IDirectDraw::SetDisplayMode ѡʾֱʡ
    ڸıʾֱ֮ǰͨIDirectDraw::SetCooperativeLevelָDDSCL_EXCLUSIVEDDSCL_FULLSCREEN ־
ʹϷȫʾ豸Ӧóͬʱʾ豸DDSCL_FULLSCREEN־ʾΪȫģʽ
ĴʾʹIDirectDraw::SetCooperativeLevel
	HRESULT  ddrval;
	LPDIRECTDRAW lpDD;  // already created by DirectDrawCreate
	ddrval = lpDD->SetCooperativeLevel( hwnd, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN );
	if( ddrval == DD_OK ){
	 // ȫռʽóɹ
	  }
	else	{
	 // òɹȻܼ
	}

    IDirectDraw::SetCooperativeLevelDD_OKȻиó򣬵ȫģʽʱܲһЩ޷ԤϵĴ
ӦʾһϢû֪ʲô£ûǷϷ
   ʹIDirectDraw::SetCooperativeLevelʱ򴰿 (HWND)һôھʱֹӦó磬
GPGDIת(flip)˺̨û޷ʵǰĻΪ˱DirectDrawһ̨ȴ̣
зôڵϢЩϢȷӦóʱֹµĴڣȷôΪģ򣬾ͻһϵе¼
޷

4ıʾģʽ
   һѡӦóĹģʽͿʹIDirectDraw::SetDisplayModeıʾģʽĴ뽫ʾģʽó
640x480x256
	HRESULT  ddrval;
	LPDIRECTDRAW lpDD;  // already created
	ddrval = lpDD->SetDisplayMode( 640, 480, 8 );
	if( ddrval == DD_OK )	{ 
	// ıģʽɹ 
	}
	else	{
	 // ʾģʽܸı
	 // ϵͳָ֧ܲģʽ
	}
    趨ʾģʽʱӦȷû豸ָ֧ߵķֱʣӦóӦ÷ϵͳֵ֧ı׼ģʽʾʾ俨֧
ƵķֱʣIDirectDraw::SetDisplayModeһDDERR_INVALIDMODE ֵˣ÷ֱʱӦ
IDirectDraw::EnumDisplayModeûʾ豸ܡ

5ɷת(Flippable Surface)
    趨ʾģʽ󣬱봴Ӧóı档DDEX1УʹIDirectDraw::SetCooperativeLevel ɶռ
ȫģʽȻԴת档ʹIDirectDraw::SetCooperativeLevel DDSCL_NORMALģʽֻܴдʽı
ˡ

6Ҫ
    ɷתĵĵһDDSURFACEDESCṹжҪĴ˽ṹĶ弰ɷתҪ
־
	// һ̨
	ddsd.dwSize = sizeof( ddsd );
	ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
	ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_FLIP | DDSCAPS_COMPLEX;
	ddsd.dwBackBufferCount = 1;
    УԱdwSizeΪDDSURFACEDESCṹĴСdwFlags־ָDDSURFACEDESCṹЩɴЧϢ 
DDEX1УdwFlagsָҪʹDDSCAPSṹ(DDSD_CAPS)һ̨ (DDSD_BACKBUFFERCOUNT)dwCapsָ
 DDSCAPSṹõı־ָһ(DDSCAPS_PRIMARYSURFACE)һת(DDSCAPS_FLIP)һ
ӱ (DDSCAPS_COMPLEX)󣬳ָһ̨̨ǱͼｫдλãתΪ档
У̨ĿΪ1ʵϣֻҪ㹻ʾڴ棬Դ̨һÿ1Mʾڴֻһ
̨ڴȿʾڴ棬Ҳϵͳڴ档DirectDrawʹʾڴʱڽ1Mʾڴ洴
2̨Զʹϵͳڴ档ͨDDSCAPSṹеdwCaps趨ΪDDSCAPS_SYSTEMMEMORY
DDSCAPS_VIDEOMEMORYָֻʹϵͳڴֻʹʾڴ档ָ DDSCAPS_VIDEOMEMORYû㹻ʾڴ
棬IDirectDraw::CreateSurface һDDERR_OUTOFVIDEOMEMORY

7
    DDSURFACEDESCṹͿʹøýṹlpDDˣlpDDDirectDrawCreate DirectDraw ָ룬
Ĵʾһ̣
	ddrval = lpDD->CreateSurface( &ddsd, &lpDDSPrimary, NULL );
	if( ddrval == DD_OK ) {
	 // lpDDSPrimary points to new surface
	}
	else{
	 // surface was not created
	 return FALSE;
	}
    óɹIDirectDraw::CreateSurfaceͷָָlpDDSPrimary ָãͿԵ
IDirectDrawSurface::GetAttachedSurface ȡųָ́룬ʾ
	ddscaps.dwCaps = DDSCAPS_BACKBUFFER;
	ddrval = lpDDSPrimary->GetAttachedSurface( &ddcaps, &lpDDSBack );
	if( ddrval == DD_OK ) {
	 // lpDDSBack points to the back buffer
	}
	else{
	 return FALSE;
	}
    IDirectDrawSurface::GetAttachedSurfaceóɹͨṩĵַDDSCAPS_BACKBUFFER ־lpDDSBack 
ָ̨

8ɫ
    ͺ̨DDEX1ʹñ׼Windows GDI һЩıύͺ̨£
	if (lpDDSPrimary->GetDC(&hdc) == DD_OK){
	    SetBkColor( hdc, RGB( 0, 0, 255 ) );
	    SetTextColor( hdc, RGB( 255, 255, 0 ) );
	    TextOut( hdc, 0, 0, szFrontMsg, lstrlen(szFrontMsg) );
	    lpDDSPrimary->ReleaseDC(hdc);
	}
	if (lpDDSBack->GetDC(&hdc) == DD_OK){
	    SetBkColor( hdc, RGB( 0, 0, 255 ) );
	    SetTextColor( hdc, RGB( 255, 255, 0 ) );
	    TextOut( hdc, 0, 0, szBackMsg, lstrlen(szBackMsg) );
	    lpDDSBack->ReleaseDC(hdc);
	}
    ʹIDirectDrawSurface::GetDC豸ĵľñ档ʹҪWindowsʹ
IDirectDrawSurface::LockIDirectDrawSurface::Unlock ͽ̨ڴ棨滹еһ
֣ȷӦóϵͳͬʱڴ档⣬Ǹڴܷת档ʹWindows GDI 
SetBkColorñɫʹSetTextColorıɫȻʹTextOutı档ıд뻺ʹ
IDirectDrawSurface::ReleaseDC沢ͷžõϰǣ̨дɺϵ
IDirectDrawSurface::ReleaseDCIDirectDrawSurface::Unlock
    һдʱñĄ̊́Ȼ󽫻תʾDDEX1Уһηת֮ǰ
һҪӳ١DDEX1ͽд⿪ʼʾʱ̫ʱ潫ὲDDEX1ֻ WM_TIMER
̨дݡʼͷܻдӦעǣһʹIDirectDrawSurface::UnlockԱָ
ָͱЧٴʹIDirectDrawSurface::LockܻȡñڴЧָ롣

9д漰ת
    ˳ʼDDEX1ʼϢѭϢѭĹУ̨дµı̨
תĹ̡WM_TIMERдݺͷתĴ󲿷ִ롣
    WM_TIMERϢǰ벿̨дݣphaseдϢд̨ϢphaseΪ1
ʾдϢȻphaseıΪ0Ϊ0ʾд̨ϢȻphaseıΪ1ע⣬еϢ
д̨̨дϢʹIDirectDrawSurface::ReleaseDCĴʵһ㣺
case WM_TIMER:
    // Flip surfaces
    if( bActive )    {
        if (lpDDSBack->GetDC(&hdc) == DD_OK)
        {
            SetBkColor( hdc, RGB( 0, 0, 255 ) );
            SetTextColor( hdc, RGB( 255, 255, 0 ) );
            if( phase )            {
                TextOut( hdc, 0, 0, szFrontMsg, lstrlen(szFrontMsg) );
                phase = 0;
            }
            else            {
                TextOut( hdc, 0, 0, szBackMsg, lstrlen(szBackMsg) );
                phase = 1;
            }
            lpDDSBack->ReleaseDC(hdc);
        }

ڴʹIDirectDrawSurface::Flip̨ת棬£
while( 1 )          {
            HRESULT ddrval;
            ddrval = lpDDSPrimary->Flip( NULL, 0 );
            if( ddrval == DD_OK )             
		{
                break;
            }
            if( ddrval == DDERR_SURFACELOST )  
		 {
			if(ddrval = lpDDSPrimary-&g>val != DD_OK )
                	{
                    break;                
			}
            }
            if( ddrval != DDERR_WASSTILLDRAWING )
            {
                break;
            }
        }
    УlpDDSPrimaryָ漰̨IDirectDrawSurface::Flipͺ潻óɹ󣬷
DD_OKֹWhileѭDDERR_SURFACELOSTǱ涪ʧҪIDirectDrawSurface::Restore ָ
棬ָɹһεIDirectDrawSurface::FlipʧܣֹWhileѭһֵ⣬ǰ
ʹIDirectDrawSurface::FlipɹҲɣȵϵͳڴ֮ǰı潻ɺŽС磬ǰһεı淭
תδʱIDirectDrawSurface::Flip ͷDDERR_WASSTILLDRAWINGУIDirectDrawSurface::FlipѭֱDD_OK.

10ͷDirectDraw 
   F12DDEX1˳֮ǰȴWM_DESTROYϢϢfiniObjectsfiniObjectsе
IUnknown Releaseĵã£
static void finiObjects( void ){
    if( lpDD != NULL )    {
        if( lpDDSPrimary != NULL )        {
            lpDDSPrimary->Release();
            lpDDSPrimary = NULL;
        }
        lpDD->Release();
        lpDD = NULL;
    }
} /* finiObjects */
    DirectDrawָ(lpDD)DirectDrawSurfaceָ(lpDDSPrimary) ǷNULLȻΪNULLȻ
DDEX1 IDirectDrawSurface::ReleaseDirectDrawSurface Ĳοֵ1⽫ʹοֵΪ0DirectDrawSurface 
ͱͷˣDirectDrawSurfaceָ뱻ΪNULLֵȻֵIDirectDraw::ReleaseDirectDrawĲοֵ1
Ϊ0ͷDirectDrawָ롣
    DDEX1DirectDrawӦãȴDirectDrawDirectDrawSurface󣬴һ漰̨
ı̨Ȼת档ڶDDEX2չDDEX1ĹܣԽһλͼļ̨
DDEX3 һһ漰̨⣬棬λͼÿһ棬Ȼʹ
IDirectDrawSurface::BltFastһλ鴫䵽̨Ȼת沢һλ鴫䵽̨
潫ϸЩܡ

11λͼ
    DDEX1һdoInitDDEX2ĳʼߵʵһһֱĴ룺
lpDDPal = DDLoadPalette(lpDD, szBackground);
    if (lpDDPal == NULL)
        goto error;
    ddrval = lpDDSPrimary->SetPalette(lpDDPal);
    if( ddrval != DD_OK )
        goto error;
    // load a bitmap into the back buffer.
    ddrval = DDReLoadBitmap(lpDDSBack, szBackground);
    if( ddrval != DD_OK )
        goto error;
    ĵһдӺDDLoadPaletteһֵúC:\ DX5SDK\SDK\SAMPLES\MISCеDdutil.cppļУ˱DDEX2
ʱҪDdutil.cppDdutil.h̡󲿷ֵDirectDrawҪļDDEX2УDDLoadPaletteBack.bmpļ
һDirectDrawPaletteDDLoadPaletteȼڴɫļԴʮִڣڣʹһȱʡɫ
塣DDEX2УλͼļгȡɫϢ洢apeָĽṹȻ´ DirectDrawPalette
	pdd->CreatePalette(DDPCAPS_8BIT, ape, &ddpal, NULL);
	return ddpal;
    IDirectDraw::CreatePaletteʱddpalָDirectDrawPaletteapeָһṹָ룬ýṹܰ2/4/16/256
Եʵ壬ʵĿIDirectDraw::CreatePalette õdwFlagsУdwFlags趨ΪDDPCAPS_8BITʾý
256ʵ壬ÿʵĸֽڣɫɫɫͱ־ֽڣ

12õɫ壬λͼ̨
    ˵ɫ֮󣬿ͨIDirectDrawSurface::SetPalette DirectDrawPalette ָddpal͸棬£
	ddrval = lpDDSPrimary->SetPalette(lpDDPal);
	if( ddrval != DD_OK )
    // SetPalette failed
    IDirectDrawSurface::SetPalette֮DirectDrawPaletteͺDirectDrawSurface(hook)һˣҪıɫ
ʱֻҪһµĵɫþͿˡ
DirectDrawPaletteͬDirectDrawSurfaceһDDEX2ʹ´뽫Back.bmpļװ̨
	// load a bitmap into the back buffer.
	ddrval = DDReLoadBitmap(lpDDSBack, szBackground);
		if( ddrval != DD_OK )
	    // Load failed
    DDReLoadBitmapDdutil.cppеһλͼļԴеѾڵDirectDraw档ڱУszBackground
ָBack.bmpװlpDDSBackָĺ̨DDReLoadBitmapDDCopyBitmapļ̨չΪʵ
ߴ硣DDCopyBitmapλͼڴ棬ʹGetObjectȡλͼĴСȻȡҪλͼĺ̨ĴС
	// get size of surface.
	ddsd.dwSize = sizeof(ddsd);
	ddsd.dwFlags = DDSD_HEIGHT | DDSD_WIDTH;
	pdds->GetSurfaceDesc(&ddsd);
ddsd ָDDSURFACEDESCṹָ룬ýṹDirectDrawĵǰDDSURFACEDESC ṹĳԱ
DDSD_HEIGHT DDSD_WIDTHָ˱ĸߺͿIDirectDrawSurface::GetSurfaceDescʹúʵֵṹиΪ480
Ϊ640DDCopyBitmap沢λͼ̨ȻStretchBltλͼѹ£
		if ((hr = pdds->GetDC(&hdc)) == DD_OK){
	    	StretchBlt(hdc, 0, 0, ddsd.dwWidth, ddsd.dwHeight, hdcImage, x, y, dx, dy, SRCCOPY);
	    	pdds->ReleaseDC(hdc);
		}
 
13λ鴫
    DDEX2ͬDDEX1ͬDDEX2һλͼļ̨Ȼת̨档ʾλͼ
ر룬DDEX3չDDEX2Ĺܣ⻺ÿ洢һλͼDDEX3еdoInitһ
֣Ǵ⻺
		// Create an offscreen bitmap.
		ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH;
		ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
		ddsd.dwHeight = 480;
		ddsd.dwWidth = 640;
		ddrval = lpDD->CreateSurface( &ddsd, &lpDDSOne, NULL );
		if( ddrval != DD_OK ){
		    return initFail(hwnd);
		}
		// Create another offscreen bitmap.
		ddrval = lpDD->CreateSurface( &ddsd, &lpDDSTwo, NULL );
		if( ddrval != DD_OK ){
		    return initFail(hwnd);
		}
    ӴпԿdwFlagsָ˳ʹDDSCAPSṹûĸߺͿDDSCAPS ṹеDDSCAPS_OFFSCREEN 
־ָñ⻺DDSURFACEDESCṹнߺͿΪ480640ȻʹIDirectDraw::CreateSurface
档ΪĴСһڶֻҪһIDirectDraw::CreateSurfaceɣȻҪòָͬ룩㻹
DDSCAPS DDSCAPS_SYSTEMMEMORYDDSCAPS_VIDEOMEMORY ָ⻺ʾڴ滹ϵͳڴ档λ
ͼʾڴԼӿ̨֮ݴٶȣλͼзǳҪǣΪ⻺ָ
DDSCAPS_VIDEOMEMORYû㹻ʾڴλͼñʱͻ᷵һDDERR_OUTOFVIDEOMEMORY
Ĵֵ

14λͼļ
    DDEX3ʹInitSurfacesλͼFrntback.bmpļװ뵽档InitSurfacesʹ
DDCopyBitmapλͼ£
		// Load our bitmap resource.
		hbm = (HBITMAP)LoadImage(GetModuleHandle(NULL), szBitmap,
		    IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION);
		if (hbm == NULL)
		    return FALSE;
		DDCopyBitmap(lpDDSOne, hbm, 0, 0,   640, 480);
		DDCopyBitmap(lpDDSTwo, hbm, 0, 480, 640, 480);
		DeleteObject(hbm);
		return TRUE;
Frntback.bmpļɣһϣһ¡DDCopyBitmapϰ벿ֵһlpDDSOne°벿ֵ
lpDDSTwo

15λλ鴫䵽̨
    WM_TIMERдͷתĴ롣DDEX3Уѡʵ棬λ鴫䵽̨£
		    rcRect.left = 0;
		    rcRect.top = 0;
		    rcRect.right = 640;
		    rcRect.bottom = 480;
		    if(phase)    
			{
		        pdds = lpDDSTwo;
		        phase = 0;
		    }
		    else    {
		        pdds = lpDDSOne;
		        phase = 1;
		    }
		    while( 1 )    {
        		ddrval = lpDDSBack->BltFast( 0, 0, pdds, &rcRect, FALSE );
		        if( ddrval == DD_OK )		      
			  {
		            break;
        		}
   phase׼һλ鴫䵽̨ȻIDirectDrawSurface::BltFastѡλ鴫䵽
̨Ͻǵλ0,0ʼrcRectָϽǺ½ǵRECTṹһΪFALSE0ָ
ʹĴ־һ汻͵̨Ϳǰķ̨໥תˡ


    Ӷֻǽд̨Ȼ󽫺̨淭תٶȲ̫졣DDEX4DDEX5Ż
ʵʱܣʹһϷDDEX4ʾΪ Color keyʹIDirectDrawSurface::BltFast
ֿ̨ԲDDEX5˶ȡɫ岢ڶʱıɫĹܡ

1Color Keyλͼ
    DDEX3˽λͼ⻺һҪʽDDEX4ʹ˽һϵеľ(spriteоԲ)װ
ļȻʹ, IDirectDrawSurface::BltFastĸֿ̨doInit˾ǰеĹ
⣬ΪColor keyĴ롣Color key͸ȵɫֵʹӲдʽʱڳΪ color key
أضдɴڱϲǾ͵ľ顣color keyĴ£
	    // Set the color key for this bitmap (black)
    	// NOTE this bitmap has black as entry 255 in the color table.
		//    ddck.dwColorSpaceLowValue = 0xff;
		//    ddck.dwColorSpaceHighValue = 0xff;
		//    lpDDSOne->SetColorKey( DDCKEY_SRCBLT, &ddck );
	    // if we did not want to hard code the palette index (0xff)
	    // we can also set the color key like so...
    	DDSetColorKey(lpDDSOne, RGB(0,0,0));
	    return TRUE;
    иcolor keyֲͬһַעڵ3У趨DDCOLORKEY ṹcolor keyķΧٵ
IDirectDrawSurface::SetColorKeycolor key óɺɫٶλͼɫԺɫΪɫ255ڶַǵ
DDSetColorKey ɫRGBֵѡcolor keyɫRGB(0,0,0)DDSetColorKey DDColorMatch
DDColorMatch 洢lpDDSOneλͼ0,0λصɫֵȻṩRGBֵ0,0λõأɫֵΡ
һԭɫͿ·Ż0,0ȷColor KeyDDSetColorKeyóɹcolor keyͷ 
DDCOLORKEY ṹеĳԱdwColorSpaceLowValue ͬʱҲdwColorSpaceHighValueԱȻٵ
IDirectDrawSurface::SetColorKey Color key
    CLR_INVALIDDDSetColorKey DDColorMatchһõı DDSetColorKeyԸֵΪcolor keyλͼ
ϽǵؾͻΪcolor keyʹáҪʵһܣҪλͼļAll.bmp0,0ֵΪɫģȻ
ıDDSetColorKey ĵã
		DDSetColorKey(lpDDSOne, CLR_INVALID);
±DDEX4DDEX4ͻʹ0,0ֵΪcolor keyˡ

2DDEX4еĶ
    DDEX4All.bmpеĺɫԲupdateFrame һ򵥵ĶԲ3λɡͨȽWin32
еGetTickCountϴθúʼеʱжǷػĸԲȻʹIDirectDrawSurface::BltFast
lpDDSOneλ鴫䵽̨ȻʹѾ趨õcolor keyԲд̨еԲд̨󣬵
IDirectDrawSurface::Flipת̨档

3̬ıɫ
    DDEX5κڳʱ̬ظıɫ壬ϷⲢõDirectDrawȷʵܺܺõؿƵɫ塣DDEX5
뽫All.bmpļ°벿еĵɫװ룺
		// First, set all colors as unused
		for(i=0; i<256; i++)		
		{
		    torusColors[i] = 0;
		}
		// lock the surface and scan the lower part (the torus area)
		// and remember all the index's we find.
		ddsd.dwSize = sizeof(ddsd);
		while (lpDDSOne->Lock(NULL, &ddsd, 0, NULL) == DDERR_WASSTILLDRAWING);
		// Now search through the torus frames and mark used colors
		for( y=480; y<480+384; y++ ){
		    for( x=0; x<640; x++ )		  
			  {
		        torusColors[((BYTE *)ddsd.lpSurface)[y*ddsd.lPitch+x]] = 1;
		    }
		    }
		lpDDSOne->Unlock(NULL);
torusColorsָAll.bmpе°벿ֵɫֵʹ֮ǰʼΪ0Ȼĳɫ
ֵǷátorusColorsʼλͼĵ0е480Уеɫֵλͼ ڴλõһֽھλ
DDSURFACEDESC ṹеlpSurfaceԱlpSurface ָӦλͼ0,480ڴַ(y*lPitch+x)趨
ɫֵɫЩɫ滻ΪͺɫԲ֮ûйõɫֻЩͬԲһɫֵŻᱻ滻

4滻ɫ
    DDEX5еupdateFrameͬDDEX4еĻͬȽд̨ٽ3ɫԲдǰڷת֮
ǰupdateFramedoInitĵɫֵıĵɫ壬£
		// Change the palette
		if(lpDDPal->GetEntries( 0, 0, 256, pe ) != DD_OK)	{
		    return;
		}
		for(i=1; i<256; i++){
		    if(!torusColors[i])  {
		       continue;
		    }
		    pe[i].peRed = (pe[i].peRed+2) % 256;
		    pe[i].peGreen = (pe[i].peGreen+1) % 256;
		    pe[i].peBlue = (pe[i].peBlue+3) % 256;
		}
		if(lpDDPal->SetEntries( 0, 0, 256, pe) != DD_OK){
		    return;
		}
    IDirectDrawPalette::GetEntriesDirectDrawPaletteвѯɫֵΪ peָĵɫʵֵЧͷ
DD_OKСȻѭtorusColorsڳʼǷΪ1ֵΪ1peָĵɫĺɫɫ
ɫֵͱ滻еıǵĵɫʵ滻ϺٵIDirectDrawPalette::SetEntriesıDirectDrawPalette еʵ
塣õɫѾ棬ĸıͻɡһʣµľͬǰһķתˡ

ġʹøǱ
ʹDirectX SDKMosquitoһһ˵ڳʹDirectDrawӲֵ֧ĸǱ档Mosquitoʹ
øǱķתûλ鴫䵽潫˶λͼʾϡMosquitoǱӦӲơ

1һ
    ҪʹøǱ棬Ҫʼһ棬Ǳ潫ʾڸϡMosquito´봴һ棺
// Zero-out the structure and set the dwSize member.
    ZeroMemory(&ddsd, sizeof(ddsd));
    ddsd.dwSize = sizeof(ddsd);

    // Set flags and create a primary surface.
    ddsd.dwFlags = DDSD_CAPS;
    ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
    ddrval = g_lpdd->CreateSurface(&ddsd, &g_lpddsPrimary, NULL );
 
    ȳʼҪʹõDDSURFACEDESCṹȻ趨ʵı־IDirectDraw2::CreateSurface档ڶԸ÷
ĵУһҪıDDSURFACEDESCṹָ룻ڶһָ룬óɹñ
IDirectDrawSurfaceӿڵָ룻ΪNULLûCOMϡ

2ӲԸǵ֧
    ʼDirectDrawҪ豸Ƿָ֧Ǳ档ΪDirectDrawܷ渲ǣӲָ֧ǣͲܼ
ĹIDirectDraw2::GetCapsȡӲ豸⸲֧֡ڵø÷֮󣬲鿴DDCAPSṹеdwFlags
ԱǷDDCAPS_OVERLAY־оͱָ֧ǣͲ֧֡
    ĴMosquitoеһ֣Ӳĸ֧
BOOL AreOverlaysSupported()
{
    DDCAPS  capsDrv;
    HRESULT ddrval;

    // Get driver capabilities to determine Overlay support.
    ZeroMemory(&capsDrv, sizeof(capsDrv));
    capsDrv.dwSize = sizeof(capsDrv);

    ddrval = g_lpdd->GetCaps(&capsDrv, NULL);
    if (FAILED(ddrval))
        return FALSE;

    // Does the driver support overlays in the current mode? 
    // (Currently the DirectDraw emulation layer does not support overlays.
    // Overlay related APIs will fail without hardware support).  
    if (!(capsDrv.dwCaps & DDCAPS_OVERLAY))
        return FALSE;

    return TRUE;
} 
    ȵIDirectDraw2::GetCapsȡ豸һDDCAPSṹĵַָ룻ΪҪط
ϢԵڶΪNULLȡ󣬳ʹ߼롱dwFlagsԱǷ DDCAPS_OVERLAY
־񣬳򷵻FALSEʧܡǣͷTRUEʾ豸ָ֧Ǳ档

3һǱ
    ֪ʾ豸ָ֧Ǳ棬ͿԴһΪûָ豸ָ֧Ǳı׼ԲܹС
ʽı档⣬ҲҪһδǱͻɹˣ׼жδĳԣֱһܹΪֹ
    Mosquitoڴʱѭbest case to worst caseԭȳԴһҳתӸǱ档ʧܣ
͸ı䷽ͨõѸٸʽáĴһ˼·ı֣
    ZeroMemory(&ddsdOverlay, sizeof(ddsdOverlay));
    ddsdOverlay.dwSize = sizeof(ddsdOverlay);

    ddsdOverlay.dwFlags= DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | 
                         DDSD_BACKBUFFERCOUNT| DDSD_PIXELFORMAT;
    ddsdOverlay.ddsCaps.dwCaps = DDSCAPS_OVERLAY | DDSCAPS_FLIP |
                                 DDSCAPS_COMPLEX | DDSCAPS_VIDEOMEMORY;
    ddsdOverlay.dwWidth  =320;
    ddsdOverlay.dwHeight =240;
    ddsdOverlay.dwBackBufferCount=2;

    // Try to create an overlay surface using one of the pixel formats in our
    // global list.
    i=0;
    do{
	   ddsdOverlay.ddpfPixelFormat=g_ddpfOverlayFormats[i];
       // Try to create the overlay surface
       ddrval = g_lpdd->CreateSurface(&ddsdOverlay, &g_lpddsOverlay, NULL);
    } while( FAILED(ddrval) && (++i < NUM_OVERLAY_FORMATS) );
 
    DDSURFACEDESCṹеı־ֵԷӳҳתӸǱ棬ȻִѭѭУøֳõ
ظʽҪı档Գɹѭֹʧܣ˵пʾӲû㹻ʾڴ֧ķ
ӲͲַ֧תǱ档£СҪʹһһķǷתǱ棬£
    // If we failed to create a triple buffered complex overlay surface, try
    // again with a single non-flippable buffer.
    if(FAILED(ddrval))
    {
        ddsdOverlay.dwBackBufferCount=0;
        ddsdOverlay.ddsCaps.dwCaps=DDSCAPS_OVERLAY | DDSCAPS_VIDEOMEMORY;
        ddsdOverlay.dwFlags= DDSD_CAPS|DDSD_HEIGHT|DDSD_WIDTH|DDSD_PIXELFORMAT;

        // Try to create the overlay surface
        ddrval = g_lpdd->CreateSurface(&ddsdOverlay, &g_lpddsOverlay, NULL);
        i=0;
        do{
            ddsdOverlay.ddpfPixelFormat=g_ddpfOverlayFormats[i];
            ddrval = g_lpdd->CreateSurface(&ddsdOverlay, &g_lpddsOverlay, NULL);
        } while( FAILED(ddrval) && (++i < NUM_OVERLAY_FORMATS) );

        // We couldn't create an overlay surface.  Exit, returning failure.
        if (FAILED(ddrval))
            return FALSE;
    }
 
ĴDDSURFACEDESCṹеı־ֵԭӳһһķǷתǱ棬ȻͨظʽѭԴ档
ɹѭֹͣɹ򷵻FALSEʧܡڳɹشǱ֮󣬾ͿɽλͼװԹ
ʾ

4ʾǱ
    ˸Ǳ֮ͿʾˡͨӲʾǵľελúظʽϼ϶Լ⣬Ҫͨ
ĿľεĿ˵СҪԳɹʾǱ档MosquitoµĲ׼ʾǱ档
4.1ʾСҪ
   󲿷ֵʾӲʾʱԼϸصʹ֮ЩԼͨIDirectDraw2::GetCaps
йЩԼϢ÷ĽṹDDCAPSйظʹԼϢͬӲԼǲͬģ˱ʼ
Ҫ鿴dwFlagsԱı־ȷӵһԼ
MosquitoʼʱȻȡӲȻûСӵķʾ
    // Get driver capabilities
    ddrval = g_lpdd->GetCaps(&capsDrv, NULL);
    if (FAILED(ddrval))
        return FALSE;

    // Check the minimum stretch and set the local variable accordingly.
    if(capsDrv.dwCaps & DDCAPS_OVERLAYSTRETCH)
        uStretchFactor1000 = (capsDrv.dwMinOverlayStretch>1000) ? capsDrv.dwMinOverlayStretch : 1000;
    else
        uStretchFactor1000 = 1000;
 
    ĴIDirectDraw2::GetCapsȡӲڱУһDDCAPSṹָ룻ڶNULL
˲ҪȡйطϢһʱбСԱԺ֮á򱨸Ӵ1000
ͱҪеĿľXķ졣磬1.3Դο320أĿľξͱҪ416
320X1.3=416صĿ򱨸С1000ͱܹʾԴСĸǣչǡ
    ĴǲⶨĴСԼֵ
    // Grab any alignment restrictions and set the local variables acordingly.
    uSrcSizeAlign = (capsDrv.dwCaps & DDCAPS_ALIGNSIZESRC)?capsDrv.dwAlignSizeSrc:0;
    uDestSizeAlign= (capsDrv.dwCaps & DDCAPS_ALIGNSIZESRC)?capsDrv.dwAlignSizeDest:0;
 
    ʹ˸ʱdwAlignSizeSrcdwAlignSizeDestԱлõĴСԼЩֵṩйؿȶ
ԼϢԺ趨ԴκĿľεĴСʱҪõԴκĿľαЩֵı
󣬳ⶨĿľα߽Լֵ
    // Set the "destination position alignment" global so we won't have to
    // keep calling GetCaps() every time we move the overlay surface.
    if (capsDrv.dwCaps & DDCAPS_ALIGNBOUNDARYDEST)
        g_dwOverlayXPositionAlignment = capsDrv.dwAlignBoundaryDest;
    else 
        g_dwOverlayXPositionAlignment = 0;
 
    ĴʹһȫֱĿľα߽ԼֵֵǴdwAlignBoundaryDestԱеĵģԺ·
ʱõ趨ĿľϽǵXظʽֵͬ롣Ҳ˵ֵ4ָֻϽǵXΪ
04812ؿĿľΡMosquito00ʾǣڵһʾ֮ǰͲҪȡԼϢΪ
ͬӦóʵֹ̿ܲͬ Ҫʾ֮ǰЩϢԵĿľΡ
2ԴκĿľ
    ڻĸԼ֮󣬾Ӧ趨йԴκĿľεֵȷܹȷʾǡĴ趨Դε

    // Set initial values in the source RECT.
    rs.left=0; rs.top=0; 
    rs.right = 320;
    rs.bottom = 240;

    // Apply size alignment restrictions, if necessary.
    if (capsDrv.dwCaps & DDCAPS_ALIGNSIZESRC && uSrcSizeAlign)
        rs.right -= rs.right % uSrcSizeAlign; 
 
    Ĵ˰Сĳʼֵ豸ҪС룬͵Դ֤ԴεĿ
ʹ֮ȳʼֵҪСΪȫ´棬Ͳܹչȡ
    趨ԴεĴСҪú͵ĿľεĴСһҪ΢һĹΪĿľοҪٵ
ϴСԼĴСú͵ĿľεĴС
    // Set up the destination RECT, starting with the source RECT values.
    // We use the source RECT dimensions instead of the surface dimensions in
    // case they differ.
    rd.left=0; rd.top=0; 
    rd.right  = (rs.right*uStretchFactor1000+999)/1000; 	// (Adding 999 avoids integer truncation problems.)

    // (This isn't required by DDraw, but we'll stretch the
    //  height, too, to maintain aspect ratio).
    rd.bottom = rs.bottom*uStretchFactor1000/1000; 
    ǰĴĿľεϽλãٸС趨ĿľεĿȡӵʱעڿȺ
ӵĳ˻ּ999Ϊ˱ضϣضϻᵼ¾ͬСӵҪһ¡ȺҲ
εĸ߶ȡԸ߶ȵ첢ǱģֻΪ˱λͼĳʱʧ
Ŀľκ󣬳еԱֺʹСԼһ£ӦĴ룺
    // Adjust the destination RECT's width to comply with any imposed
    // alignment restrictions.
    if (capsDrv.dwCaps & DDCAPS_ALIGNSIZEDEST && uDestSizeAlign)
        rd.right = (int)((rd.right+uDestSizeAlign-1)/uDestSizeAlign)*uDestSizeAlign;
 
    Ӳı־鿴Ƿ˾δСԼǣĿľεĿʹ֮СԼ
εĵչȶܼȣΪٿȿܻᵼĿľαСҪĻҪСӶʾǱʧܡ
3ʾǱ
    ԴκĿľκ󣬾Ϳʾˡʾ֮ǰ׼ȷʾǻܼ򵥡MosquitoµĴ
ʾǣ
    // Set the flags we'll send to UpdateOverlay
    dwUpdateFlags = DDOVER_SHOW | DDOVER_DDFX;

    // Does the overlay hardware support source color keying?
    // If so, we can hide the black background around the image.
    // This probably won't work with YUV formats
    if (capsDrv.dwCKeyCaps & DDCKEYCAPS_SRCOVERLAY)
        dwUpdateFlags |= DDOVER_KEYSRCOVERRIDE;

    // Create an overlay FX structure so we can specify a source color key.
    // This information is ignored if the DDOVER_SRCKEYOVERRIDE flag isn't set.
    ZeroMemory(&ovfx, sizeof(ovfx));
    ovfx.dwSize = sizeof(ovfx);

    ovfx.dckSrcColorkey.dwColorSpaceLowValue=0; // Specify black as the color key
    ovfx.dckSrcColorkey.dwColorSpaceHighValue=0;

    // Call UpdateOverlay() to displays the overlay on the screen.
    ddrval = g_lpddsOverlay->UpdateOverlay(&rs, g_lpddsPrimary, &rd, dwUpdateFlags, &ovfx);
    if(FAILED(ddrval))
        return FALSE;
 
    ʼʱdwUpdateFlags趨DDOVER_SHOWDDOVER_DDFX־ָøǵһʾӲӦʹð
DDOVERLAYFXṹеЧϢһȻ󣬳DDCAPSṹȷǷ֧ԴColor Keyǣ
DDOVER_KEYSRCOVERRIDE־ͰdwUpdateFlagsԴColor KeyҲݴColor Key
    ׼֮󣬳IDirectDrawSurface3::UpdateOverlayʾǡڶԸ÷ĵУһ͵
ѵԴκĿľεĵַڶǸʾϵĵַĸ ˷ڴǰ׼dwUpdateFlags
еı־DDOVERLAYFXṹĵַýṹеĳԱ趨ͬЩ־ƥ䡣
    Ӳֻ֧һǱҸñʹãUpdateOverlayͻʧܣDDERR_OUTOFCAPS⣬пӲ
СӹСUpdateOverlayʧܺҪԼĿľεĿӦֿԡٷ
MosquitoҲֻǼ򵥵طһϢ

5¸ǵʾλ
    ʾǱ֮ʱܾͲҪԸĲˡЩҪ·øǣı串ǵʾλáMosquito
ʹIDirectDrawSurface3::SetOverlayPosition·øǣ£
    // Set X- and Y-coordinates
    .
    .
    .
    // We need to check for any alignment restrictions on the X position
    // and align it if necessary.
    if (g_dwOverlayXPositionAlignment)
        dwXAligned = g_nOverlayXPos - g_nOverlayXPos % g_dwOverlayXPositionAlignment;
    else
        dwXAligned = g_nOverlayXPos;

    // Set the overlay to its new position.
    ddrval = g_lpddsOverlay->SetOverlayPosition(dwXAligned, g_nOverlayYPos);
    if (ddrval == DDERR_SURFACELOST)
    {
        if (!RestoreAllSurfaces()) 
            return;
    }
 
    ʼܴڵκĿľα߽ԼǰIDirectDraw2::GetCapsʱȫֱ 
g_dwOverlayXPositionAlignmentѾ趨ΪͬDDCAPSṹdwAlignBoundaryDestԱֵȡĿľԼ
;ݴ˵µXΪضġҪ󣬸ǱͲʾ
    ˶Xĵ֮󣬳IDirectDrawSurface3::SetOverlayPosition·øǡڵеһǶ
X꣬ڶµYꡣЩֵ˸ϽµλáﲢҪȡÿȺ͸߶ϢΪDirectDrawڿʼ
IDirectDrawSurface3::UpdateOverlayʾʱѾ˱СϢΪһ涪ʧ·øǱ
ʧܣMosquito͵һӦöĺָЩ沢װǵλͼ
    ע⣬Ҫʹ̫Ŀҡ±߽ꡣΪIDirectDraw2::SetOverlayPositionִмйܣʹЩ
ܵ¸ǳĿ߽õʧܣDDERR_INVALIDPOSITION

6ظǱ
    ҪһǱֻ벻øǿɼͿ趨ʵı־IDirectDrawSurface3::UpdateOverlayظøǱ
档Mosquito´ظǱ沢׼رӦó
void DestroyOverlay()
{
    if (g_lpddsOverlay){
        // Use UpdateOverlay() with the DDOVER_HIDE flag to remove an overlay 
        // from the display.
        g_lpddsOverlay->UpdateOverlay(NULL, g_lpddsPrimary, NULL, DDOVER_HIDE, NULL);
        g_lpddsOverlay->Release();
        g_lpddsOverlay=NULL;
    }
}
    ڵIDirectDrawSurface3::UpdateOverlayʱԴκĿľָNULLΪظǵĹвҪԴκĿľΡ
ͬҲָΪNULLΪʹøЧڶĿָ롣󣬳ڵĸʹ DDOVER_HIDE
־øǽӿȡ
ظ֮ͷIDirectDrawSurface3ӿڣҽȫֱΪNULLʹ֮ЧMosquito˵
ǾͲҪˡӦóлҪʹøøǣֻ򵥵ظǣҪͷȻҪʱʾ

塢DirectDrawDirectDraw

    ҪйDirectDrawӦãӦöоDirectX SDK:֮е
1Stretch
һдһǶռģʽĶмλ鴫λ鴫Ĺܡ
2Donut
˶ռģʽӦͬǶռģʽӦ֮Ľ
3Wormhole
÷ϸĵɫ嶯
4Dxview
 ϸȡʾӲ
  ĻDuelIklownsFoxbearPaletteFlip2dȣֻҪЩӷDirectXļDirectDrawǲѵġ


ͨѶַ ѧ촺ϲ
룺 430074
Email    jxwu@usa.net
Tel      027-7545580

  