Direct Draw Header I use for above code, I dont know if somethings wrong or not
Code:// This ddraw unit is for windows mobile 5 or above unit ddraw; interface uses windows; // // Copyright (c) Microsoft Corporation. All rights reserved. // // // Use of this source code is subject to the terms of the Microsoft end-user // license agreement (EULA) under which you licensed this SOFTWARE PRODUCT. // If you did not accept the terms of the EULA, you are not authorized to use // this source code. For a copy of the EULA, please see the LICENSE.RTF on your // install media. // {==========================================================================; * * File: ddraw.h * Content: DirectDraw include file * ************************************************************************** } const IID_IDirectDraw: TGUID = '{9C59509A-39BD-11D1-8C4A-00C04FD930C5}'; IID_IDirectDrawSurface: TGUID = '{0b0e83e4-f37f-11d2-8b15-00c04F689292}'; IID_IDirectDrawPalette: TGUID = '{6C14DB84-A733-11CE-A521-0020AF0BE560}'; IID_IDirectDrawClipper: TGUID = '{6C14DB85-A733-11CE-A521-0020AF0BE560}'; IID_IDirectDrawColorControl: TGUID = '{4B9F0EE0-0D7E-11D0-9B06-00A0C903A3B8}'; IID_IDirectDrawGammaControl: TGUID = '{69C11C3E-B46B-11D1-AD7A-00C04FC29B4E}'; type IDirectDraw = interface; IDirectDrawSurface = interface; IDirectDrawPalette = interface; IDirectDrawClipper = interface; IDirectDrawColorControl = interface; IDirectDrawGammaControl = interface; // // DirectDraw Structures // // // DDCOLORKEY // PDDCOLORKEY = ^TDDCOLORKEY; TDDCOLORKEY = record dwColorSpaceLowValue : DWORD;{ low boundary of color space that is to } { be treated as Color Key, inclusive } dwColorSpaceHighValue : DWORD; { high boundary of color space that is } { to be treated as Color Key, inclusive } end; DDCOLORKEY = TDDCOLORKEY; LPDDCOLORKEY = PDDCOLORKEY; // // DDARGB // Generic pixel format with 8-bit RGB and alpha components // PDDARGB = ^TDDARGB; TDDARGB = record blue : BYTE; green : BYTE; red : BYTE; alpha : BYTE; end; DDARGB = TDDARGB; LPDDARGB = PDDARGB; // // DDBLTFX // PDDBLTFX = ^TDDBLTFX; TDDBLTFX = record dwSize : DWORD;{ size of structure } dwROP : DWORD;{ Win32 raster operations } dwFillColor : DWORD; { color in RGB or Palettized (Brush value for Win32 ROPs) } ddckDestColorkey : TDDCOLORKEY; { DestColorkey override } ddckSrcColorkey : TDDCOLORKEY;{ SrcColorkey override } end; DDBLTFX = TDDBltFX; LPDDBLTFX = PDDBltFX; // // DDALPHABLTFX // PDDALPHABLTFX = ^TDDALPHABLTFX; TDDALPHABLTFX = record dwSize : DWORD;{ size of structure } ddargbScaleFactors : TDDARGB;{ Constant scaling factors } dwFillColor : DWORD;{ color in ARGB or Palettized } end; DDALPHABLTFX = TDDALPHABLTFX; LPDDALPHABLTFX = PDDALPHABLTFX; // // DDSCAPS // Caps bits defined below. // PDDSCaps = ^TDDSCaps; TDDSCaps = record dwCaps: DWORD; // capabilities of surface wanted end; DDSCAPS = TDDSCaps; LPDDSCAPS = PDDSCaps; // // DDCAPS // const DD_ROP_SPACE = 256 div 32; { space required to store ROP array } type PDDCAPS = ^TDDCAPS; TDDCAPS = record dwSize : DWORD; { size of the DDCAPS structure } { Surface capabilities } dwVidMemTotal : DWORD;{ total amount of video memory } dwVidMemFree : DWORD; { amount of free video memory } dwVidMemStride : DWORD;{ video memory stride (0 if linear) } ddsCaps : TDDSCAPS;{ surface caps } dwNumFourCCCodes : DWORD; { number of four cc codes } { palette capabilities } dwPalCaps : DWORD;{ Palette capabilities } { Hardware blitting capabilities } dwBltCaps : DWORD; { driver specific capabilities } dwCKeyCaps : DWORD;{ color key blitting capabilities } dwAlphaCaps : DWORD;{ alpha blitting capabilities } dwRops : array[0..(DD_ROP_SPACE)-1] of DWORD;{ ROPS supported } { general overlay capabilities. } dwOverlayCaps : DWORD;{ Overlay capabilities } dwMaxVisibleOverlays : DWORD;{ maximum number of visible overlays } dwCurrVisibleOverlays : DWORD;{ current number of visible overlays } dwAlignBoundarySrc : DWORD; { source rectangle alignment } dwAlignSizeSrc : DWORD;{ source rectangle byte size } dwAlignBoundaryDest : DWORD;{ dest rectangle alignment } dwAlignSizeDest : DWORD; { dest rectangle byte size } 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 } { Miscalenous capabilies } dwMiscCaps : DWORD; end; DDCAPS = TDDCAPS; LPDDCAPS = PDDCAPS; // // DDPIXELFORMAT // type PDDPixelFormat = ^TDDPixelFormat; TDDPixelFormat = record dwSize: DWORD; // size of structure dwFlags: DWORD; // pixel format flags dwFourCC: DWORD; // (FOURCC code) case Integer of 0: ( dwRGBBitCount: DWORD; // how many bits per pixel dwYUVBitCount: DWORD; // how many bits per pixel dwAlphaBitDepth: DWORD; // how many bits for alpha channels ); 1: ( dwRBitMask : DWORD; // mask for red bit dwYBitMask : DWORD ; // mask for Y bits ); 2: ( dwGBitMask : DWORD; // mask for green bits dwUBitMask : DWORD; // mask for U bits ); 3: ( dwBBitMask : DWORD; // mask for blue bits dwVBitMask : DWORD; // mask for V bits ); 4: ( dwRGBAlphaBitMask : DWORD; // mask for alpha channel ); end; DDPIXELFORMAT = TDDPixelFormat; LPDDPIXELFORMAT = PDDPixelFormat; const DDPF_ALPHAPIXELS = $00000001; DDPF_ALPHA = $00000002; DDPF_FOURCC = $00000004; DDPF_PALETTEINDEXED = $00000020; DDPF_RGB = $00000040; DDPF_ALPHAPREMULT = $00008000; DDPF_VALID = DDPF_ALPHAPIXELS or DDPF_ALPHA or DDPF_FOURCC or DDPF_PALETTEINDEXED or DDPF_RGB or DDPF_ALPHAPREMULT; {DDSURFACEDESC} type PDDSurfaceDesc = ^TDDSurfaceDesc; TDDSurfaceDesc = 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 lPitch : LONGint; // bytes to next line down (return value only) lXPitch : LONGint; // bytes to next pixel right (return value only) dwBackBufferCount : DWORD; // number of back buffers requested dwRefreshRate : DWORD; // refresh rate (used when display mode is described) lpSurface : pointer; // pointer to the associated surface memory ddckCKDestOverlay : DDCOLORKEY; // color key for destination overlay use ddckCKDestBlt : DDCOLORKEY; // color key for destination blt use ddckCKSrcOverlay : DDCOLORKEY; // color key for source overlay use ddckCKSrcBlt : DDCOLORKEY; // color key for source blt use ddpfPixelFormat : DDPIXELFORMAT; // pixel format description of the surface ddsCaps : TDDSCAPS; // direct draw surface capabilities dwSurfaceSize : DWORD; // Surface size, in bytes end; DDSURFACEDESC = TDDSurfaceDesc; LPDDSURFACEDESC = PDDSurfaceDesc; { * DDSURFACEDESC dwFlags values. } const DDSD_CAPS = $00000001; DDSD_HEIGHT = $00000002; DDSD_WIDTH = $00000004; DDSD_PITCH = $00000008; DDSD_XPITCH = $00000010; DDSD_BACKBUFFERCOUNT = $00000020; DDSD_LPSURFACE = $00000800; DDSD_PIXELFORMAT = $00001000; DDSD_CKDESTOVERLAY = $00002000; DDSD_CKDESTBLT = $00004000; DDSD_CKSRCOVERLAY = $00008000; DDSD_CKSRCBLT = $00010000; DDSD_REFRESHRATE = $00040000; DDSD_SURFACESIZE = $00080000; DDSD_VALID = DDSD_CAPS or DDSD_HEIGHT or DDSD_WIDTH or DDSD_PITCH or DDSD_XPITCH or DDSD_BACKBUFFERCOUNT or DDSD_LPSURFACE or DDSD_PIXELFORMAT or DDSD_CKDESTOVERLAY or DDSD_CKDESTBLT or DDSD_CKSRCOVERLAY or DDSD_CKSRCBLT or DDSD_REFRESHRATE or DDSD_SURFACESIZE; DDSD_ENUM_VALID = DDSD_CAPS or DDSD_HEIGHT or DDSD_WIDTH or DDSD_PIXELFORMAT; // //DDOVERLAYFX // type PDDOVERLAYFX = ^TDDOVERLAYFX; TDDOVERLAYFX = record dwSize : DWORD;{ size of structure } dwAlphaConstBitDepth : DWORD;{ Bit depth used to specify alpha constant. } dwAlphaConst : DWORD; { Constant to use as alpha channel. } dckDestColorkey : TDDCOLORKEY;{ DestColorkey override } dckSrcColorkey : TDDCOLORKEY;{ DestColorkey override } end; DDOVERLAYFX = TDDOVERLAYFX; LPDDOVERLAYFX = PDDOVERLAYFX; // // DDGAMMARAMP // PDDGAMMARAMP = ^TDDGAMMARAMP; TDDGAMMARAMP = record red : array[0..255] of WORD; green : array[0..255] of WORD; blue : array[0..255] of WORD; end; DDGAMMARAMP = TDDGAMMARAMP; LPDDGAMMARAMP = PDDGAMMARAMP; // // This is the structure within which DirectDraw returns data about the current graphics driver and chipset // const MAX_DDDEVICEID_STRING = 512; type PDDDEVICEIDENTIFIER = ^TDDDEVICEIDENTIFIER; TDDDEVICEIDENTIFIER = record // * These elements are for presentation to the user only. They should not be used to identify particular // * drivers, since this is unreliable and many different strings may be associated with the same // * device, and the same driver from different vendors. szDriver : array[0..(MAX_DDDEVICEID_STRING)-1] of wchar; szDescription : array[0..(MAX_DDDEVICEID_STRING)-1] of wchar; { * This element is the version of the DirectDraw/3D driver. It is legal to do <, > comparisons * on the whole 64 bits. Caution should be exercised if you use this element to identify problematic * drivers. It is recommended that guidDeviceIdentifier is used for this purpose. * * This version has the form: * wProduct = HIWORD(liDriverVersion.HighPart) * wVersion = LOWORD(liDriverVersion.HighPart) * wSubVersion = HIWORD(liDriverVersion.LowPart) * wBuild = LOWORD(liDriverVersion.LowPart) } liDriverVersion : LARGE_INTEGER; { * These elements can be used to identify particular chipsets. Use with extreme caution. * dwVendorId Identifies the manufacturer. May be zero if unknown. * dwDeviceId Identifies the type of chipset. May be zero if unknown. * dwSubSysId Identifies the subsystem, typically this means the particular board. May be zero if unknown. * dwRevision Identifies the revision level of the chipset. May be zero if unknown. } dwVendorId : DWORD; dwDeviceId : DWORD; dwSubSysId : DWORD; dwRevision : DWORD; { * This element can be used to check changes in driver/chipset. This GUID is a unique identifier for the * driver/chipset pair. Use this element if you wish to track changes to the driver/chipset in order to * reprofile the graphics subsystem. * This element can also be used to identify particular problematic drivers. } guidDeviceIdentifier : TGUID; end; DDDEVICEIDENTIFIER = TDDDEVICEIDENTIFIER; LPDDDEVICEIDENTIFIER = PDDDEVICEIDENTIFIER; // // DDCOLORCONTROL // type PDDColorControl = ^TDDColorControl; TDDColorControl = record dwSize: DWORD; dwFlags: DWORD; lBrightness: Longint; lContrast: Longint; lHue: Longint; lSaturation: Longint; lSharpness: Longint; lGamma: Longint; lColorEnable: Longint; end; DDCOLORCONTROL = TDDColorControl; LPDDCOLORCONTROL = PDDCOLORCONTROL; // // DDCOLORCONTROL dwFlags values. // const DDCOLOR_BRIGHTNESS = $00000001; DDCOLOR_CONTRAST = $00000002; DDCOLOR_HUE = $00000004; DDCOLOR_SATURATION = $00000008; DDCOLOR_SHARPNESS = $00000010; DDCOLOR_GAMMA = $00000020; DDCOLOR_COLORENABLE = $00000040; DDCOLOR_VALID = DDCOLOR_BRIGHTNESS or DDCOLOR_CONTRAST or DDCOLOR_HUE or DDCOLOR_SATURATION or DDCOLOR_SHARPNESS or DDCOLOR_GAMMA or DDCOLOR_COLORENABLE; // // API's // type TDDENUMCALLBACKEX = function(lpGUID: PGUID; lpDriverDescription: LPWSTR; lpDriverName: LPWSTR; lpContext: Pointer; Monitor: HMonitor): BOOL; stdcall; function DirectDrawEnumerateEx(lpCallback:TDDENUMCALLBACKEX; lpContext:Pointer; dwFlags:DWORD):HRESULT;stdcall; external 'DDraw.dll'; function DirectDrawCreate(lpGUID: PGUID; out lplpDD: IDirectDraw; pUnkOuter: IUnknown): HResult; stdcall; external 'DDraw.dll'; function DirectDrawCreateClipper(dwFlags: DWORD; out lplpDDClipper: IDirectDrawClipper; pUnkOuter: IUnknown): HResult; stdcall;external 'DDraw.dll'; // // DirectDrawEnumerateEx Flags // // * This flag causes enumeration of any GDI display devices which are part of // * the Windows Desktop const DDENUM_ATTACHEDSECONDARYDEVICES = $00000001; // * This flag causes enumeration of any GDI display devices which are not // * part of the Windows Desktop DDENUM_DETACHEDSECONDARYDEVICES = $00000002; DDENUM_VALID = DDENUM_ATTACHEDSECONDARYDEVICES or DDENUM_DETACHEDSECONDARYDEVICES; // Enumeration function pointer types type TDDEnumModesCallback = function(const lpDDSurfaceDesc: TDDSurfaceDesc; lpContext: Pointer): HResult; stdcall; type LPDDENUMMODESCALLBACK = TDDEnumModesCallback; type TDDEnumSurfacesCallback = function(lpDDSurface: IDirectDrawSurface; const lpDDSurfaceDesc: TDDSurfaceDesc; lpContext: Pointer): HResult; stdcall; type LPDDENUMSURFACESCALLBACK = TDDEnumSurfacesCallback; // // IDirectDraw // type IDirectDraw = interface(IUnknown) ['{9C59509A-39BD-11D1-8C4A-00C04FD930C5}'] // IDirectDraw methods function CreateClipper(dwFlags: DWORD; out lplpDDClipper: IDirectDrawClipper; pUnkOuter: IUnknown): HResult; stdcall; function CreatePalette(dwFlags: DWORD; lpColorTable: PPaletteEntry; out lplpDDPalette: IDirectDrawPalette; pUnkOuter: IUnknown): HResult; stdcall; function CreateSurface(const lpDDSurfaceDesc: TDDSurfaceDesc; out lplpDDSurface: IDirectDrawSurface; pUnkOuter: IUnknown): HResult; stdcall; function EnumDisplayModes(dwFlags: DWORD; const lpDDSurfaceDesc: TDDSurfaceDesc; lpContext: Pointer; lpEnumModesCallback: TDDEnumModesCallback): HResult; stdcall; function EnumSurfaces(dwFlags: DWORD; const lpDDSD: TDDSurfaceDesc; lpContext: Pointer; lpEnumCallback: TDDEnumSurfacesCallback): HResult; stdcall; function FlipToGDISurface: HResult; stdcall; function GetCaps(var lpDDDriverCaps: TDDCaps; var lpDDHELCaps: TDDCaps): HResult; stdcall; function GetDisplayMode(var lpDDSurfaceDesc: TDDSurfaceDesc): HResult; stdcall; function GetFourCCCodes(var lpNumCodes, lpCodes: DWORD): HResult; stdcall; function GetGDISurface(out lplpGDIDDSSurface: IDirectDrawSurface): HResult; stdcall; function GetMonitorFrequency(var lpdwFrequency: DWORD): HResult; stdcall; function GetScanLine(var lpdwScanLine: DWORD): HResult; stdcall; function GetVerticalBlankStatus(var lpbIsInVB: BOOL): HResult; stdcall; function RestoreDisplayMode: HResult; stdcall; function SetCooperativeLevel(hWnd: HWND; dwFlags: DWORD): HResult; stdcall; function SetDisplayMode(dwWidth, dwHeight, dwBpp: DWORD): HResult; stdcall; function WaitForVerticalBlank(dwFlags: DWORD; hEvent: THandle): HResult; stdcall; function GetAvailableVidMem(var lpDDSCaps: TDDSCaps; var lpdwTotal, lpdwFree: DWORD): HResult; stdcall; function GetSurfaceFromDC(hdc: HDC; lpDDS: IDirectDrawSurface): HResult; stdcall; function RestoreAllSurfaces: HResult; stdcall; function TestCooperativeLevel: HResult; stdcall; function GetDeviceIdentifier(var lpdddi: TDDDeviceIdentifier; dwFlags: DWORD): HResult; stdcall; end; { IDirectDrawPalette Interface } IDirectDrawPalette = interface(IUnknown) ['{6C14DB84-A733-11CE-A521-0020AF0BE560}'] // IDirectDrawPalette methods function GetCaps(varlpdwCaps: DWORD): HResult; stdcall; function GetEntries(dwFlags: DWORD; dwBase: DWORD; dwNumEntries: DWORD; lpEntries: PPaletteEntry): HResult; stdcall; function SetEntries(dwFlags: DWORD; dwStartingEntry: DWORD; dwCount: DWORD; lpEntries: PPaletteEntry): HResult; stdcall; end; {IDirectDrawClipper} IDirectDrawClipper = interface(IUnknown) ['{6C14DB85-A733-11CE-A521-0020AF0BE560}'] // IDirectDrawClipper methods function GetClipList(const lpRect: TRect; lpClipList: PRgnData; var lpdwSize: DWORD): HResult; stdcall; function GetHWnd(var lphWnd: HWND): HResult; stdcall; function IsClipListChanged(var lpbChanged: BOOL): HResult; stdcall; function SetClipList(lpClipList: PRgnData; dwFlags: DWORD): HResult; stdcall; function SetHWnd(dwFlags: DWORD; hWnd: HWND): HResult; stdcall; end; {IDirectDrawSurface} IDirectDrawSurface = interface(IUnknown) ['{0b0e83e4-f37f-11d2-8b15-00c04F689292}'] // IDirectDrawSurface methods function AddOverlayDirtyRect(const lpRect: TRect): HResult; stdcall; function Blt(const lpDestRect: TRect; lpDDSrcSurface: IDirectDrawSurface; const lpSrcRect: TRect; dwFlags: DWORD; const lpDDBltFx: TDDBltFX): HResult; stdcall; function EnumAttachedSurfaces(lpContext: Pointer; lpEnumSurfacesCallback: TDDEnumSurfacesCallback): HResult; stdcall; function EnumOverlayZOrders(dwFlags: DWORD; lpContext: Pointer; lpfnCallback: TDDEnumSurfacesCallback): HResult; stdcall; function Flip(lpDDSurfaceTargetOverride: IDirectDrawSurface; dwFlags: DWORD): HResult; stdcall; function GetBltStatus(dwFlags: DWORD): HResult; stdcall; function GetCaps(var lpDDSCaps: TDDSCaps): HResult; stdcall; function GetClipper(out lplpDDClipper: IDirectDrawClipper): HResult; stdcall; function GetColorKey(dwFlags: DWORD; var lpDDColorKey: TDDColorKey): HResult; stdcall; function GetDC(var lphDC: HDC): HResult; stdcall; function GetFlipStatus(dwFlags: DWORD): HResult; stdcall; function GetOverlayPosition(var lplX, lplY: Longint): HResult; stdcall; function GetPalette(out lplpDDPalette: IDirectDrawPalette): HResult; stdcall; function GetPixelFormat(var lpDDPixelFormat: TDDPixelFormat): HResult; stdcall; function GetSurfaceDesc(var lpDDSurfaceDesc: TDDSurfaceDesc): HResult; stdcall; function IsLost: HResult; stdcall; function Lock(lpDestRect: PRect; const lpDDSurfaceDesc: TDDSurfaceDesc; dwFlags: DWORD; hEvent: THandle): HResult; stdcall; function ReleaseDC(hDC: HDC): HResult; stdcall; function Restore: HResult; stdcall; function SetClipper(lpDDClipper: IDirectDrawClipper): HResult; stdcall; function SetColorKey(dwFlags: DWORD; const lpDDColorKey: TDDColorKey): HResult; stdcall; function SetOverlayPosition(lX, lY: Longint): HResult; stdcall; function SetPalette(lpDDPalette: IDirectDrawPalette): HResult; stdcall; function Unlock(lpSurfaceData: Pointer): HResult; stdcall; function UpdateOverlay(const lpSrcRect: TRect; lpDDDestSurface: IDirectDrawSurface; const lpDestRect: TRect; dwFlags: DWORD; const lpDDOverlayFx: TDDOverlayFX): HResult; stdcall; function UpdateOverlayZOrder(dwFlags: DWORD; lpDDSReference: IDirectDrawSurface): HResult; stdcall; function GetDDInterface(out lplpDD: IUnknown): HResult; stdcall; function AlphaBlt (const lpDestRect: TRect; lpDDSrcSurface: IDirectDrawSurface; const lpSrcRect: TRect; dwFlags: DWORD; const lpDDAlphaBltFx: TDDALPHABLTFX): HResult; stdcall; end; { IDirectDrawColorControl} IDirectDrawColorControl = interface(IUnknown) ['{4B9F0EE0-0D7E-11D0-9B06-00A0C903A3B8}'] // IDirectDrawColorControl methods function GetColorControls(var lpColorControl: TDDColorControl): HResult; stdcall; function SetColorControls(const lpColorControl: TDDColorControl): HResult; stdcall; end; { IDirectDrawGammaControl} IDirectDrawGammaControl = interface(IUnknown) ['{69C11C3E-B46B-11D1-AD7A-00C04FC29B4E}'] // IDirectDrawGammaControl methods function GetGammaRamp(dwFlags: DWORD; var lpRampData: TDDGammaRamp): HResult; stdcall; function SetGammaRamp(dwFlags: DWORD; const lpRampData: TDDGammaRamp): HResult; stdcall; end; { DirectDraw Macros } function MAKEFOURCC(ch0, ch1, ch2, ch3: Char) : DWORD; // * Direct Draw Capability Flags // * Surface Capability Flags const DDSCAPS_ALPHA = $00000001; DDSCAPS_BACKBUFFER = $00000002; DDSCAPS_FLIP = $00000004; DDSCAPS_FRONTBUFFER = $00000008; DDSCAPS_OVERLAY = $00000010; DDSCAPS_PALETTE = $00000020; DDSCAPS_PRIMARYSURFACE = $00000040; DDSCAPS_SYSTEMMEMORY = $00000080; DDSCAPS_VIDEOMEMORY = $00000100; DDSCAPS_WRITEONLY = $00000200; DDSCAPS_READONLY = $00000800; DDSCAPS_NOTUSERLOCKABLE = $00002000; DDSCAPS_DYNAMIC = $00004000; DDSCAPS_VALID = DDSCAPS_ALPHA or DDSCAPS_BACKBUFFER or DDSCAPS_FLIP or DDSCAPS_FRONTBUFFER or DDSCAPS_OVERLAY or DDSCAPS_PALETTE or DDSCAPS_PRIMARYSURFACE or DDSCAPS_SYSTEMMEMORY or DDSCAPS_VIDEOMEMORY or DDSCAPS_WRITEONLY or DDSCAPS_READONLY or DDSCAPS_NOTUSERLOCKABLE or DDSCAPS_DYNAMIC; // * Palette Capability Flags DDPCAPS_PRIMARYSURFACE = $00000010; DDPCAPS_ALPHA = $00000400; DDPCAPS_VALID = DDPCAPS_PRIMARYSURFACE or DDPCAPS_ALPHA; // * DirectDraw Capability Flags // * General hardware blitting capabilities (For DDCAPS dwBltCaps field) DDBLTCAPS_READSYSMEM = $00000001; DDBLTCAPS_WRITESYSMEM = $00000002; DDBLTCAPS_FOURCCTORGB = $00000004; DDBLTCAPS_COPYFOURCC = $00000008; DDBLTCAPS_FILLFOURCC = $00000010; DDBLTCAPS_VALID = (((DDBLTCAPS_READSYSMEM or DDBLTCAPS_WRITESYSMEM) or DDBLTCAPS_FOURCCTORGB) or DDBLTCAPS_COPYFOURCC) or DDBLTCAPS_FILLFOURCC; // * Hardware color key blitting capabilities (For DDCAPS dwCKeyCaps field) DDCKEYCAPS_DESTBLT = $00000001; DDCKEYCAPS_DESTBLTCLRSPACE = $00000002; DDCKEYCAPS_DESTBLTCLRSPACEYUV = $00000004; DDCKEYCAPS_SRCBLT = $00000200; DDCKEYCAPS_SRCBLTCLRSPACE = $00000400; DDCKEYCAPS_SRCBLTCLRSPACEYUV = $00000800; DDCKEYCAPS_BOTHBLT = $00001000; DDCKEYCAPS_VALID = (((((DDCKEYCAPS_DESTBLT or DDCKEYCAPS_DESTBLTCLRSPACE) or DDCKEYCAPS_DESTBLTCLRSPACEYUV) or DDCKEYCAPS_SRCBLT) or DDCKEYCAPS_SRCBLTCLRSPACE) or DDCKEYCAPS_SRCBLTCLRSPACEYUV) or DDCKEYCAPS_BOTHBLT; // * Hardware alpha blitting capabilities (For DDCAPS dwAlphaCaps field) DDALPHACAPS_ALPHAPIXELS = $00000001; DDALPHACAPS_ALPHASURFACE = $00000002; DDALPHACAPS_ALPHAPALETTE = $00000004; DDALPHACAPS_ALPHACONSTANT = $00000008; DDALPHACAPS_ARGBSCALE = $00000010; DDALPHACAPS_SATURATE = $00000020; DDALPHACAPS_PREMULT = $00000040; DDALPHACAPS_NONPREMULT = $00000080; DDALPHACAPS_ALPHAFILL = $00000800; DDALPHACAPS_ALPHANEG = $00000100; DDALPHACAPS_VALID = DDALPHACAPS_ALPHAPIXELS or DDALPHACAPS_ALPHASURFACE or DDALPHACAPS_ALPHAPALETTE or DDALPHACAPS_ALPHACONSTANT or DDALPHACAPS_ARGBSCALE or DDALPHACAPS_SATURATE or DDALPHACAPS_PREMULT or DDALPHACAPS_NONPREMULT or DDALPHACAPS_ALPHAFILL or DDALPHACAPS_ALPHANEG; // * Overlay capabilities ( For DDCAPS dwOverlayCaps field) DDOVERLAYCAPS_FLIP = $00000001; DDOVERLAYCAPS_FOURCC = $00000004; DDOVERLAYCAPS_ZORDER = $00000008; DDOVERLAYCAPS_MIRRORLEFTRIGHT = $00000010; DDOVERLAYCAPS_MIRRORUPDOWN = $00000020; DDOVERLAYCAPS_CKEYSRC = $00000040; DDOVERLAYCAPS_CKEYSRCCLRSPACE = $00000080; DDOVERLAYCAPS_CKEYSRCCLRSPACEYUV = $00000100; DDOVERLAYCAPS_CKEYDEST = $00000200; DDOVERLAYCAPS_CKEYDESTCLRSPACE = $00000400; DDOVERLAYCAPS_CKEYDESTCLRSPACEYUV = $00000800; DDOVERLAYCAPS_CKEYBOTH = $00001000; DDOVERLAYCAPS_ALPHADEST = $00002000; DDOVERLAYCAPS_ALPHASRC = $00008000; DDOVERLAYCAPS_ALPHADESTNEG = $00002000; DDOVERLAYCAPS_ALPHASRCNEG = $00008000; DDOVERLAYCAPS_ALPHACONSTANT = $00010000; DDOVERLAYCAPS_ALPHAPREMULT = $00040000; DDOVERLAYCAPS_ALPHANONPREMULT = $00080000; DDOVERLAYCAPS_ALPHAANDKEYDEST = $00100000; DDOVERLAYCAPS_OVERLAYSUPPORT = $80000000; DDOVERLAYCAPS_VALID = DDOVERLAYCAPS_FLIP or DDOVERLAYCAPS_FOURCC or DDOVERLAYCAPS_ZORDER or DDOVERLAYCAPS_MIRRORLEFTRIGHT or DDOVERLAYCAPS_MIRRORUPDOWN or DDOVERLAYCAPS_CKEYSRC or DDOVERLAYCAPS_CKEYSRCCLRSPACE or DDOVERLAYCAPS_CKEYSRCCLRSPACEYUV or DDOVERLAYCAPS_CKEYDEST or DDOVERLAYCAPS_CKEYDESTCLRSPACE or DDOVERLAYCAPS_CKEYDESTCLRSPACEYUV or DDOVERLAYCAPS_CKEYBOTH or DDOVERLAYCAPS_ALPHADEST or DDOVERLAYCAPS_ALPHASRC or DDOVERLAYCAPS_ALPHADESTNEG or DDOVERLAYCAPS_ALPHASRCNEG or DDOVERLAYCAPS_ALPHACONSTANT or DDOVERLAYCAPS_ALPHAPREMULT or DDOVERLAYCAPS_ALPHANONPREMULT or DDOVERLAYCAPS_ALPHAANDKEYDEST or DDOVERLAYCAPS_OVERLAYSUPPORT; // Miscellaneous Capability Flags (For DDCAPS dwMiscCaps member) DDMISCCAPS_READSCANLINE = $00000001; DDMISCCAPS_READMONITORFREQ = $00000002; DDMISCCAPS_READVBLANKSTATUS = $00000004; DDMISCCAPS_FLIPINTERVAL = $00000008; DDMISCCAPS_FLIPODDEVEN = $00000010; DDMISCCAPS_FLIPVSYNCWITHVBI = $00000020; DDMISCCAPS_COLORCONTROLOVERLAY = $00000040; DDMISCCAPS_COLORCONTROLPRIMARY = $00000080; DDMISCCAPS_GAMMACONTROLOVERLAY = $00000100; DDMISCCAPS_GAMMACONTROLPRIMARY = $00000200; DDMISCCAPS_VALID = DDMISCCAPS_READSCANLINE or DDMISCCAPS_READMONITORFREQ or DDMISCCAPS_READVBLANKSTATUS or DDMISCCAPS_FLIPINTERVAL or DDMISCCAPS_FLIPODDEVEN or DDMISCCAPS_FLIPVSYNCWITHVBI or DDMISCCAPS_COLORCONTROLOVERLAY or DDMISCCAPS_COLORCONTROLPRIMARY or DDMISCCAPS_GAMMACONTROLOVERLAY or DDMISCCAPS_GAMMACONTROLPRIMARY; // DirectDraw method flags //* Flags for IDirectDraw::EnumSurfaces DDENUMSURFACES_ALL = $00000001; DDENUMSURFACES_MATCH = $00000002; DDENUMSURFACES_NOMATCH = $00000004; DDENUMSURFACES_CANBECREATED = $00000008; DDENUMSURFACES_DOESEXIST = $00000010; DDENUMSURFACES_VALID = DDENUMSURFACES_ALL or DDENUMSURFACES_MATCH or DDENUMSURFACES_NOMATCH or DDENUMSURFACES_CANBECREATED or DDENUMSURFACES_DOESEXIST; //* Flags for IDirectDraw::SetCooperativeLevel DDSCL_NORMAL = $00000000; DDSCL_FULLSCREEN = $00000001; DDSCL_VALID = DDSCL_FULLSCREEN or DDSCL_NORMAL; // * Flags for IDirectDraw::WaitForVerticalBlank DDWAITVB_BLOCKBEGIN = $00000001; DDWAITVB_BLOCKEND = $00000004; DDWAITVB_VALID = DDWAITVB_BLOCKBEGIN or DDWAITVB_BLOCKEND; // * Flags for IDirectDrawSurface::GetColorKey and IDirectDrawSurface::SetColorKey DDCKEY_COLORSPACE = $00000001; DDCKEY_DESTBLT = $00000002; DDCKEY_DESTOVERLAY = $00000004; DDCKEY_SRCBLT = $00000008; DDCKEY_SRCOVERLAY = $00000010; DDCKEY_VALID = DDCKEY_DESTBLT or DDCKEY_DESTOVERLAY or DDCKEY_SRCBLT or DDCKEY_SRCOVERLAY; // * Flags for IDirectDrawSurface::Blt DDBLT_COLORFILL = $00000400; DDBLT_KEYDEST = $00002000; DDBLT_KEYDESTOVERRIDE = $00004000; DDBLT_KEYSRC = $00008000; DDBLT_KEYSRCOVERRIDE = $00010000; DDBLT_ROP = $00020000; DDBLT_WAITNOTBUSY = $01000000; DDBLT_WAITVSYNC = $00000001; DDBLT_VALID = ((((((DDBLT_COLORFILL or DDBLT_KEYDEST) or DDBLT_KEYDESTOVERRIDE) or DDBLT_KEYSRC) or DDBLT_KEYSRCOVERRIDE) or DDBLT_ROP) or DDBLT_WAITNOTBUSY) or DDBLT_WAITVSYNC; // Flags for IDirectDrawSurface::AlphaBlt DDABLT_NOBLEND = $02000000; DDABLT_COLORFILL = $00100000; DDABLT_ALPHADESTNEG = $00000004; DDABLT_ALPHASRCNEG = $00000080; DDABLT_WAITNOTBUSY = $01000000; DDABLT_WAITVSYNC = $00000001; DDABLT_VALID = ((((DDABLT_NOBLEND or DDABLT_COLORFILL) or DDABLT_ALPHADESTNEG) or DDABLT_ALPHASRCNEG) or DDABLT_WAITNOTBUSY) or DDABLT_WAITVSYNC; // Flags for IDirectDrawSurface::Flip DDFLIP_EVEN = $00000002; DDFLIP_ODD = $00000004; DDFLIP_INTERVAL1 = $01000000; DDFLIP_INTERVAL2 = $02000000; DDFLIP_INTERVAL4 = $04000000; DDFLIP_WAITNOTBUSY = $00000008; DDFLIP_WAITVSYNC = $00000001; DDFLIP_VALID = (((((DDFLIP_EVEN or DDFLIP_ODD) or DDFLIP_INTERVAL1) or DDFLIP_INTERVAL2) or DDFLIP_INTERVAL4) or DDFLIP_WAITNOTBUSY) or DDFLIP_WAITVSYNC; DDFLIP_INTERVAL3 = DDFLIP_INTERVAL1 or DDFLIP_INTERVAL2; DDFLIP_INTERVALMASK = (DDFLIP_INTERVAL1 or DDFLIP_INTERVAL2) or DDFLIP_INTERVAL4; // * Flag values for IDirectDrawSurface::UpdateOverlay DDOVER_ALPHADEST = $00000001; DDOVER_ALPHADESTNEG = $00000002; DDOVER_ALPHASRC = $00000004; DDOVER_ALPHASRCNEG = $00000008; DDOVER_ALPHACONSTOVERRIDE = $00000010; DDOVER_HIDE = $00000020; DDOVER_KEYDEST = $00000040; DDOVER_KEYDESTOVERRIDE = $00000080; DDOVER_KEYSRC = $00000100; DDOVER_KEYSRCOVERRIDE = $00000200; DDOVER_SHOW = $00000400; DDOVER_MIRRORLEFTRIGHT = $00001000; DDOVER_MIRRORUPDOWN = $00002000; DDOVER_WAITNOTBUSY = $00004000; DDOVER_WAITVSYNC = $00008000; DDOVER_VALID = DDOVER_ALPHADEST or DDOVER_ALPHADESTNEG or DDOVER_ALPHASRC or DDOVER_ALPHASRCNEG or DDOVER_ALPHACONSTOVERRIDE or DDOVER_HIDE or DDOVER_KEYDEST or DDOVER_KEYDESTOVERRIDE or DDOVER_KEYSRC or DDOVER_KEYSRCOVERRIDE or DDOVER_SHOW or DDOVER_MIRRORLEFTRIGHT or DDOVER_MIRRORUPDOWN or DDOVER_WAITNOTBUSY or DDOVER_WAITVSYNC; // * Flags for IDirectDrawSurface::Lock DDLOCK_READONLY = $00000001; DDLOCK_WRITEONLY = $00000002; DDLOCK_DISCARD = $00000004; DDLOCK_WAITNOTBUSY = $00000008; DDLOCK_VALID = ((DDLOCK_READONLY or DDLOCK_WRITEONLY) or DDLOCK_DISCARD) or DDLOCK_WAITNOTBUSY; // * Flags for IDirectDrawSurface::GetFlipStatus DDGFS_CANFLIP = $00000001; DDGFS_ISFLIPDONE = $00000002; DDGFS_VALID = DDGFS_CANFLIP or DDGFS_ISFLIPDONE; // * Flags for IDirectDrawSurface::GetBltStatus DDGBS_CANBLT = $00000001; DDGBS_ISBLTDONE = $00000002; DDGBS_VALID = DDGBS_CANBLT or DDGBS_ISBLTDONE; // * Flags for IDirectDrawSurface::EnumOverlayZOrders DDENUMOVERLAYZ_FRONTTOBACK = $00000001; DDENUMOVERLAYZ_VALID = DDENUMOVERLAYZ_FRONTTOBACK; // * Flags for IDirectDrawSurface::UpdateOverlayZOrder DDOVERZ_SENDTOFRONT = $00000000; DDOVERZ_SENDTOBACK = $00000001; DDOVERZ_MOVEFORWARD = $00000002; DDOVERZ_MOVEBACKWARD = $00000003; DDOVERZ_INSERTINFRONTOF = $00000004; DDOVERZ_INSERTINBACKOF = $00000005; // // DirectDraw Return Codes // // * Enumeration function return values. DDENUMRET_CANCEL = 0; DDENUMRET_OK = 1; // // DirectDraw error codes. // const DD_OK = 0; DD_FALSE = S_FALSE; DDERR_CURRENTLYNOTAVAIL = HResult($88760000 + 40); DDERR_GENERIC = HResult(E_FAIL); DDERR_HEIGHTALIGN = HResult($88760000 + 90); DDERR_INCOMPATIBLEPRIMARY = HResult($88760000 + 95); DDERR_INVALIDCAPS = HResult($88760000 + 100); DDERR_INVALIDCLIPLIST = HResult($88760000 + 110); DDERR_INVALIDMODE = HResult($88760000 + 120); DDERR_INVALIDOBJECT = HResult($88760000 + 130); DDERR_INVALIDPARAMS = HResult(E_INVALIDARG); DDERR_INVALIDPIXELFORMAT = HResult($88760000 + 145); DDERR_INVALIDRECT = HResult($88760000 + 150); DDERR_LOCKEDSURFACES = HResult($88760000 + 160); DDERR_NO3D = HResult($88760000 + 170); DDERR_NOALPHAHW = HResult($88760000 + 180); DDERR_NOCLIPLIST = HResult($88760000 + 205); DDERR_NOCOLORCONVHW = HResult($88760000 + 210); DDERR_NOCOOPERATIVELEVELSET = HResult($88760000 + 212); DDERR_NOCOLORKEY = HResult($88760000 + 215); DDERR_NOFLIPHW = HResult($88760000 + 230); DDERR_NOGDI = HResult($88760000 + 240); DDERR_NOMIRRORHW = HResult($88760000 + 250); DDERR_NOTFOUND = HResult($88760000 + 255); DDERR_NOOVERLAYHW = HResult($88760000 + 260); DDERR_OVERLAPPINGRECTS = HResult($88760000 + 270); DDERR_NORASTEROPHW = HResult($88760000 + 280); DDERR_NOSTRETCHHW = HResult($88760000 + 310); DDERR_NOVSYNCHW = HResult($88760000 + 335); DDERR_NOZOVERLAYHW = HResult($88760000 + 350); DDERR_OUTOFCAPS = HResult($88760000 + 360); DDERR_OUTOFMEMORY = HResult(E_OUTOFMEMORY); DDERR_OUTOFVIDEOMEMORY = HResult($88760000 + 380); DDERR_PALETTEBUSY = HResult($88760000 + 387); DDERR_COLORKEYNOTSET = HResult($88760000 + 400); DDERR_SURFACEBUSY = HResult($88760000 + 430); DDERR_CANTLOCKSURFACE = HResult($88760000 + 435); DDERR_SURFACELOST = HResult($88760000 + 450); DDERR_TOOBIGHEIGHT = HResult($88760000 + 470); DDERR_TOOBIGSIZE = HResult($88760000 + 480); DDERR_TOOBIGWIDTH = HResult($88760000 + 490); DDERR_UNSUPPORTED = HResult(E_NOTIMPL); DDERR_UNSUPPORTEDFORMAT = HResult($88760000 + 536); DDERR_VERTICALBLANKINPROGRESS = HResult($88760000 + 537); DDERR_WASSTILLDRAWING = HResult($88760000 + 540); DDERR_DIRECTDRAWALREADYCREATED = HResult($88760000 + 562); DDERR_PRIMARYSURFACEALREADYEXISTS = HResult($88760000 + 564); DDERR_REGIONTOOSMALL = HResult($88760000 + 566); DDERR_CLIPPERISUSINGHWND = HResult($88760000 + 567); DDERR_NOCLIPPERATTACHED = HResult($88760000 + 568); DDERR_NOPALETTEATTACHED = HResult($88760000 + 572); DDERR_NOPALETTEHW = HResult($88760000 + 573); DDERR_NOBLTHW = HResult($88760000 + 575); DDERR_OVERLAYNOTVISIBLE = HResult($88760000 + 577); DDERR_NOOVERLAYDEST = HResult($88760000 + 578); DDERR_INVALIDPOSITION = HResult($88760000 + 579); DDERR_NOTAOVERLAYSURFACE = HResult($88760000 + 580); DDERR_EXCLUSIVEMODEALREADYSET = HResult($88760000 + 581); DDERR_NOTFLIPPABLE = HResult($88760000 + 582); DDERR_NOTLOCKED = HResult($88760000 + 584); DDERR_CANTCREATEDC = HResult($88760000 + 585); DDERR_NODC = HResult($88760000 + 586); DDERR_WRONGMODE = HResult($88760000 + 587); DDERR_IMPLICITLYCREATED = HResult($88760000 + 588); DDERR_NOTPALETTIZED = HResult($88760000 + 589); DDERR_DCALREADYCREATED = HResult($88760000 + 620); DDERR_MOREDATA = HResult($88760000 + 690); DDERR_VIDEONOTACTIVE = HResult($88760000 + 695); DDERR_DEVICEDOESNTOWNSURFACE = HResult($88760000 + 699); implementation function MAKEFOURCC(ch0, ch1, ch2, ch3: Char) : DWORD; begin Result := Ord(ch0) + (Ord(ch1) shl 8) + (Ord(ch2) shl 16) + (Ord(ch3) shl 24); end; end.
Reply With Quote
Bookmarks