// H to Pas Converter Ver0.3.0.3 // Date : 97/09/01 // Source : ddraw.h //DirectX5 include file // // Translated by kuroda Dycoon // // 1997/12/10 unit ddraw; interface uses Windows, OLE2; const DIRECTDRAW_VERSION = 00; DD_ROP_SPACE = ( 256 div 32); CO_E_NOTINITIALIZED = 0401F0; _FACDD = 6; CLSID_DirectDraw: TGUID = ( D1:$D7B70EE0;D2:40;D3:CF;D4:($B0,,{viewgit}{/viewgit},,$AF,$C2,$CD,)); CLSID_DirectDrawClipper: TGUID = ( D1:3817A0;D2:DB3;D3:CF;D4:($A2,$DE,{viewgit}{/viewgit},$AA,{viewgit}{/viewgit},$b9,,)); IID_IDirectDraw: TGUID = ( D1:C14DB80;D2:$A733;D3:CE;D4:($A5,,{viewgit}{/viewgit},,$AF,{viewgit}{/viewgit}B,$E5,)); IID_IDirectDraw2: TGUID = ( D1:$B3A6F3E0;D2:B43;D3:CF;D4:($A2,$DE,{viewgit}{/viewgit},$AA,{viewgit}{/viewgit},$B9,,)); IID_IDirectDrawSurface: TGUID = ( D1:C14DB81;D2:$A733;D3:CE;D4:($A5,,{viewgit}{/viewgit},,$AF,{viewgit}{/viewgit}B,$E5,)); IID_IDirectDrawSurface2: TGUID = ( D1:805885;D2:eec;D3:cf;D4:(,,$a8,,,$c1,{viewgit}{/viewgit}e,)); IID_IDirectDrawSurface3: TGUID = ( D1:$DA044E00;D2:B2;D3:D0;D4:($A1,$D5,{viewgit}{/viewgit},$AA,{viewgit}{/viewgit},$B8,$DF,$BB)); IID_IDirectDrawPalette: TGUID = ( D1:C14DB84;D2:$A733;D3:CE;D4:($A5,,{viewgit}{/viewgit},,$AF,{viewgit}{/viewgit}B,$E5,)); IID_IDirectDrawClipper: TGUID = ( D1:C14DB85;D2:$A733;D3:CE;D4:($A5,,{viewgit}{/viewgit},,$AF,{viewgit}{/viewgit}B,$E5,)); IID_IDirectDrawColorControl: TGUID = ( D1:B9F0EE0;D2:{viewgit}{/viewgit}D7E;D3:D0;D4:(B,,{viewgit}{/viewgit},$A0,$C9,,$A3,$B8)); type IDirectDraw = class; IDirectDraw2 = class; IDirectDrawSurface = class; IDirectDrawSurface2 = class; IDirectDrawSurface3 = class; IDirectDrawPalette = class; IDirectDrawClipper = class; IDirectDrawColorControl = class; DDCOLORKEY = record dwColorSpaceLowValue : DWORD; dwColorSpaceHighValue : DWORD; end; DDSCAPS = record dwCaps : DWORD; // capabilities of surface wanted end; DDPIXELFORMAT = record dwSize : DWORD; dwFlags : DWORD; dwFourCC : DWORD; case Integer of 0: ( dwRGBBitCount : DWORD; dwRBitMask : DWORD; dwGBitMask : DWORD; dwBBitMask : DWORD; dwRGBAlphaBitMask : DWORD; ); 1: ( dwYUVBitCount : DWORD; dwYBitMask : DWORD; dwUBitMask : DWORD; dwVBitMask : DWORD; dwYUVAlphaBitMask : DWORD; ); 2: ( dwZBufferBitDepth : DWORD; Unknown2_2: DWORD; Unknown2_3: DWORD; Unknown2_4: DWORD; dwRGBZBitMask : DWORD; ); 3: ( dwAlphaBitDepth : DWORD; Unknown3_2: DWORD; Unknown3_3: DWORD; Unknown3_4: DWORD; dwYUVZBitMask : DWORD; ); end; DDSURFACEDESC = record dwSize : DWORD; // size of the DDSURFACEDESC structure dwFlags : DWORD; // determines what fields are valid dwHeight : DWORD; // height of surface to be created dwWidth : DWORD; // width of input surface case Integer of 0: ( lPitch : longint; dwBackBufferCount : DWORD; dwMipMapCount : DWORD; dwAlphaBitDepth : DWORD; dwReserved : DWORD; lpSurface : Pointer; ddckCKDestOverlay : DDCOLORKEY; ddckCKDestBlt : DDCOLORKEY; ddckCKSrcOverlay : DDCOLORKEY; ddckCKSrcBlt : DDCOLORKEY; ddpfPixelFormat : DDPIXELFORMAT; ddsCaps : DDSCAPS; ); 1: ( dwLinearSize : DWORD; Unknown1_2: DWORD; dwZBufferBitDepth : DWORD; ); 2: ( Unknown2_1: longint; Unknown2_2: DWORD; dwRefreshRate : DWORD; ); end; DDCOLORCONTROL = record dwSize : DWORD; dwFlags : DWORD; lBrightness : longint; lContrast : longint; lHue : longint; lSaturation : longint; lSharpness : longint; lGamma : longint; lColorEnable : longint; dwReserved1 : DWORD; end; DDCAPS = record dwSize :DWORD { 0}; // size of the DDDRIVERCAPS structure dwCaps :DWORD { 4}; // driver specific capabilities dwCaps2 :DWORD { 8}; // more driver specific capabilites dwCKeyCaps :DWORD { c}; // color key capabilities of the surface dwFXCaps :DWORD { 10}; // driver specific stretching and effects capabilites dwFXAlphaCaps :DWORD { 14}; // alpha driver specific capabilities dwPalCaps :DWORD { 18}; // palette capabilities dwSVCaps :DWORD { 1c}; // stereo vision capabilities dwAlphaBltConstBitDepths :DWORD { 20}; // DDBD_2,4,8 dwAlphaBltPixelBitDepths :DWORD { 24}; // DDBD_1,2,4,8 dwAlphaBltSurfaceBitDepths :DWORD { 28}; // DDBD_1,2,4,8 dwAlphaOverlayConstBitDepths :DWORD { 2c}; // DDBD_2,4,8 dwAlphaOverlayPixelBitDepths :DWORD { 30}; // DDBD_1,2,4,8 dwAlphaOverlaySurfaceBitDepths :DWORD { 34}; // DDBD_1,2,4,8 dwZBufferBitDepths :DWORD { 38}; // DDBD_8,16,24,32 dwVidMemTotal :DWORD { 3c}; // total amount of video memory dwVidMemFree :DWORD { 40}; // amount of free video memory dwMaxVisibleOverlays :DWORD { 44}; // maximum number of visible overlays dwCurrVisibleOverlays :DWORD { 48}; // current number of visible overlays dwNumFourCCCodes :DWORD { 4c}; // number of four cc codes dwAlignBoundarySrc :DWORD { 50}; // source rectangle alignment dwAlignSizeSrc :DWORD { 54}; // source rectangle byte size dwAlignBoundaryDest :DWORD { 58}; // dest rectangle alignment dwAlignSizeDest :DWORD { 5c}; // dest rectangle byte size dwAlignStrideAlign :DWORD { 60}; // stride alignment dwRops : array[0..DD_ROP_SPACE-1] of DWORD {64}; // ROPS supported ddsCaps :DDSCAPS { 84}; // DDSCAPS structure has all the general capabilities dwMinOverlayStretch :DWORD { 88}; // minimum overlay stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 dwMaxOverlayStretch :DWORD { 8c}; // maximum overlay stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 dwMinLiveVideoStretch :DWORD { 90}; // minimum live video stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 dwMaxLiveVideoStretch :DWORD { 94}; // maximum live video stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 dwMinHwCodecStretch :DWORD { 98}; // minimum hardware codec stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 dwMaxHwCodecStretch :DWORD { 9c}; // maximum hardware codec stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 dwReserved1 :DWORD { a0}; // reserved dwReserved2 :DWORD { a4}; // reserved dwReserved3 :DWORD { a8}; // reserved dwSVBCaps :DWORD { ac}; // driver specific capabilities for System->Vmem blts dwSVBCKeyCaps :DWORD { b0}; // driver color key capabilities for System->Vmem blts dwSVBFXCaps :DWORD { b4}; // driver FX capabilities for System->Vmem blts dwSVBRops : array[0..DD_ROP_SPACE-1] of DWORD{ b8}; // ROPS supported for System->Vmem blts dwVSBCaps : DWORD{ d8}; // driver specific capabilities for Vmem->System blts dwVSBCKeyCaps : DWORD{ dc}; // driver color key capabilities for Vmem->System blts dwVSBFXCaps : DWORD{ e0}; // driver FX capabilities for Vmem->System blts dwVSBRops : array[0..DD_ROP_SPACE-1] of DWORD{ e4}; // ROPS supported for Vmem->System blts dwSSBCaps : DWORD{104}; // driver specific capabilities for System->System blts dwSSBCKeyCaps : DWORD{108}; // driver color key capabilities for System->System blts dwSSBFXCaps : DWORD{10c}; // driver FX capabilities for System->System blts dwSSBRops : array[0..DD_ROP_SPACE-1] of DWORD{110}; // ROPS supported for System->System blts dwMaxVideoPorts : DWORD{130}; // maximum number of usable video ports dwCurrVideoPorts : DWORD{134}; // current number of video ports used dwSVBCaps2 : DWORD{138}; // more driver specific capabilities for System->Vmem blts dwNLVBCaps : DWORD{13c}; // driver specific capabilities for non-local->local vidmem blts dwNLVBCaps2 : DWORD{140}; // more driver specific capabilities non-local->local vidmem blts dwNLVBCKeyCaps : DWORD{144}; // driver color key capabilities for non-local->local vidmem blts dwNLVBFXCaps : DWORD{148}; // driver FX capabilities for non-local->local blts dwNLVBRops : array[0..DD_ROP_SPACE-1] of DWORD{14c}; // ROPS supported for non-local->local blts //dwReserved4 : DWORD{130}; // reserved //dwReserved5 : DWORD{134}; // reserved //dwReserved6 : DWORD{138}; // reserved end; LPDirectDrawSurface = ^IDirectDrawSurface; DDOVERLAYFX = record dwSize : DWORD; // size of structure dwAlphaEdgeBlendBitDepth : DWORD; // Bit depth used to specify constant for alpha edge blend dwAlphaEdgeBlend : DWORD; // Constant to use as alpha for edge blend dwReserved : DWORD; dwAlphaDestConstBitDepth : DWORD; // Bit depth used to specify alpha constant for destination case Integer of 0: ( dwAlphaDestConst : DWORD; dwAlphaSrcConstBitDepth : DWORD; dwAlphaSrcConst : DWORD; dckDestColorkey : DDCOLORKEY; dckSrcColorkey : DDCOLORKEY; dwDDFX : DWORD; dwFlags : DWORD; ); 1: ( lpDDSAlphaDest : IDirectDrawSurface; Unknown1_2: DWORD; lpDDSAlphaSrc : IDirectDrawSurface; ); end; DDBLTFX = record dwSize : DWORD; // size of structure dwDDFX : DWORD; // FX operations dwROP : DWORD; // Win32 raster operations dwDDROP : DWORD; // Raster operations new for DirectDraw dwRotationAngle : DWORD; // Rotation angle for blt dwZBufferOpCode : DWORD; // ZBuffer compares dwZBufferLow : DWORD; // Low limit of Z buffer dwZBufferHigh : DWORD; // High limit of Z buffer dwZBufferBaseDest : DWORD; // Destination base value dwZDestConstBitDepth : DWORD; // Bit depth used to specify Z constant for destination case Integer of 0: ( dwZDestConst : DWORD; dwZSrcConstBitDepth : DWORD; dwZSrcConst : DWORD; dwAlphaEdgeBlendBitDepth : DWORD; dwAlphaEdgeBlend : DWORD; dwReserved : DWORD; dwAlphaDestConstBitDepth : DWORD; dwAlphaDestConst : DWORD; dwAlphaSrcConstBitDepth : DWORD; dwAlphaSrcConst : DWORD; dwFillColor : DWORD; ddckDestColorkey : DDCOLORKEY; ddckSrcColorkey : DDCOLORKEY; ); 1: ( lpDDSZBufferDest : IDirectDrawSurface; Unknown1_2: DWORD; lpDDSZBufferSrc : IDirectDrawSurface; Unknown1_4: DWORD; Unknown1_5: DWORD; Unknown1_6: DWORD; Unknown1_7: DWORD; lpDDSAlphaDest : IDirectDrawSurface; Unknown1_9: DWORD; lpDDSAlphaSrc : IDirectDrawSurface; dwFillDepth : DWORD; ); 2: ( Unknown2_1: DWORD; Unknown2_2: DWORD; Unknown2_3: DWORD; Unknown2_4: DWORD; Unknown2_5: DWORD; Unknown2_6: DWORD; Unknown2_7: DWORD; Unknown2_8: DWORD; Unknown2_9: DWORD; Unknown2_10: DWORD; dwFillPixel : DWORD; ); 3: ( Unknown3_1: DWORD; Unknown3_2: DWORD; Unknown3_3: DWORD; Unknown3_4: DWORD; Unknown3_5: DWORD; Unknown3_6: DWORD; Unknown3_7: DWORD; Unknown3_8: DWORD; Unknown3_9: DWORD; Unknown3_10: DWORD; lpDDSPattern : IDirectDrawSurface; ); end; LPDDBLTFX = ^DDBLTFX; DDBLTBATCH = record lprDest : ^TRECT; lpDDSSrc : IDirectDrawSurface; lprSrc : ^TRECT; dwFlags : DWORD; lpDDBltFx : LPDDBLTFX; end; LPDIRECTDRAW = IDirectDraw; LPDIRECTDRAW2 = IDirectDraw2; LPDIRECTDRAWSURFACE2 = IDirectDrawSurface2; LPDIRECTDRAWSURFACE3 = IDirectDrawSurface3; LPDIRECTDRAWPALETTE = IDirectDrawPalette; LPDIRECTDRAWCLIPPER = IDirectDrawClipper; LPDIRECTDRAWCOLORCONTROL = IDirectDrawColorControl; // LPDDFXROP = ^DDFXROP; LPDDSURFACEDESC = ^DDSURFACEDESC; LPDDCOLORCONTROL = ^DDCOLORCONTROL; LPDDCAPS = ^DDCAPS; LPDDCOLORKEY = ^DDCOLORKEY; LPDDPIXELFORMAT = ^DDPIXELFORMAT; LPDDOVERLAYFX = ^DDOVERLAYFX; LPDDSCAPS = ^DDSCAPS; LPDDBLTBATCH = ^DDBLTBATCH; LPPALETTEENTRY=^TPALETTEENTRY; LPDDENUMMODESCALLBACK = function ( const lpDDSurfaceDesc: DDSURFACEDESC ; lpContext: Pointer ): HRESULT ; stdcall ; LPDDENUMSURFACESCALLBACK = function ( lpDDSurface: IDirectDrawSurface ; const lpDDSurfaceDesc: DDSURFACEDESC ; lpContext: Pointer ): HRESULT ; stdcall ; IDirectDraw = class ( IUnknown ) // ['{6C14DB80-A733-11CE-A521-0020AF0BE560}'] function Compact: HRESULT;virtual ; stdcall ; abstract ; function CreateClipper(Para0: DWORD;var Para1 : IDIRECTDRAWCLIPPER;Para2: IUnknown): HRESULT; virtual ; stdcall ; abstract ; function CreatePalette(Para0: DWORD;Para1: PPALETTEENTRY;var Para2: IDirectDrawPalette; Para3: IUnknown): HRESULT; virtual ; stdcall ; abstract ; function CreateSurface(const Para0: DDSURFACEDESC; var Para1: IDirectDrawSurface; Para2: IUnknown): HRESULT; virtual ; stdcall ; abstract ; function DuplicateSurface(Para0: IDirectDrawSurface; var Para1: IDirectDrawSurface): HRESULT; virtual ; stdcall ; abstract ; function EnumDisplayModes(Para0: DWORD;Para1: lpDDSURFACEDESC; Para2: Pointer; Para3: LPDDENUMMODESCALLBACK): HRESULT; virtual ; stdcall ; abstract ; function EnumSurfaces(Para0: DWORD;const Para1: DDSURFACEDESC; Para2: pointer; Para3: LPDDENUMSURFACESCALLBACK): HRESULT;virtual ; stdcall ; abstract ; function FlipToGDISurface: HRESULT; virtual ; stdcall ; abstract ; function GetCaps(var Para0: DDCAPS;var Para1: DDCAPS): HRESULT; virtual ; stdcall ; abstract ; function GetDisplayMode(const Para0: DDSURFACEDESC): HRESULT; virtual ; stdcall ; abstract ; function GetFourCCCodes(Para0: LPDWORD; Para1: LPDWORD): HRESULT; virtual ; stdcall ; abstract ; function GetGDISurface(var Para0: IDirectDrawSurface): HRESULT; virtual ; stdcall ; abstract ; function GetMonitorFrequency(Para0: LPDWORD): HRESULT; virtual ; stdcall ; abstract ; function GetScanLine(Para0: LPDWORD): HRESULT; virtual ; stdcall ; abstract ; function GetVerticalBlankStatus( var lpbIsInVB: BOOL): HRESULT; virtual ; stdcall ; abstract ; function Initialize(var Para0: PGUID): HRESULT; virtual ; stdcall ; abstract ; function RestoreDisplayMode: HRESULT; virtual ; stdcall ; abstract ; function SetCooperativeLevel(Para0: HWND; Para1: DWORD): HRESULT; virtual ; stdcall ; abstract ; function SetDisplayMode(Para0: DWORD; Para1: DWORD; Para2: DWORD): HRESULT; virtual ; stdcall ; abstract ; function WaitForVerticalBlank(Para0: DWORD; Para1: DWord): HRESULT; virtual ; stdcall ; abstract ; end; IDirectDrawSurface = class ( IUnknown ) // ['{6C14DB81-A733-11CE-A521-0020AF0BE560}'] function AddAttachedSurface(Para0: IDirectDrawSurface): HRESULT; virtual ; stdcall ; abstract ; function AddOverlayDirtyRect(const Para0: TRect): HRESULT; virtual ; stdcall ; abstract ; function Blt(const Para0: TRect; Para1: IDirectDrawSurface;const Para2: TREct; Para3: DWORD; const Para4: DDBLTFX): HRESULT; virtual ; stdcall ; abstract ; function BltBatch(const lpDDBltBatch: DDBLTBATCH; Para1: DWORD; Para2: DWORD): HRESULT; virtual ; stdcall ; abstract ; function BltFast(Para0: DWORD; Para1: DWORD; Para2: IDirectDrawSurface;const Para3: TRect; Para4: DWORD): HRESULT; virtual ; stdcall ; abstract ; function DeleteAttachedSurface(Para0: DWORD; Para1: IDirectDrawSurface): HRESULT; virtual ; stdcall ; abstract ; function EnumAttachedSurfaces(Para0: Pointer; Para1: LPDDENUMSURFACESCALLBACK): HRESULT; virtual ; stdcall ; abstract ; function EnumOverlayZOrders(Para0: DWORD; Para1: Pointer; Para2: LPDDENUMSURFACESCALLBACK): HRESULT; virtual ; stdcall ; abstract ; function Flip(Para0: IDirectDrawSurface; Para1: DWORD): HRESULT; virtual ; stdcall ; abstract ; function GetAttachedSurface( var lpDDSCaps: DDSCAPS ; var Para1: IDirectDrawSurface): HRESULT; virtual ; stdcall ; abstract ; function GetBltStatus(Para0: DWORD): HRESULT; virtual ; stdcall ; abstract ; function GetCaps(Para0: Pointer): HRESULT; virtual ; stdcall ; abstract ; function GetClipper(Para0: IDIRECTDRAWCLIPPER): HRESULT; virtual ; stdcall ; abstract ; function GetColorKey(Para0: DWORD; const Para1: DDCOLORKEY): HRESULT; virtual ; stdcall ; abstract ; function GetDC(var Para0: HDC): HRESULT; virtual ; stdcall ; abstract ; function GetFlipStatus(Para0: DWORD): HRESULT; virtual ; stdcall ; abstract ; function GetOverlayPosition(Para0: pointer; Para1: pointer): HRESULT; virtual ; stdcall ; abstract ; function GetPalette(var para0 : IDirectDrawPalette): HRESULT; virtual ; stdcall ; abstract ; function GetPixelFormat(const Para0: DDPIXELFORMAT): HRESULT; virtual ; stdcall ; abstract ; function GetSurfaceDesc(const Para0: DDSURFACEDESC): HRESULT; virtual ; stdcall ; abstract ; function Initialize(Para0: IDirectDraw;const Para1: DDSURFACEDESC): HRESULT; virtual ; stdcall ; abstract ; function IsLost: HRESULT; virtual ; stdcall ; abstract ; function Lock(Para0: PRect;var Para1: DDSURFACEDESC; Para2: DWORD; Para3: THandle): HRESULT; virtual ; stdcall ; abstract ; function ReleaseDC(Para0: HDC): HRESULT; virtual ; stdcall ; abstract ; function Restore: HRESULT; virtual ; stdcall ; abstract ; function SetClipper(Para0: IDIRECTDRAWCLIPPER): HRESULT; virtual ; stdcall ; abstract ; function SetColorKey(Para0: DWORD;const Para1: DDCOLORKEY): HRESULT; virtual ; stdcall ; abstract ; function SetOverlayPosition(Para0: longint; Para1: longint): HRESULT; virtual ; stdcall ; abstract ; function SetPalette(Para0: IDirectDrawPalette): HRESULT; virtual ; stdcall ; abstract ; function Unlock(Para0: Pointer): HRESULT; virtual ; stdcall ; abstract ; function UpdateOverlay(const Para0: TRect; Para1: IDirectDrawSurface;const Para2: TRect; Para3: DWORD;const Para4: DDOVERLAYFX): HRESULT; virtual ; stdcall ; abstract ; function UpdateOverlayDisplay(Para0: DWORD): HRESULT; virtual ; stdcall ; abstract ; function UpdateOverlayZOrder(Para0: DWORD; Para1: IDirectDrawSurface): HRESULT; virtual ; stdcall ; abstract ; end; IDirectDrawPalette = class ( IUnknown ) // ['{6C14DB84-A733-11CE-A521-0020AF0BE560}'] function GetCaps(Para0: LPDWORD): HRESULT; virtual ; stdcall ; abstract ; function GetEntries(Para0: DWORD; Para1: DWORD; Para2: DWORD; Para3: LPPALETTEENTRY): HRESULT; virtual ; stdcall ; abstract ; function Initialize(Para0: IDirectDraw; Para1: DWORD; Para2: LPPALETTEENTRY): HRESULT;virtual ; stdcall ; abstract ; function SetEntries(Para0: DWORD; Para1: DWORD; Para2: DWORD; Para3: LPPALETTEENTRY): HRESULT; virtual ; stdcall ; abstract ; end; IDirectDrawClipper = class ( IUnknown ) // ['{6C14DB85-A733-11CE-A521-0020AF0BE560}'] function GetClipList(const Para0: TRect; Para1: PRgnData;var Para2: DWord): HRESULT; virtual ; stdcall ; abstract ; function GetHWnd(var Para0: HWND): HRESULT; virtual ; stdcall ; abstract ; function Initialize(Para0: IDirectDraw; Para1: DWORD): HRESULT; virtual ; stdcall ; abstract ; function IsClipListChanged(var Para0: BOOL): HRESULT; virtual ; stdcall ; abstract ; function SetClipList(Para0: Pointer; Para1: DWORD): HRESULT; virtual ; stdcall ; abstract ; function SetHWnd(Para0: DWORD; Para1: HWND): HRESULT; virtual ; stdcall ; abstract ; end; IDirectDraw2 = class ( IUnknown ) // ['{B3A6F3E0-2B43-11CF-A2DE-00AA00B93356}'] function Compact: HRESULT; virtual ; stdcall ; abstract ; function CreateClipper(Para0: DWORD;var para1: IDIRECTDRAWCLIPPER; Para2: IUnknown): HRESULT; virtual ; stdcall ; abstract ; function CreatePalette(Para0: DWORD; Para1: LPPALETTEENTRY;var Para2: IDirectDrawPalette; Para3: IUnknown): HRESULT; virtual ; stdcall ; abstract ; function CreateSurface(const Para0: DDSURFACEDESC; var Para1: IDirectDrawSurface; Para2: IUnknown): HRESULT; virtual ; stdcall ; abstract ; function DuplicateSurface(Para0: IDirectDrawSurface; var Para1: IDirectDrawSurface): HRESULT; virtual ; stdcall ; abstract ; function EnumDisplayModes(Para0: DWORD;const Para1: DDSURFACEDESC; Para2: pointer; Para3: LPDDENUMMODESCALLBACK): HRESULT; virtual ; stdcall ; abstract ; function EnumSurfaces(Para0: DWORD;const Para1: DDSURFACEDESC; Para2: Pointer; Para3: LPDDENUMSURFACESCALLBACK): HRESULT; virtual ; stdcall ; abstract ; function FlipToGDISurface: HRESULT; virtual ; stdcall ; abstract ; function GetCaps(var Para0: DDCAPS;var Para1: DDCAPS): HRESULT; virtual ; stdcall ; abstract ; function GetDisplayMode(const Para0: DDSURFACEDESC): HRESULT; virtual ; stdcall ; abstract ; function GetFourCCCodes(Para0: LPDWORD; Para1: LPDWORD): HRESULT; virtual ; stdcall ; abstract ; function GetGDISurface(var Para0: IDirectDrawSurface): HRESULT; virtual ; stdcall ; abstract ; function GetMonitorFrequency(Para0: LPDWORD): HRESULT; virtual ; stdcall ; abstract ; function GetScanLine(Para0: LPDWORD): HRESULT; virtual ; stdcall ; abstract ; function GetVerticalBlankStatus(Para0: Pointer): HRESULT; virtual ; stdcall ; abstract ; function Initialize(var Para0: PGUID): HRESULT; virtual ; stdcall ; abstract ; function RestoreDisplayMode: HRESULT; virtual ; stdcall ; abstract ; function SetCooperativeLevel(Para0: HWND; Para1: DWORD): HRESULT; virtual ; stdcall ; abstract ; function SetDisplayMode(Para0: DWORD; Para1: DWORD; Para2: DWORD; Para3: DWORD; Para4: DWORD): HRESULT; virtual ; stdcall ; abstract ; function WaitForVerticalBlank(Para0: DWORD; Para1: DWord): HRESULT; virtual ; stdcall ; abstract ; {** Added in the v2 interface **} function GetAvailableVidMem(const Para0: DDSCAPS;var Para1: DWORD;var Para2: DWORD): HRESULT; virtual ; stdcall ; abstract ; end; IDirectDrawSurface2 = class ( IUnknown ) // ['{57805885-6eec-11cf-9441-a82303c10e27}'] function AddAttachedSurface(Para0: IDIRECTDRAWSURFACE2): HRESULT; virtual ; stdcall ; abstract ; function AddOverlayDirtyRect(const Para0: TRect): HRESULT; virtual ; stdcall ; abstract ; function Blt(const Para0: TRect; Para1: IDIRECTDRAWSURFACE2;const Para2:TRect; Para3: DWORD; const Para4: DDBLTFX): HRESULT; virtual ; stdcall ; abstract ; function BltBatch(const Para0: DDBLTBATCH; Para1: DWORD; Para2: DWORD): HRESULT; virtual ; stdcall ; abstract ; function BltFast(Para0: DWORD; Para1: DWORD; Para2: IDIRECTDRAWSURFACE2;const Para3: TRect; Para4: DWORD): HRESULT; virtual ; stdcall ; abstract ; function DeleteAttachedSurface(Para0: DWORD; Para1: IDIRECTDRAWSURFACE2): HRESULT; virtual ; stdcall ; abstract ; function EnumAttachedSurfaces(Para0: Pointer; Para1: LPDDENUMSURFACESCALLBACK): HRESULT; virtual ; stdcall ; abstract ; function EnumOverlayZOrders(Para0: DWORD; Para1: Pointer; Para2: LPDDENUMSURFACESCALLBACK): HRESULT; virtual ; stdcall ; abstract ; function Flip(Para0: IDIRECTDRAWSURFACE2; Para1: DWORD): HRESULT; virtual ; stdcall ; abstract ; function GetAttachedSurface(const Para0: DDSCAPS; var Para1: IDIRECTDRAWSURFACE2): HRESULT; virtual ; stdcall ; abstract ; function GetBltStatus(Para0: DWORD): HRESULT; virtual ; stdcall ; abstract ; function GetCaps(const Para0: DDSCAPS): HRESULT; virtual ; stdcall ; abstract ; function GetClipper(Para0: IDIRECTDRAWCLIPPER): HRESULT; virtual ; stdcall ; abstract ; function GetColorKey(Para0: DWORD;const Para1: DDCOLORKEY): HRESULT; virtual ; stdcall ; abstract ; function GetDC(var Para0: HDC): HRESULT; virtual ; stdcall ; abstract ; function GetFlipStatus(Para0: DWORD): HRESULT; virtual ; stdcall ; abstract ; function GetOverlayPosition(Para0: Pointer; Para1: Pointer): HRESULT; virtual ; stdcall ; abstract ; function GetPalette(var Para0: IDirectDrawPalette): HRESULT; virtual ; stdcall ; abstract ; function GetPixelFormat(const Para0: DDPIXELFORMAT): HRESULT; virtual ; stdcall ; abstract ; function GetSurfaceDesc(const Para0: DDSURFACEDESC): HRESULT; virtual ; stdcall ; abstract ; function Initialize(Para0: IDirectDraw;const Para1: DDSURFACEDESC): HRESULT; virtual ; stdcall ; abstract ; function IsLost: HRESULT; virtual ; stdcall ; abstract ; function Lock(Para0: PRect;var Para1: DDSURFACEDESC; Para2: DWORD; Para3: THandle): HRESULT; virtual ; stdcall ; abstract ; function ReleaseDC(Para0: HDC): HRESULT; virtual ; stdcall ; abstract ; function Restore: HRESULT; virtual ; stdcall ; abstract ; function SetClipper(Para0: IDIRECTDRAWCLIPPER): HRESULT; virtual ; stdcall ; abstract ; function SetColorKey(Para0: DWORD;const Para1: DDCOLORKEY): HRESULT; virtual ; stdcall ; abstract ; function SetOverlayPosition(Para0: longint; Para1: longint): HRESULT; virtual ; stdcall ; abstract ; function SetPalette(Para0: IDirectDrawPalette): HRESULT; virtual ; stdcall ; abstract ; function Unlock(Para0: Pointer): HRESULT; virtual ; stdcall ; abstract ; function UpdateOverlay(const Para0:TRect; Para1: IDIRECTDRAWSURFACE2;const Para2: TRect; Para3: DWORD;const Para4: DDOVERLAYFX): HRESULT; virtual ; stdcall ; abstract ; function UpdateOverlayDisplay(Para0: DWORD): HRESULT; virtual ; stdcall ; abstract ; function UpdateOverlayZOrder(Para0: DWORD; Para1: IDIRECTDRAWSURFACE2): HRESULT; virtual ; stdcall ; abstract ; {** Added in the v2 interface **} function GetDDInterface(var Para0: Pointer): HRESULT; virtual ; stdcall ; abstract ; function PageLock(Para0: DWORD): HRESULT; virtual ; stdcall ; abstract ; function PageUnlock(Para0: DWORD): HRESULT; virtual ; stdcall ; abstract ; end; IDirectDrawSurface3 = class ( IUnknown ) // ['{DA044E00-69B2-11D0-A1D5-00AA00B8DFBB}'] function AddAttachedSurface(Para0: IDIRECTDRAWSURFACE3): HRESULT; virtual ; stdcall ; abstract ; function AddOverlayDirtyRect(const Para0: TRect): HRESULT; virtual ; stdcall ; abstract ; function Blt(Para0: Pointer; Para1: IDIRECTDRAWSURFACE3; Para2: Pointer; Para3: DWORD; const Para4: DDBLTFX): HRESULT; virtual ; stdcall ; abstract ; function BltBatch(const Para0: DDBLTBATCH; Para1: DWORD; Para2: DWORD): HRESULT; virtual ; stdcall ; abstract ; function BltFast(Para0: DWORD; Para1: DWORD; Para2: IDIRECTDRAWSURFACE3; Para3: Pointer; Para4: DWORD): HRESULT; virtual ; stdcall ; abstract ; function DeleteAttachedSurface(Para0: DWORD; Para1: IDIRECTDRAWSURFACE3): HRESULT; virtual ; stdcall ; abstract ; function EnumAttachedSurfaces(Para0: Pointer; Para1: LPDDENUMSURFACESCALLBACK): HRESULT; virtual ; stdcall ; abstract ; function EnumOverlayZOrders(Para0: DWORD; Para1: Pointer; Para2: LPDDENUMSURFACESCALLBACK): HRESULT; virtual ; stdcall ; abstract ; function Flip(Para0: IDIRECTDRAWSURFACE3; Para1: DWORD): HRESULT; virtual ; stdcall ; abstract ; function GetAttachedSurface(const Para0: DDSCAPS; var Para1: IDIRECTDRAWSURFACE3): HRESULT; virtual ; stdcall ; abstract ; function GetBltStatus(Para0: DWORD): HRESULT; virtual ; stdcall ; abstract ; function GetCaps(const Para0: DDSCAPS): HRESULT; virtual ; stdcall ; abstract ; function GetClipper(para0: IDIRECTDRAWCLIPPER): HRESULT; virtual ; stdcall ; abstract ; function GetColorKey(Para0: DWORD;const Para1: DDCOLORKEY): HRESULT; virtual ; stdcall ; abstract ; function GetDC(var Para0: HDC): HRESULT; virtual ; stdcall ; abstract ; function GetFlipStatus(Para0: DWORD): HRESULT; virtual ; stdcall ; abstract ; function GetOverlayPosition(Para0: Pointer; Para1: Pointer): HRESULT; virtual ; stdcall ; abstract ; function GetPalette(var para0: IDirectDrawPalette): HRESULT; virtual ; stdcall ; abstract ; function GetPixelFormat(const Para0: DDPIXELFORMAT): HRESULT; virtual ; stdcall ; abstract ; function GetSurfaceDesc(const Para0: DDSURFACEDESC): HRESULT; virtual ; stdcall ; abstract ; function Initialize(Para0: IDirectDraw;const Para1: DDSURFACEDESC): HRESULT; virtual ; stdcall ; abstract ; function IsLost: HRESULT; virtual ; stdcall ; abstract ; function Lock(Para0: PRect;var Para1: DDSURFACEDESC; Para2: DWORD; Para3: THandle): HRESULT; virtual ; stdcall ; abstract ; function ReleaseDC(Para0: HDC): HRESULT; virtual ; stdcall ; abstract ; function Restore: HRESULT; virtual ; stdcall ; abstract ; function SetClipper(Para0: IDIRECTDRAWCLIPPER): HRESULT; virtual ; stdcall ; abstract ; function SetColorKey(Para0: DWORD;const Para1: DDCOLORKEY): HRESULT; virtual ; stdcall ; abstract ; function SetOverlayPosition(Para0: longint; Para1: longint): HRESULT; virtual ; stdcall ; abstract ; function SetPalette(Para0: IDirectDrawPalette): HRESULT; virtual ; stdcall ; abstract ; function Unlock(Para0: Pointer): HRESULT; virtual ; stdcall ; abstract ; function UpdateOverlay(const Para0: TRect; Para1: IDIRECTDRAWSURFACE3;const Para2: TRect; Para3: DWORD;const Para4: DDOVERLAYFX): HRESULT; virtual ; stdcall ; abstract ; function UpdateOverlayDisplay(Para0: DWORD): HRESULT; virtual ; stdcall ; abstract ; function UpdateOverlayZOrder(Para0: DWORD; Para1: IDIRECTDRAWSURFACE3): HRESULT; virtual ; stdcall ; abstract ; {** Added in the v2 interface **} function GetDDInterface(var Para0: Pointer): HRESULT; virtual ; stdcall ; abstract ; function PageLock(Para0: DWORD): HRESULT; virtual ; stdcall ; abstract ; function PageUnlock(Para0: DWORD): HRESULT; virtual ; stdcall ; abstract ; {** Added in the V3 interface **} function SetSurfaceDesc(const Para0: DDSURFACEDESC; Para1: DWORD): HRESULT; virtual ; stdcall ; abstract ; end; IDirectDrawColorControl = class ( IUnknown ) // ['{4B9F0EE0-0D7E-11D0-9B06-00A0C903A3B8}'] function GetColorControls(const Para0: DDCOLORCONTROL): HRESULT; virtual ; stdcall ; abstract ; function SetColorControls(const Para0: DDCOLORCONTROL): HRESULT; virtual ; stdcall ; abstract ; end; // function DirectDrawEnumerateW(lpCallback: LPDDENUMCALLBACKW; lpContext: Pointer): HRESULT; stdcall; // function DirectDrawEnumerateA(lpCallback: LPDDENUMCALLBACKA; lpContext: Pointer): HRESULT; stdcall; //type // LPDDENUMCALLBACK = LPDDENUMCALLBACKW; //const // DirectDrawEnumerate = DirectDrawEnumerateW; //type // LPDDENUMCALLBACK = LPDDENUMCALLBACKA; const // DirectDrawEnumerate = DirectDrawEnumerateA; REGSTR_KEY_DDHW_DESCRIPTION = 'Description'; REGSTR_KEY_DDHW_DRIVERNAME = 'DriverName'; REGSTR_PATH_DDHW = 'Hardware\DirectDrawDrivers'; DDCREATE_HARDWAREONLY = {viewgit}{/viewgit}000001; DDCREATE_EMULATIONONLY = {viewgit}{/viewgit}000002; function DirectDrawCreate(lpGUID: PGUID; var lplpDD: IDirectDraw; pUnkOuter: IUnknown): HRESULT;stdcall ; function DirectDrawCreateClipper(dwFlags: DWORD; var lplpDDClipper: IDIRECTDRAWCLIPPER; pUnkOuter: IUnknown): HRESULT;stdcall ; type HRESULT = longint; LPDDENUMCALLBACK = function ( lpGUID: PGUID ; lpDriverDescription: LPSTR ; lpDriverName: LPSTR ; lpContext: Pointer ): BOOL ;stdcall; type DDCAPS_DX3 = record dwSize : DWORD; // size of the DDDRIVERCAPS structure dwCaps : DWORD; // driver specific capabilities dwCaps2 : DWORD; // more driver specific capabilites dwCKeyCaps : DWORD; // color key capabilities of the surface dwFXCaps : DWORD; // driver specific stretching and effects capabilites dwFXAlphaCaps : DWORD; // alpha driver specific capabilities dwPalCaps : DWORD; // palette capabilities dwSVCaps : DWORD; // stereo vision capabilities dwAlphaBltConstBitDepths : DWORD; // DDBD_2,4,8 dwAlphaBltPixelBitDepths : DWORD; // DDBD_1,2,4,8 dwAlphaBltSurfaceBitDepths : DWORD; // DDBD_1,2,4,8 dwAlphaOverlayConstBitDepths : DWORD; // DDBD_2,4,8 dwAlphaOverlayPixelBitDepths : DWORD; // DDBD_1,2,4,8 dwAlphaOverlaySurfaceBitDepths : DWORD; // DDBD_1,2,4,8 dwZBufferBitDepths : DWORD; // DDBD_8,16,24,32 dwVidMemTotal : DWORD; // total amount of video memory dwVidMemFree : DWORD; // amount of free video memory dwMaxVisibleOverlays : DWORD; // maximum number of visible overlays dwCurrVisibleOverlays : DWORD; // current number of visible overlays dwNumFourCCCodes : DWORD; // number of four cc codes dwAlignBoundarySrc : DWORD; // source rectangle alignment dwAlignSizeSrc : DWORD; // source rectangle byte size dwAlignBoundaryDest : DWORD; // dest rectangle alignment dwAlignSizeDest : DWORD; // dest rectangle byte size dwAlignStrideAlign : DWORD; // stride alignment dwRops : array[0..DD_ROP_SPACE-1] of DWORD; // ROPS supported ddsCaps : DDSCAPS; // DDSCAPS structure has all the general capabilities dwMinOverlayStretch : DWORD; // minimum overlay stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 dwMaxOverlayStretch : DWORD; // maximum overlay stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 dwMinLiveVideoStretch : DWORD; // minimum live video stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 dwMaxLiveVideoStretch : DWORD; // maximum live video stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 dwMinHwCodecStretch : DWORD; // minimum hardware codec stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 dwMaxHwCodecStretch : DWORD; // maximum hardware codec stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 dwReserved1 : DWORD; // reserved dwReserved2 : DWORD; // reserved dwReserved3 : DWORD; // reserved dwSVBCaps : DWORD; // driver specific capabilities for System->Vmem blts dwSVBCKeyCaps : DWORD; // driver color key capabilities for System->Vmem blts dwSVBFXCaps : DWORD; // driver FX capabilities for System->Vmem blts dwSVBRops : array[0..DD_ROP_SPACE-1] of DWORD; // ROPS supported for System->Vmem blts dwVSBCaps : DWORD; // driver specific capabilities for Vmem->System blts dwVSBCKeyCaps : DWORD; // driver color key capabilities for Vmem->System blts dwVSBFXCaps : DWORD; // driver FX capabilities for Vmem->System blts dwVSBRops : array[0..DD_ROP_SPACE-1] of DWORD; // ROPS supported for Vmem->System blts dwSSBCaps : DWORD; // driver specific capabilities for System->System blts dwSSBCKeyCaps : DWORD; // driver color key capabilities for System->System blts dwSSBFXCaps : DWORD; // driver FX capabilities for System->System blts dwSSBRops : array[0..DD_ROP_SPACE-1] of DWORD; // ROPS supported for System->System blts dwReserved4 : DWORD; // reserved dwReserved5 : DWORD; // reserved dwReserved6 : DWORD; // reserved end; const DDSD_CAPS = {viewgit}{/viewgit}000001; // default { * dwHeight field is valid. } DDSD_HEIGHT = {viewgit}{/viewgit}000002; { * dwWidth field is valid. } DDSD_WIDTH = {viewgit}{/viewgit}000004; { * lPitch is valid. } DDSD_PITCH = {viewgit}{/viewgit}000008; { * dwBackBufferCount is valid. } DDSD_BACKBUFFERCOUNT = {viewgit}{/viewgit}000020; { * dwZBufferBitDepth is valid. } DDSD_ZBUFFERBITDEPTH = {viewgit}{/viewgit}000040; { * dwAlphaBitDepth is valid. } DDSD_ALPHABITDEPTH = {viewgit}{/viewgit}000080; { * lpSurface is valid. } DDSD_LPSURFACE = {viewgit}{/viewgit}000800; { * ddpfPixelFormat is valid. } DDSD_PIXELFORMAT = {viewgit}{/viewgit}001000; { * ddckCKDestOverlay is valid. } DDSD_CKDESTOVERLAY = {viewgit}{/viewgit}002000; { * ddckCKDestBlt is valid. } DDSD_CKDESTBLT = {viewgit}{/viewgit}004000; { * ddckCKSrcOverlay is valid. } DDSD_CKSRCOVERLAY = {viewgit}{/viewgit}008000; { * ddckCKSrcBlt is valid. } DDSD_CKSRCBLT = {viewgit}{/viewgit}010000; { * dwMipMapCount is valid. } DDSD_MIPMAPCOUNT = {viewgit}{/viewgit}020000; { * dwRefreshRate is valid } DDSD_REFRESHRATE = {viewgit}{/viewgit}040000; { * dwLinearSize is valid } DDSD_LINEARSIZE = {viewgit}{/viewgit}080000; { * All input fields are valid. } DDSD_ALL = {viewgit}{/viewgit}0ff9ee; { * DDCOLORCONTROL } { * lBrightness field is valid. } const DDCOLOR_BRIGHTNESS = {viewgit}{/viewgit}000001; { * lContrast field is valid. } DDCOLOR_CONTRAST = {viewgit}{/viewgit}000002; { * lHue field is valid. } DDCOLOR_HUE = {viewgit}{/viewgit}000004; { * lSaturation field is valid. } DDCOLOR_SATURATION = {viewgit}{/viewgit}000008; { * lSharpness field is valid. } DDCOLOR_SHARPNESS = {viewgit}{/viewgit}000010; { * lGamma field is valid. } DDCOLOR_GAMMA = {viewgit}{/viewgit}000020; { * lColorEnable field is valid. } DDCOLOR_COLORENABLE = {viewgit}{/viewgit}000040; {============================================================================ * * Direct Draw Capability Flags * * These flags are used to describe the capabilities of a given Surface. * All flags are bit flags. * *==========================================================================} {*************************************************************************** * * DIRECTDRAWSURFACE CAPABILITY FLAGS * ***************************************************************************} { * This bit is reserved. It should not be specified. } DDSCAPS_RESERVED1 = {viewgit}{/viewgit}000001; { * Indicates that this surface contains alpha-only information. * (To determine if a surface is RGBA/YUVA, the pixel format must be * interrogated.) } DDSCAPS_ALPHA = {viewgit}{/viewgit}000002; { * Indicates that this surface is a backbuffer. It is generally * set by CreateSurface when the DDSCAPS_FLIP capability bit is set. * It indicates that this surface is THE back buffer of a surface * flipping structure. DirectDraw supports N surfaces in a * surface flipping structure. Only the surface that immediately * precedeces the DDSCAPS_FRONTBUFFER has this capability bit set. * The other surfaces are identified as back buffers by the presence * of the DDSCAPS_FLIP capability, their attachment order, and the * absence of the DDSCAPS_FRONTBUFFER and DDSCAPS_BACKBUFFER * capabilities. The bit is sent to CreateSurface when a standalone * back buffer is being created. This surface could be attached to * a front buffer and/or back buffers to form a flipping surface * structure after the CreateSurface call. See AddAttachments for * a detailed description of the behaviors in this case. } DDSCAPS_BACKBUFFER = {viewgit}{/viewgit}000004; { * Indicates a complex surface structure is being described. A * complex surface structure results in the creation of more than * one surface. The additional surfaces are attached to the root * surface. The complex structure can only be destroyed by * destroying the root. } DDSCAPS_COMPLEX = {viewgit}{/viewgit}000008; { * Indicates that this surface is a part of a surface flipping structure. * When it is passed to CreateSurface the DDSCAPS_FRONTBUFFER and * DDSCAP_BACKBUFFER bits are not set. They are set by CreateSurface * on the resulting creations. The dwBackBufferCount field in the * DDSURFACEDESC structure must be set to at least 1 in order for * the CreateSurface call to succeed. The DDSCAPS_COMPLEX capability * must always be set with creating multiple surfaces through CreateSurface. } DDSCAPS_FLIP = {viewgit}{/viewgit}000010; { * Indicates that this surface is THE front buffer of a surface flipping * structure. It is generally set by CreateSurface when the DDSCAPS_FLIP * capability bit is set. * If this capability is sent to CreateSurface then a standalonw front buffer * is created. This surface will not have the DDSCAPS_FLIP capability. * It can be attached to other back buffers to form a flipping structure. * See AddAttachments for a detailed description of the behaviors in this * case. } DDSCAPS_FRONTBUFFER = {viewgit}{/viewgit}000020; { * Indicates that this surface is any offscreen surface that is not an overlay, * texture, zbuffer, front buffer, back buffer, or alpha surface. It is used * to identify plain vanilla surfaces. } DDSCAPS_OFFSCREENPLAIN = {viewgit}{/viewgit}000040; { * Indicates that this surface is an overlay. It may or may not be directly visible * depending on whether or not it is currently being overlayed onto the primary * surface. DDSCAPS_VISIBLE can be used to determine whether or not it is being * overlayed at the moment. } DDSCAPS_OVERLAY = {viewgit}{/viewgit}000080; { * Indicates that unique DirectDrawPalette objects can be created and * attached to this surface. } DDSCAPS_PALETTE = {viewgit}{/viewgit}000100; { * Indicates that this surface is the primary surface. The primary * surface represents what the user is seeing at the moment. } DDSCAPS_PRIMARYSURFACE = {viewgit}{/viewgit}000200; { * Indicates that this surface is the primary surface for the left eye. * The primary surface for the left eye represents what the user is seeing * at the moment with the users left eye. When this surface is created the * DDSCAPS_PRIMARYSURFACE represents what the user is seeing with the users * right eye. } DDSCAPS_PRIMARYSURFACELEFT = {viewgit}{/viewgit}000400; { * Indicates that this surface memory was allocated in system memory } DDSCAPS_SYSTEMMEMORY = {viewgit}{/viewgit}000800; { * Indicates that this surface can be used as a 3D texture. It does not * indicate whether or not the surface is being used for that purpose. } DDSCAPS_TEXTURE = {viewgit}{/viewgit}001000; { * Indicates that a surface may be a destination for 3D rendering. This * bit must be set in order to query for a Direct3D Device Interface * from this surface. } DDSCAPS_3DDEVICE = {viewgit}{/viewgit}002000; { * Indicates that this surface exists in video memory. } DDSCAPS_VIDEOMEMORY = {viewgit}{/viewgit}004000; { * Indicates that changes made to this surface are immediately visible. * It is always set for the primary surface and is set for overlays while * they are being overlayed and texture maps while they are being textured. } DDSCAPS_VISIBLE = {viewgit}{/viewgit}008000; { * Indicates that only writes are permitted to the surface. Read accesses * from the surface may or may not generate a protection fault, but the * results of a read from this surface will not be meaningful. READ ONLY. } DDSCAPS_WRITEONLY = {viewgit}{/viewgit}010000; { * Indicates that this surface is a z buffer. A z buffer does not contain * displayable information. Instead it contains bit depth information that is * used to determine which pixels are visible and which are obscured. } DDSCAPS_ZBUFFER = {viewgit}{/viewgit}020000; { * Indicates surface will have a DC associated longint term } DDSCAPS_OWNDC = {viewgit}{/viewgit}040000; { * Indicates surface should be able to receive live video } DDSCAPS_LIVEVIDEO = {viewgit}{/viewgit}080000; { * Indicates surface should be able to have a stream decompressed * to it by the hardware. } DDSCAPS_HWCODEC = {viewgit}{/viewgit}100000; { * Surface is a ModeX surface. * } DDSCAPS_MODEX = {viewgit}{/viewgit}200000; { * Indicates surface is one level of a mip-map. This surface will * be attached to other DDSCAPS_MIPMAP surfaces to form the mip-map. * This can be done explicitly, by creating a number of surfaces and * attaching them with AddAttachedSurface or by imiticitly by CreateSurface. * If this bit is set then DDSCAPS_TEXTURE must also be set. } DDSCAPS_MIPMAP = {viewgit}{/viewgit}400000; { * This bit is reserved. It should not be specified. } DDSCAPS_RESERVED2 = {viewgit}{/viewgit}800000; { * Indicates that memory for the surface is not allocated until the surface * is loaded (via the Direct3D texture Load() function). } DDSCAPS_ALLOCONLOAD = 000000; { * Indicates that the surface will recieve data from a video port. } DDSCAPS_VIDEOPORT = 000000; { * Indicates that a video memory surface is resident in true, local video * memory rather than non-local video memory. If this flag is specified then * so must DDSCAPS_VIDEOMEMORY. This flag is mutually exclusive with * DDSCAPS_NONLOCALVIDMEM. } DDSCAPS_LOCALVIDMEM = 000000; { * Indicates that a video memory surface is resident in non-local video * memory rather than true, local video memory. If this flag is specified * then so must DDSCAPS_VIDEOMEMORY. This flag is mutually exclusive with * DDSCAPS_LOCALVIDMEM. } DDSCAPS_NONLOCALVIDMEM = 000000; { * Indicates that this surface is a standard VGA mode surface, and not a * ModeX surface. (This flag will never be set in combination with the * DDSCAPS_MODEX flag). } DDSCAPS_STANDARDVGAMODE = 000000; { * Indicates that this surface will be an optimized surface. This flag is * currently only valid in conjunction with the DDSCAPS_TEXTURE flag. The surface * will be created without any underlying video memory until loaded. } DDSCAPS_OPTIMIZED = 000000; {*************************************************************************** * * DIRECTDRAW DRIVER CAPABILITY FLAGS * ***************************************************************************} { * Display hardware has 3D acceleration. } DDCAPS_3D = {viewgit}{/viewgit}000001; { * Indicates that DirectDraw will support only dest rectangles that are aligned * on DIRECTDRAWCAPS.dwAlignBoundaryDest boundaries of the surface, respectively. * READ ONLY. } DDCAPS_ALIGNBOUNDARYDEST = {viewgit}{/viewgit}000002; { * Indicates that DirectDraw will support only source rectangles whose sizes in * BYTEs are DIRECTDRAWCAPS.dwAlignSizeDest multiples, respectively. READ ONLY. } DDCAPS_ALIGNSIZEDEST = {viewgit}{/viewgit}000004; { * Indicates that DirectDraw will support only source rectangles that are aligned * on DIRECTDRAWCAPS.dwAlignBoundarySrc boundaries of the surface, respectively. * READ ONLY. } DDCAPS_ALIGNBOUNDARYSRC = {viewgit}{/viewgit}000008; { * Indicates that DirectDraw will support only source rectangles whose sizes in * BYTEs are DIRECTDRAWCAPS.dwAlignSizeSrc multiples, respectively. READ ONLY. } DDCAPS_ALIGNSIZESRC = {viewgit}{/viewgit}000010; { * Indicates that DirectDraw will create video memory surfaces that have a stride * alignment equal to DIRECTDRAWCAPS.dwAlignStride. READ ONLY. } DDCAPS_ALIGNSTRIDE = {viewgit}{/viewgit}000020; { * Display hardware is capable of blt operations. } DDCAPS_BLT = {viewgit}{/viewgit}000040; { * Display hardware is capable of asynchronous blt operations. } DDCAPS_BLTQUEUE = {viewgit}{/viewgit}000080; { * Display hardware is capable of color space conversions during the blt operation. } DDCAPS_BLTFOURCC = {viewgit}{/viewgit}000100; { * Display hardware is capable of stretching during blt operations. } DDCAPS_BLTSTRETCH = {viewgit}{/viewgit}000200; { * Display hardware is shared with GDI. } DDCAPS_GDI = {viewgit}{/viewgit}000400; { * Display hardware can overlay. } DDCAPS_OVERLAY = {viewgit}{/viewgit}000800; { * Set if display hardware supports overlays ban can not clip them. } DDCAPS_OVERLAYCANTCLIP = {viewgit}{/viewgit}001000; { * Indicates that overlay hardware is capable of color space conversions during * the overlay operation. } DDCAPS_OVERLAYFOURCC = {viewgit}{/viewgit}002000; { * Indicates that stretching can be done by the overlay hardware. } DDCAPS_OVERLAYSTRETCH = {viewgit}{/viewgit}004000; { * Indicates that unique DirectDrawPalettes can be created for DirectDrawSurfaces * other than the primary surface. } DDCAPS_PALETTE = {viewgit}{/viewgit}008000; { * Indicates that palette changes can be syncd with the veritcal refresh. } DDCAPS_PALETTEVSYNC = {viewgit}{/viewgit}010000; { * Display hardware can return the current scan line. } DDCAPS_READSCANLINE = {viewgit}{/viewgit}020000; { * Display hardware has stereo vision capabilities. DDSCAPS_PRIMARYSURFACELEFT * can be created. } DDCAPS_STEREOVIEW = {viewgit}{/viewgit}040000; { * Display hardware is capable of generating a vertical blank interrupt. } DDCAPS_VBI = {viewgit}{/viewgit}080000; { * Supports the use of z buffers with blt operations. } DDCAPS_ZBLTS = {viewgit}{/viewgit}100000; { * Supports Z Ordering of overlays. } DDCAPS_ZOVERLAYS = {viewgit}{/viewgit}200000; { * Supports color key } DDCAPS_COLORKEY = {viewgit}{/viewgit}400000; { * Supports alpha surfaces } DDCAPS_ALPHA = {viewgit}{/viewgit}800000; { * colorkey is hardware assisted(DDCAPS_COLORKEY will also be set) } DDCAPS_COLORKEYHWASSIST = 000000; { * no hardware support at all } DDCAPS_NOHARDWARE = 000000; { * Display hardware is capable of color fill with bltter } DDCAPS_BLTCOLORFILL = 000000; { * Display hardware is bank switched, and potentially very slow at * random access to VRAM. } DDCAPS_BANKSWITCHED = 000000; { * Display hardware is capable of depth filling Z-buffers with bltter } DDCAPS_BLTDEPTHFILL = 000000; { * Display hardware is capable of clipping while bltting. } DDCAPS_CANCLIP = 000000; { * Display hardware is capable of clipping while stretch bltting. } DDCAPS_CANCLIPSTRETCHED = 000000; { * Display hardware is capable of bltting to or from system memory } DDCAPS_CANBLTSYSMEM = 000000; {*************************************************************************** * * MORE DIRECTDRAW DRIVER CAPABILITY FLAGS (dwCaps2) * ***************************************************************************} { * Display hardware is certified } DDCAPS2_CERTIFIED = {viewgit}{/viewgit}000001; { * Driver cannot interleave 2D operations (lock and blt) to surfaces with * Direct3D rendering operations eetween calls to BeginScene() and EndScene() } DDCAPS2_NO2DDURING3DSCENE = {viewgit}{/viewgit}000002; { * Display hardware contains a video port } DDCAPS2_VIDEOPORT = {viewgit}{/viewgit}000004; { * The overlay can be automatically flipped according to the video port * VSYNCs, providing automatic doubled buffered display of video port * data using an overlay } DDCAPS2_AUTOFLIPOVERLAY = {viewgit}{/viewgit}000008; { * Overlay can display each field of interlaced data individually while * it is interleaved in memory without causing jittery artifacts. } DDCAPS2_CANBOBINTERLEAVED = {viewgit}{/viewgit}000010; { * Overlay can display each field of interlaced data individually while * it is not interleaved in memory without causing jittery artifacts. } DDCAPS2_CANBOBNONINTERLEAVED = {viewgit}{/viewgit}000020; { * The overlay surface contains color controls (brightness, sharpness, etc.) } DDCAPS2_COLORCONTROLOVERLAY = {viewgit}{/viewgit}000040; { * The primary surface contains color controls (gamma, etc.) } DDCAPS2_COLORCONTROLPRIMARY = {viewgit}{/viewgit}000080; { * RGBZ -> RGB supported for 16:16 RGB:Z } DDCAPS2_CANDROPZ16BIT = {viewgit}{/viewgit}000100; { * Driver supports non-local video memory. } DDCAPS2_NONLOCALVIDMEM = {viewgit}{/viewgit}000200; { * Dirver supports non-local video memory but has different capabilities for * non-local video memory surfaces. If this bit is set then so must * DDCAPS2_NONLOCALVIDMEM. } DDCAPS2_NONLOCALVIDMEMCAPS = {viewgit}{/viewgit}000400; { * Driver neither requires nor prefers surfaces to be pagelocked when performing * blts involving system memory surfaces } DDCAPS2_NOPAGELOCKREQUIRED = {viewgit}{/viewgit}000800; { * Driver can create surfaces which are wider than the primary surface } DDCAPS2_WIDESURFACES = {viewgit}{/viewgit}001000; { * Driver supports bob using software without using a video port } DDCAPS2_CANFLIPODDEVEN = {viewgit}{/viewgit}002000; {*************************************************************************** * * DIRECTDRAW FX ALPHA CAPABILITY FLAGS * ***************************************************************************} { * Supports alpha blending around the edge of a source color keyed surface. * For Blt. } DDFXALPHACAPS_BLTALPHAEDGEBLEND = {viewgit}{/viewgit}000001; { * Supports alpha information in the pixel format. The bit depth of alpha * information in the pixel format can be 1,2,4, or 8. The alpha value becomes * more opaque as the alpha value increases. (0 is transparent.) * For Blt. } DDFXALPHACAPS_BLTALPHAPIXELS = {viewgit}{/viewgit}000002; { * Supports alpha information in the pixel format. The bit depth of alpha * information in the pixel format can be 1,2,4, or 8. The alpha value * becomes more transparent as the alpha value increases. (0 is opaque.) * This flag can only be set if DDCAPS_ALPHA is set. * For Blt. } DDFXALPHACAPS_BLTALPHAPIXELSNEG = {viewgit}{/viewgit}000004; { * Supports alpha only surfaces. The bit depth of an alpha only surface can be * 1,2,4, or 8. The alpha value becomes more opaque as the alpha value increases. * (0 is transparent.) * For Blt. } DDFXALPHACAPS_BLTALPHASURFACES = {viewgit}{/viewgit}000008; { * The depth of the alpha channel data can range can be 1,2,4, or 8. * The NEG suffix indicates that this alpha channel becomes more transparent * as the alpha value increases. (0 is opaque.) This flag can only be set if * DDCAPS_ALPHA is set. * For Blt. } DDFXALPHACAPS_BLTALPHASURFACESNEG = {viewgit}{/viewgit}000010; { * Supports alpha blending around the edge of a source color keyed surface. * For Overlays. } DDFXALPHACAPS_OVERLAYALPHAEDGEBLEND = {viewgit}{/viewgit}000020; { * Supports alpha information in the pixel format. The bit depth of alpha * information in the pixel format can be 1,2,4, or 8. The alpha value becomes * more opaque as the alpha value increases. (0 is transparent.) * For Overlays. } DDFXALPHACAPS_OVERLAYALPHAPIXELS = {viewgit}{/viewgit}000040; { * Supports alpha information in the pixel format. The bit depth of alpha * information in the pixel format can be 1,2,4, or 8. The alpha value * becomes more transparent as the alpha value increases. (0 is opaque.) * This flag can only be set if DDCAPS_ALPHA is set. * For Overlays. } DDFXALPHACAPS_OVERLAYALPHAPIXELSNEG = {viewgit}{/viewgit}000080; { * Supports alpha only surfaces. The bit depth of an alpha only surface can be * 1,2,4, or 8. The alpha value becomes more opaque as the alpha value increases. * (0 is transparent.) * For Overlays. } DDFXALPHACAPS_OVERLAYALPHASURFACES = {viewgit}{/viewgit}000100; { * The depth of the alpha channel data can range can be 1,2,4, or 8. * The NEG suffix indicates that this alpha channel becomes more transparent * as the alpha value increases. (0 is opaque.) This flag can only be set if * DDCAPS_ALPHA is set. * For Overlays. } DDFXALPHACAPS_OVERLAYALPHASURFACESNEG = {viewgit}{/viewgit}000200; {*************************************************************************** * * DIRECTDRAW FX CAPABILITY FLAGS * ***************************************************************************} { * Uses arithmetic operations to stretch and shrink surfaces during blt * rather than pixel doubling techniques. Along the Y axis. } DDFXCAPS_BLTARITHSTRETCHY = {viewgit}{/viewgit}000020; { * Uses arithmetic operations to stretch during blt * rather than pixel doubling techniques. Along the Y axis. Only * works for x1, x2, etc. } DDFXCAPS_BLTARITHSTRETCHYN = {viewgit}{/viewgit}000010; { * Supports mirroring left to right in blt. } DDFXCAPS_BLTMIRRORLEFTRIGHT = {viewgit}{/viewgit}000040; { * Supports mirroring top to bottom in blt. } DDFXCAPS_BLTMIRRORUPDOWN = {viewgit}{/viewgit}000080; { * Supports arbitrary rotation for blts. } DDFXCAPS_BLTROTATION = {viewgit}{/viewgit}000100; { * Supports 90 degree rotations for blts. } DDFXCAPS_BLTROTATION90 = {viewgit}{/viewgit}000200; { * DirectDraw supports arbitrary shrinking of a surface along the * x axis (horizontal direction) for blts. } DDFXCAPS_BLTSHRINKX = {viewgit}{/viewgit}000400; { * DirectDraw supports integer shrinking (1x,2x,) of a surface * along the x axis (horizontal direction) for blts. } DDFXCAPS_BLTSHRINKXN = {viewgit}{/viewgit}000800; { * DirectDraw supports arbitrary shrinking of a surface along the * y axis (horizontal direction) for blts. } DDFXCAPS_BLTSHRINKY = {viewgit}{/viewgit}001000; { * DirectDraw supports integer shrinking (1x,2x,) of a surface * along the y axis (vertical direction) for blts. } DDFXCAPS_BLTSHRINKYN = {viewgit}{/viewgit}002000; { * DirectDraw supports arbitrary stretching of a surface along the * x axis (horizontal direction) for blts. } DDFXCAPS_BLTSTRETCHX = {viewgit}{/viewgit}004000; { * DirectDraw supports integer stretching (1x,2x,) of a surface a * along the x axis (horizontal direction) for blts. } DDFXCAPS_BLTSTRETCHXN = {viewgit}{/viewgit}008000; { * DirectDraw supports arbitrary stretching of a surface along the * y axis (horizontal direction) for blts. } DDFXCAPS_BLTSTRETCHY = {viewgit}{/viewgit}010000; { * DirectDraw supports integer stretching (1x,2x,) of a surface * along the y axis (vertical direction) for blts. } DDFXCAPS_BLTSTRETCHYN = {viewgit}{/viewgit}020000; { * Uses arithmetic operations to stretch and shrink surfaces during * overlay rather than pixel doubling techniques. Along the Y axis * for overlays. } DDFXCAPS_OVERLAYARITHSTRETCHY = {viewgit}{/viewgit}040000; { * Uses arithmetic operations to stretch surfaces during * overlay rather than pixel doubling techniques. Along the Y axis * for overlays. Only works for x1, x2, etc. } DDFXCAPS_OVERLAYARITHSTRETCHYN = {viewgit}{/viewgit}000008; { * DirectDraw supports arbitrary shrinking of a surface along the * x axis (horizontal direction) for overlays. } DDFXCAPS_OVERLAYSHRINKX = {viewgit}{/viewgit}080000; { * DirectDraw supports integer shrinking (1x,2x,) of a surface * along the x axis (horizontal direction) for overlays. } DDFXCAPS_OVERLAYSHRINKXN = {viewgit}{/viewgit}100000; { * DirectDraw supports arbitrary shrinking of a surface along the * y axis (horizontal direction) for overlays. } DDFXCAPS_OVERLAYSHRINKY = {viewgit}{/viewgit}200000; { * DirectDraw supports integer shrinking (1x,2x,) of a surface * along the y axis (vertical direction) for overlays. } DDFXCAPS_OVERLAYSHRINKYN = {viewgit}{/viewgit}400000; { * DirectDraw supports arbitrary stretching of a surface along the * x axis (horizontal direction) for overlays. } DDFXCAPS_OVERLAYSTRETCHX = {viewgit}{/viewgit}800000; { * DirectDraw supports integer stretching (1x,2x,) of a surface * along the x axis (horizontal direction) for overlays. } DDFXCAPS_OVERLAYSTRETCHXN = 000000; { * DirectDraw supports arbitrary stretching of a surface along the * y axis (horizontal direction) for overlays. } DDFXCAPS_OVERLAYSTRETCHY = 000000; { * DirectDraw supports integer stretching (1x,2x,) of a surface * along the y axis (vertical direction) for overlays. } DDFXCAPS_OVERLAYSTRETCHYN = 000000; { * DirectDraw supports mirroring of overlays across the vertical axis } DDFXCAPS_OVERLAYMIRRORLEFTRIGHT = 000000; { * DirectDraw supports mirroring of overlays across the horizontal axis } DDFXCAPS_OVERLAYMIRRORUPDOWN = 000000; {*************************************************************************** * * DIRECTDRAWRETEREO VIEW CAPABILITIES * ***************************************************************************} { * The stereo view is accomplished via enigma encoding. } DDSVCAPS_ENIGMA = {viewgit}{/viewgit}000001; { * The stereo view is accomplished via high frequency flickering. } DDSVCAPS_FLICKER = {viewgit}{/viewgit}000002; { * The stereo view is accomplished via red and blue filters applied * to the left and right eyes. All images must adapt their colorspaces * for this process. } DDSVCAPS_REDBLUE = {viewgit}{/viewgit}000004; { * The stereo view is accomplished with split screen technology. } DDSVCAPS_SPLIT = {viewgit}{/viewgit}000008; {*************************************************************************** * * DIRECTDRAWPALETTE CAPABILITIES * ***************************************************************************} { * Index is 4 bits. There are sixteen color entries in the palette table. } DDPCAPS_4BIT = {viewgit}{/viewgit}000001; { * Index is onto a 8 bit color index. This field is only valid with the * DDPCAPS_1BIT, DDPCAPS_2BIT or DDPCAPS_4BIT capability and the target * surface is in 8bpp. Each color entry is one byte longint and is an index * into destination surface's 8bpp palette. } DDPCAPS_8BITENTRIES = {viewgit}{/viewgit}000002; { * Index is 8 bits. There are 256 color entries in the palette table. } DDPCAPS_8BIT = {viewgit}{/viewgit}000004; { * Indicates that this DIRECTDRAWPALETTE should use the palette color array * passed into the lpDDColorArray parameter to initialize the DIRECTDRAWPALETTE * object. } DDPCAPS_INITIALIZE = {viewgit}{/viewgit}000008; { * This palette is the one attached to the primary surface. Changing this * table has immediate effect on the display unless DDPSETPAL_VSYNC is specified * and supported. } DDPCAPS_PRIMARYSURFACE = {viewgit}{/viewgit}000010; { * This palette is the one attached to the primary surface left. Changing * this table has immediate effect on the display for the left eye unless * DDPSETPAL_VSYNC is specified and supported. } DDPCAPS_PRIMARYSURFACELEFT = {viewgit}{/viewgit}000020; { * This palette can have all 256 entries defined } DDPCAPS_ALLOW256 = {viewgit}{/viewgit}000040; { * This palette can have modifications to it synced with the monitors * refresh rate. } DDPCAPS_VSYNC = {viewgit}{/viewgit}000080; { * Index is 1 bit. There are two color entries in the palette table. } DDPCAPS_1BIT = {viewgit}{/viewgit}000100; { * Index is 2 bit. There are four color entries in the palette table. } DDPCAPS_2BIT = {viewgit}{/viewgit}000200; {*************************************************************************** * * DIRECTDRAWPALETTE SETENTRY CONSTANTS * ***************************************************************************} {*************************************************************************** * * DIRECTDRAWPALETTE GETENTRY CONSTANTS * ***************************************************************************} { 0 is the only legal value } {*************************************************************************** * * DIRECTDRAWSURFACE SETPALETTE CONSTANTS * ***************************************************************************} {*************************************************************************** * * DIRECTDRAW BITDEPTH CONSTANTS * * NOTE: These are only used to indicate supported bit depths. These * are flags only, they are not to be used as an actual bit depth. The * absolute numbers 1, 2, 4, 8, 16, 24 and 32 are used to indicate actual * bit depths in a surface or for changing the display mode. * ***************************************************************************} { * 1 bit per pixel. } DDBD_1 = {viewgit}{/viewgit}004000; { * 2 bits per pixel. } DDBD_2 = {viewgit}{/viewgit}002000; { * 4 bits per pixel. } DDBD_4 = {viewgit}{/viewgit}001000; { * 8 bits per pixel. } DDBD_8 = {viewgit}{/viewgit}000800; { * 16 bits per pixel. } DDBD_16 = {viewgit}{/viewgit}000400; { * 24 bits per pixel. } DDBD_24 = {viewgit}{/viewgit}000200; { * 32 bits per pixel. } DDBD_32 = {viewgit}{/viewgit}000100; {*************************************************************************** * * DIRECTDRAWSURFACE SET/GET COLOR KEY FLAGS * ***************************************************************************} { * Set if the structure contains a color space. Not set if the structure * contains a single color key. } DDCKEY_COLORSPACE = {viewgit}{/viewgit}000001; { * Set if the structure specifies a color key or color space which is to be * used as a destination color key for blt operations. } DDCKEY_DESTBLT = {viewgit}{/viewgit}000002; { * Set if the structure specifies a color key or color space which is to be * used as a destination color key for overlay operations. } DDCKEY_DESTOVERLAY = {viewgit}{/viewgit}000004; { * Set if the structure specifies a color key or color space which is to be * used as a source color key for blt operations. } DDCKEY_SRCBLT = {viewgit}{/viewgit}000008; { * Set if the structure specifies a color key or color space which is to be * used as a source color key for overlay operations. } DDCKEY_SRCOVERLAY = {viewgit}{/viewgit}000010; {*************************************************************************** * * DIRECTDRAW COLOR KEY CAPABILITY FLAGS * ***************************************************************************} { * Supports transparent blting using a color key to identify the replaceable * bits of the destination surface for RGB colors. } DDCKEYCAPS_DESTBLT = {viewgit}{/viewgit}000001; { * Supports transparent blting using a color space to identify the replaceable * bits of the destination surface for RGB colors. } DDCKEYCAPS_DESTBLTCLRSPACE = {viewgit}{/viewgit}000002; { * Supports transparent blting using a color space to identify the replaceable * bits of the destination surface for YUV colors. } DDCKEYCAPS_DESTBLTCLRSPACEYUV = {viewgit}{/viewgit}000004; { * Supports transparent blting using a color key to identify the replaceable * bits of the destination surface for YUV colors. } DDCKEYCAPS_DESTBLTYUV = {viewgit}{/viewgit}000008; { * Supports overlaying using colorkeying of the replaceable bits of the surface * being overlayed for RGB colors. } DDCKEYCAPS_DESTOVERLAY = {viewgit}{/viewgit}000010; { * Supports a color space as the color key for the destination for RGB colors. } DDCKEYCAPS_DESTOVERLAYCLRSPACE = {viewgit}{/viewgit}000020; { * Supports a color space as the color key for the destination for YUV colors. } DDCKEYCAPS_DESTOVERLAYCLRSPACEYUV = {viewgit}{/viewgit}000040; { * Supports only one active destination color key value for visible overlay * surfaces. } DDCKEYCAPS_DESTOVERLAYONEACTIVE = {viewgit}{/viewgit}000080; { * Supports overlaying using colorke ong of the replaceable bits of the * surface being overlayed for YUV colors. } DDCKEYCAPS_DESTOVERLAYYUV = {viewgit}{/viewgit}000100; { * Supports transparent blting using the color key for the source with * this surface for RGB colors. } DDCKEYCAPS_SRCBLT = {viewgit}{/viewgit}000200; { * Supports transparent blting using a color space for the source with * this surface for RGB colors. } DDCKEYCAPS_SRCBLTCLRSPACE = {viewgit}{/viewgit}000400; { * Supports transparent blting using a color space for the source with * this surface for YUV colors. } DDCKEYCAPS_SRCBLTCLRSPACEYUV = {viewgit}{/viewgit}000800; { * Supports transparent blting using the color key for the source with * this surface for YUV colors. } DDCKEYCAPS_SRCBLTYUV = {viewgit}{/viewgit}001000; { * Supports overlays using the color key for the source with this * overlay surface for RGB colors. } DDCKEYCAPS_SRCOVERLAY = {viewgit}{/viewgit}002000; { * Supports overlays using a color space as the source color key for * the overlay surface for RGB colors. } DDCKEYCAPS_SRCOVERLAYCLRSPACE = {viewgit}{/viewgit}004000; { * Supports overlays using a color space as the source color key for * the overlay surface for YUV colors. } DDCKEYCAPS_SRCOVERLAYCLRSPACEYUV = {viewgit}{/viewgit}008000; { * Supports only one active source color key value for visible * overlay surfaces. } DDCKEYCAPS_SRCOVERLAYONEACTIVE = {viewgit}{/viewgit}010000; { * Supports overlays using the color key for the source with this * overlay surface for YUV colors. } DDCKEYCAPS_SRCOVERLAYYUV = {viewgit}{/viewgit}020000; { * there are no bandwidth trade-offs for using colorkey with an overlay } DDCKEYCAPS_NOCOSTOVERLAY = {viewgit}{/viewgit}040000; {*************************************************************************** * * DIRECTDRAW PIXELFORMAT FLAGS * ***************************************************************************} { * The surface has alpha channel information in the pixel format. } DDPF_ALPHAPIXELS = {viewgit}{/viewgit}000001; { * The pixel format contains alpha only information } DDPF_ALPHA = {viewgit}{/viewgit}000002; { * The FourCC code is valid. } DDPF_FOURCC = {viewgit}{/viewgit}000004; { * The surface is 4-bit color indexed. } DDPF_PALETTEINDEXED4 = {viewgit}{/viewgit}000008; { * The surface is indexed into a palette which stores indices * into the destination surface's 8-bit palette. } DDPF_PALETTEINDEXEDTO8 = {viewgit}{/viewgit}000010; { * The surface is 8-bit color indexed. } DDPF_PALETTEINDEXED8 = {viewgit}{/viewgit}000020; { * The RGB data in the pixel format structure is valid. } DDPF_RGB = {viewgit}{/viewgit}000040; { * The surface will accept pixel data in the format specified * and compress it during the write. } DDPF_COMPRESSED = {viewgit}{/viewgit}000080; { * The surface will accept RGB data and translate it during * the write to YUV data. The format of the data to be written * will be contained in the pixel format structure. The DDPF_RGB * flag will be set. } DDPF_RGBTOYUV = {viewgit}{/viewgit}000100; { * pixel format is YUV - YUV data in pixel format struct is valid } DDPF_YUV = {viewgit}{/viewgit}000200; { * pixel format is a z buffer only surface } DDPF_ZBUFFER = {viewgit}{/viewgit}000400; { * The surface is 1-bit color indexed. } DDPF_PALETTEINDEXED1 = {viewgit}{/viewgit}000800; { * The surface is 2-bit color indexed. } DDPF_PALETTEINDEXED2 = {viewgit}{/viewgit}001000; { * The surface contains Z information in the pixels } DDPF_ZPIXELS = {viewgit}{/viewgit}002000; {=========================================================================== * * * DIRECTDRAW CALLBACK FLAGS * * *==========================================================================} {*************************************************************************** * * DIRECTDRAW ENUMSURFACES FLAGS * ***************************************************************************} { * Enumerate all of the surfaces that meet the search criterion. } DDENUMSURFACES_ALL = {viewgit}{/viewgit}000001; { * A search hit is a surface that matches the surface description. } DDENUMSURFACES_MATCH = {viewgit}{/viewgit}000002; { * A search hit is a surface that does not match the surface description. } DDENUFAURFACES_NOMATCH = {viewgit}{/viewgit}000004; { * Enumerate the first surface that can be created which meets the search criterion. } DDENUMSURFACES_CANBECREATED = {viewgit}{/viewgit}000008; { * Enumerate the surfaces that already exist that meet the search criterion. } DDENUMSURFACES_DOESEXIST = {viewgit}{/viewgit}000010; {*************************************************************************** * * DIRECTDRAW SETDISPLAYMODE FLAGS * ***************************************************************************} { * The desired mode is a standard VGA mode } DDSDM_STANDARDVGAMODE = {viewgit}{/viewgit}000001; {*************************************************************************** * * DIRECTDRAW ENUMDISPLAYMODES FLAGS * ***************************************************************************} { * Enumerate Modes with different refresh rates. EnumDisplayModes guarantees * that a particular mode will be enumerated only once. This flag specifies whether * the refresh rate is taken into account when determining if a mode is unique. } DDEDM_REFRESHRATES = {viewgit}{/viewgit}000001; { * Enumerate VGA modes. Specify this flag if you wish to enumerate supported VGA * modes such as mode 0x13 in addition to the usual ModeX modes (which are always * enumerated if the application has previously called SetCooperativeLevel with the * DDSCL_ALLOWMODEX flag set). } DDEDM_STANDARDVGAMODES = {viewgit}{/viewgit}000002; {*************************************************************************** * * DIRECTDRAW SETCOOPERATIVELEVEL FLAGS * ***************************************************************************} { * Exclusive mode owner will be responsible for the entire primary surface. * GDI can be ignored. used with DD } DDSCL_FULLSCREEN = {viewgit}{/viewgit}000001; { * allow CTRL_ALT_DEL to work while in fullscreen exclusive mode } DDSCL_ALLOWREBOOT = {viewgit}{/viewgit}000002; { * prevents DDRAW from modifying the application window. * prevents DDRAW from minimize/restore the application window on activation. } DDSCL_NOWINDOWCHANGES = {viewgit}{/viewgit}000004; { * app wants to work as a regular Windows application } DDSCL_NORMAL = {viewgit}{/viewgit}000008; { * app wants exclusive access } DDSCL_EXCLUSIVE = {viewgit}{/viewgit}000010; { * app can deal with non-windows display modes } DDSCL_ALLOWMODEX = {viewgit}{/viewgit}000040; {*************************************************************************** * * DIRECTDRAW BLT FLAGS * ***************************************************************************} { * Use the alpha information in the pixel format or the alpha channel surface * attached to the destination surface as the alpha channel for this blt. } DDBLT_ALPHADEST = {viewgit}{/viewgit}000001; { * Use the dwConstAlphaDest field in the DDBLTFX structure as the alpha channel * for the destination surface for this blt. } DDBLT_ALPHADESTCONSTOVERRIDE = {viewgit}{/viewgit}000002; { * The NEG suffix indicates that the destination surface becomes more * transparent as the alpha value increases. (0 is opaque) } DDBLT_ALPHADESTNEG = {viewgit}{/viewgit}000004; { * Use the lpDDSAlphaDest field in the DDBLTFX structure as the alpha * channel for the destination for this blt. } DDBLT_ALPHADESTSURFACEOVERRIDE = {viewgit}{/viewgit}000008; { * Use the dwAlphaEdgeBlend field in the DDBLTFX structure as the alpha channel * for the edges of the image that border the color key colors. } DDBLT_ALPHAEDGEBLEND = {viewgit}{/viewgit}000010; { * Use the alpha information in the pixel format or the alpha channel surface * attached to the source surface as the alpha channel for this blt. } DDBLT_ALPHASRC = {viewgit}{/viewgit}000020; { * Use the dwConstAlphaSrc field in the DDBLTFX structure as the alpha channel * for the source for this blt. } DDBLT_ALPHASRCCONSTOVERRIDE = {viewgit}{/viewgit}000040; { * The NEG suffix indicates that the source surface becomes more transparent * as the alpha value increases. (0 is opaque) } DDBLT_ALPHASRCNEG = {viewgit}{/viewgit}000080; { * Use the lpDDSAlphaSrc field in the DDBLTFX structure as the alpha channel * for the source for this blt. } DDBLT_ALPHASRCSURFACEOVERRIDE = {viewgit}{/viewgit}000100; { * Do this blt asynchronously through the FIFO in the order received. If * there is no room in the hardware FIFO fail the call. } DDBLT_ASYNC = {viewgit}{/viewgit}000200; { * Uses the dwFillColor field in the DDBLTFX structure as the RGB color * to fill the destination rectangle on the destination surface with. } DDBLT_COLORFILL = {viewgit}{/viewgit}000400; { * Uses the dwDDFX field in the DDBLTFX structure to specify the effects * to use for the blt. } DDBLT_DDFX = {viewgit}{/viewgit}000800; { * Uses the dwDDROPS field in the DDBLTFX structure to specify the ROPS * that are not part of the Win32 API. } DDBLT_DDROPS = {viewgit}{/viewgit}001000; { * Use the color key associated with the destination surface. } DDBLT_KEYDEST = {viewgit}{/viewgit}002000; { * Use the dckDestColorkey field in the DDBLTFX structure as the color key * for the destination surface. } DDBLT_KEYDESTOVERRIDE = {viewgit}{/viewgit}004000; { * Use the color key associated with the source surface. } DDBLT_KEYSRC = {viewgit}{/viewgit}008000; { * Use the dckSrcColorkey field in the DDBLTFX structure as the color key * for the source surface. } DDBLT_KEYSRCOVERRIDE = {viewgit}{/viewgit}010000; { * Use the dwROP field in the DDBLTFX structure for the raster operation * for this blt. These ROPs are the same as the ones defined in the Win32 API. } DDBLT_ROP = {viewgit}{/viewgit}020000; { * Use the dwRotationAngle field in the DDBLTFX structure as the angle * (specified in 1/100th of a degree) to rotate the surface. } DDBLT_ROTATIONANGLE = {viewgit}{/viewgit}040000; { * Z-buffered blt using the z-buffers attached to the source and destination * surfaces and the dwZBufferOpCode field in the DDBLTFX structure as the * z-buffer opcode. } DDBLT_ZBUFFER = {viewgit}{/viewgit}080000; { * Z-buffered blt using the dwConstDest Zfield and the dwZBufferOpCode field * in the DDBLTFX structure as the z-buffer and z-buffer opcode respectively * for the destination. } DDBLT_ZBUFFERDESTCONSTOVERRIDE = {viewgit}{/viewgit}100000; { * Z-buffered blt using the lpDDSDestZBuffer field and the dwZBufferOpCode * field in the DDBLTFX structure as the z-buffer and z-buffer opcode * respectively for the destination. } DDBLT_ZBUFFERDESTOVERRIDE = {viewgit}{/viewgit}200000; { * Z-buffered blt using the dwConstSrcZ field and the dwZBufferOpCode field * in the DDBLTFX structure as the z-buffer and z-buffer opcode respectively * for the source. } DDBLT_ZBUFFERSRCCONSTOVERRIDE = {viewgit}{/viewgit}400000; { * Z-buffered blt using the lpDDSSrcZBuffer field and the dwZBufferOpCode * field in the DDBLTFX structure as the z-buffer and z-buffer opcode * respectively for the source. } DDBLT_ZBUFFERSRCOVERRIDE = {viewgit}{/viewgit}800000; { * wait until the device is ready to handle the blt * this will cause blt to not return DDERR_WASSTILLDRAWING } DDBLT_WAIT = 000000; { * Uses the dwFillDepth field in the DDBLTFX structure as the depth value * to fill the destination rectangle on the destination Z-buffer surface * with. } DDBLT_DEPTHFILL = 000000; {*************************************************************************** * * BLTFAST FLAGS * ***************************************************************************} DDBLTFAST_NOCOLORKEY = {viewgit}{/viewgit}000000; DDBLTFAST_SRCCOLORKEY = {viewgit}{/viewgit}000001; DDBLTFAST_DESTCOLORKEY = {viewgit}{/viewgit}000002; DDBLTFAST_WAIT = {viewgit}{/viewgit}000010; {*************************************************************************** * * FLIP FLAGS * ***************************************************************************} DDFLIP_WAIT = {viewgit}{/viewgit}000001; { * Indicates that the target surface contains the even field of video data. * This flag is only valid with an overlay surface. } DDFLIP_EVEN = {viewgit}{/viewgit}000002; { * Indicates that the target surface contains the odd field of video data. * This flag is only valid with an overlay surface. } DDFLIP_ODD = {viewgit}{/viewgit}000004; {*************************************************************************** * * DIRECTDRAW SURFACE OVERLAY FLAGS * ***************************************************************************} { * Use the alpha information in the pixel format or the alpha channel surface * attached to the destination surface as the alpha channel for the * destination overlay. } DDOVER_ALPHADEST = {viewgit}{/viewgit}000001; { * Use the dwConstAlphaDest field in the DDOVERLAYFX structure as the * destination alpha channel for this overlay. } DDOVER_ALPHADESTCONSTOVERRIDE = {viewgit}{/viewgit}000002; { * The NEG suffix indicates that the destination surface becomes more * transparent as the alpha value increases. } DDOVER_ALPHADESTNEG = {viewgit}{/viewgit}000004; { * Use the lpDDSAlphaDest field in the DDOVERLAYFX structure as the alpha * channel destination for this overlay. } DDOVER_ALPHADESTSURFACEOVERRIDE = {viewgit}{/viewgit}000008; { * Use the dwAlphaEdgeBlend field in the DDOVERLAYFX structure as the alpha * channel for the edges of the image that border the color key colors. } DDOVER_ALPHAEDGEBLEND = {viewgit}{/viewgit}000010; { * Use the alpha information in the pixel format or the alpha channel surface * attached to the source surface as the source alpha channel for this overlay. } DDOVER_ALPHASRC = {viewgit}{/viewgit}000020; { * Use the dwConstAlphaSrc field in the DDOVERLAYFX structure as the source * alpha channel for this overlay. } DDOVER_ALPHASRCCONSTOVERRIDE = {viewgit}{/viewgit}000040; { * The NEG suffix indicates that the source surface becomes more transparent * as the alpha value increases. } DDOVER_ALPHASRCNEG = {viewgit}{/viewgit}000080; { * Use the lpDDSAlphaSrc field in the DDOVERLAYFX structure as the alpha channel * source for this overlay. } DDOVER_ALPHASRCSURFACEOVERRIDE = {viewgit}{/viewgit}000100; { * Turn this overlay off. } DDOVER_HIDE = {viewgit}{/viewgit}000200; { * Use the color key associated with the destination surface. } DDOVER_KEYDEST = {viewgit}{/viewgit}000400; { * Use the dckDestColorkey field in the DDOVERLAYFX structure as the color key * for the destination surface } DDOVER_KEYDESTOVERRIDE = {viewgit}{/viewgit}000800; { * Use the color key associated with the source surface. } DDOVER_KEYSRC = {viewgit}{/viewgit}001000; { * Use the dckSrcColorkey field in the DDOVERLAYFX structure as the color key * for the source surface. } DDOVER_KEYSRCOVERRIDE = {viewgit}{/viewgit}002000; { * Turn this overlay on. } DDOVER_SHOW = {viewgit}{/viewgit}004000; { * Add a dirty rect to an emulated overlayed surface. } DDOVER_ADDDIRTYRECT = {viewgit}{/viewgit}008000; { * Redraw all dirty rects on an emulated overlayed surface. } DDOVER_REFRESHDIRTYRECTS = {viewgit}{/viewgit}010000; { * Redraw the entire surface on an emulated overlayed surface. } DDOVER_REFRESHALL = {viewgit}{/viewgit}020000; { * Use the overlay FX flags to define special overlay FX } DDOVER_DDFX = {viewgit}{/viewgit}080000; { * Autoflip the overlay when ever the video port autoflips } DDOVER_AUTOFLIP = {viewgit}{/viewgit}100000; { * Display each field of video port data individually without * causing any jittery artifacts } DDOVER_BOB = {viewgit}{/viewgit}200000; { * Indicates that bob/weave decisions should not be overridden by other * interfaces. } DDOVER_OVERRIDEBOBWEAVE = {viewgit}{/viewgit}400000; { * Indicates that the surface memory is composed of interleaved fields. } DDOVER_INTERLEAVED = {viewgit}{/viewgit}800000; {*************************************************************************** * * DIRECTDRAWSURFACE LOCK FLAGS * ***************************************************************************} { * The default. Set to indicate that Lock should return a valid memory pointer * to the top of the specified rectangle. If no rectangle is specified then a * pointer to the top of the surface is returned. } DDLOCK_SURFACEMEMORYPTR = {viewgit}{/viewgit}000000; // default { * Set to indicate that Lock should wait until it can obtain a valid memory * pointer before returning. If this bit is set, Lock will never return * DDERR_WASSTILLDRAWING. } DDLOCK_WAIT = {viewgit}{/viewgit}000001; { * Set if an event handle is being passed to Lock. Lock will trigger the event * when it can return the surface memory pointer requested. } DDLOCK_EVENT = {viewgit}{/viewgit}000002; { * Indicates that the surface being locked will only be read from. } DDLOCK_READONLY = {viewgit}{/viewgit}000010; { * Indicates that the surface being locked will only be written to } DDLOCK_WRITEONLY = {viewgit}{/viewgit}000020; { * Indicates that a system wide lock should not be taken when this surface * is locked. This has several advantages (cursor responsiveness, ability * to call more Windows functions, easier debugging) when locking video * memory surfaces. However, an application specifying this flag must * comply with a number of conditions documented in the help file. * Furthermore, this flag cannot be specified when locking the primary. } DDLOCK_NOSYSLOCK = {viewgit}{/viewgit}000800; {*************************************************************************** * * DIRECTDRAWSURFACE PAGELOCK FLAGS * ***************************************************************************} { * No flags defined at present } {*************************************************************************** * * DIRECTDRAWSURFACE PAGEUNLOCK FLAGS * ***************************************************************************} { * No flags defined at present } {*************************************************************************** * * DIRECTDRAWSURFACE BLT FX FLAGS * ***************************************************************************} { * If stretching, use arithmetic stretching along the Y axis for this blt. } DDBLTFX_ARITHSTRETCHY = {viewgit}{/viewgit}000001; { * Do this blt mirroring the surface left to right. Spin the * surface around its y-axis. } DDBLTFX_MIRRORLEFTRIGHT = {viewgit}{/viewgit}000002; { * Do this blt mirroring the surface up and down. Spin the surface * around its x-axis. } DDBLTFX_MIRRORUPDOWN = {viewgit}{/viewgit}000004; { * Schedule this blt to avoid tearing. } DDBLTFX_NOTEARING = {viewgit}{/viewgit}000008; { * Do this blt rotating the surface one hundred and eighty degrees. } DDBLTFX_ROTATE180 = {viewgit}{/viewgit}000010; { * Do this blt rotating the surface two hundred and seventy degrees. } DDBLTFX_ROTATE270 = {viewgit}{/viewgit}000020; { * Do this blt rotating the surface ninety degrees. } DDBLTFX_ROTATE90 = {viewgit}{/viewgit}000040; { * Do this z blt using dwZBufferLow and dwZBufferHigh as range values * specified to limit the bits copied from the source surface. } DDBLTFX_ZBUFFERRANGE = {viewgit}{/viewgit}000080; { * Do this z blt adding the dwZBufferBaseDest to each of the sources z values * before comparing it with the desting z values. } DDBLTFX_ZBUFFERBASEDEST = {viewgit}{/viewgit}000100; {*************************************************************************** * * DIRECTDRAWSURFACE OVERLAY FX FLAGS * ***************************************************************************} { * If stretching, use arithmetic stretching along the Y axis for this overlay. } DDOVERFX_ARITHSTRETCHY = {viewgit}{/viewgit}000001; { * Mirror the overlay across the vertical axis } DDOVERFX_MIRRORLEFTRIGHT = {viewgit}{/viewgit}000002; { * Mirror the overlay across the horizontal axis } DDOVERFX_MIRRORUPDOWN = {viewgit}{/viewgit}000004; {*************************************************************************** * * DIRECTDRAW WAITFORVERTICALBLANK FLAGS * ***************************************************************************} { * return when the vertical blank interval begins } DDWAITVB_BLOCKBEGIN = {viewgit}{/viewgit}000001; { * set up an event to trigger when the vertical blank begins } DDWAITVB_BLOCKBEGINEVENT = {viewgit}{/viewgit}000002; { * return when the vertical blank interval ends and display begins } DDWAITVB_BLOCKEND = {viewgit}{/viewgit}000004; {*************************************************************************** * * DIRECTDRAW GETFLIPSTATUS FLAGS * ***************************************************************************} { * is it OK to flip now? } DDGFS_CANFLIP = {viewgit}{/viewgit}000001; { * is the last flip finished? } DDGFS_ISFLIPDONE = {viewgit}{/viewgit}000002; {*************************************************************************** * * DIRECTDRAW GETBLTSTATUS FLAGS * ***************************************************************************} { * is it OK to blt now? } DDGBS_CANBLT = {viewgit}{/viewgit}000001; { * is the blt to the surface finished? } DDGBS_ISBLTDONE = {viewgit}{/viewgit}000002; {*************************************************************************** * * DIRECTDRAW ENUMOVERLAYZORDER FLAGS * ***************************************************************************} { * Enumerate overlays back to front. } DDENUMOVERLAYZ_BACKTOFRONT = {viewgit}{/viewgit}000000; { * Enumerate overlays front to back } DDENUMOVERLAYZ_FRONTTOBACK = {viewgit}{/viewgit}000001; {*************************************************************************** * * DIRECTDRAW UPDATEOVERLAYZORDER FLAGS * ***************************************************************************} { * Send overlay to front } DDOVERZ_SENDTOFRONT = {viewgit}{/viewgit}000000; { * Send overlay to back } DDOVERZ_SENDTOBACK = {viewgit}{/viewgit}000001; { * Move Overlay forward } DDOVERZ_MOVEFORWARD = {viewgit}{/viewgit}000002; { * Move Overlay backward } DDOVERZ_MOVEBACKWARD = {viewgit}{/viewgit}000003; { * Move Overlay in front of relative surface } DDOVERZ_INSERTINFRONTOF = {viewgit}{/viewgit}000004; { * Move Overlay in back of relative surface } DDOVERZ_INSERTINBACKOF = {viewgit}{/viewgit}000005; {=========================================================================== * * * DIRECTDRAW RETURN CODES * * The return values from DirectDraw Commands and Surface that return an HRESULT * are codes from DirectDraw concerning the results of the action * requested by DirectDraw. * *==========================================================================} { * Status is OK * * Issued by: DirectDraw Commands and all callbacks } DD_OK = 0; {*************************************************************************** * * DIRECTDRAW ENUMCALLBACK RETURN VALUES * * EnumCallback returns are used to control the flow of the DIRECTDRAW and * DIRECTDRAWSURFACE object enumerations. They can only be returned by * enumeration callback routines. * ***************************************************************************} { * stop the enumeration } DDENUMRET_CANCEL = 0; { * continue the enumeration } DDENUMRET_OK = 1; DDERR_GENERIC = E_FAIL; DDERR_INVALIDPARAMS = E_INVALIDARG; DDERR_OUTOFMEMORY = E_OUTOFMEMORY; DDERR_NOTINITIALIZED = CO_E_NOTINITIALIZED; function DirectDrawEnumerate ( lpCallback: LPDDENUMCALLBACK ; lpContext: Pointer ): HRESULT ;stdcall ; implementation function DirectDrawEnumerate ; external 'DDRAW.DLL' name 'DirectDrawEnumerateA' ; function DirectDrawCreate ; external 'DDRAW.DLL' ; function DirectDrawCreateClipper ; external 'DDRAW.DLL' ; end.