游戏引擎

开发平台：

Delphi

DirectDraw.pas：源码内容

* It enables easier use of GetAttachedSurface rather than EnumAttachedSurfaces for surface
* constructs such as Cube Maps, wherein there are more than one mipmap surface attached
* to the root surface.
* This caps bit is ignored by CreateSurface
*)
DDSCAPS2_MIPMAPSUBLEVEL = $00010000;
{$EXTERNALSYM DDSCAPS2_MIPMAPSUBLEVEL}
(* This flag indicates that the texture should be managed by D3D only *)
DDSCAPS2_D3DTEXTUREMANAGE = $00020000;
{$EXTERNALSYM DDSCAPS2_D3DTEXTUREMANAGE}
(* This flag indicates that the managed surface can be safely lost *)
DDSCAPS2_DONOTPERSIST = $00040000;
{$EXTERNALSYM DDSCAPS2_DONOTPERSIST}
(* indicates that this surface is part of a stereo flipping chain *)
DDSCAPS2_STEREOSURFACELEFT = $00080000;
{$EXTERNALSYM DDSCAPS2_STEREOSURFACELEFT}
(*
* Indicates that the surface is a volume.
* Can be combined with DDSCAPS_MIPMAP to indicate a multi-level volume
*)
DDSCAPS2_VOLUME = $00200000;
{$EXTERNALSYM DDSCAPS2_VOLUME}
(*
* Indicates that the surface may be locked multiple times by the application.
* This cap cannot be used with DDSCAPS2_OPAQUE.
*)
DDSCAPS2_NOTUSERLOCKABLE = $00400000;
{$EXTERNALSYM DDSCAPS2_NOTUSERLOCKABLE}
(*
* Indicates that the vertex buffer data can be used to render points and
* point sprites.
*)
DDSCAPS2_POINTS = $00800000;
{$EXTERNALSYM DDSCAPS2_POINTS}
(*
* Indicates that the vertex buffer data can be used to render rt pactches.
*)
DDSCAPS2_RTPATCHES = $01000000;
{$EXTERNALSYM DDSCAPS2_RTPATCHES}
(*
* Indicates that the vertex buffer data can be used to render n patches.
*)
DDSCAPS2_NPATCHES = $02000000;
{$EXTERNALSYM DDSCAPS2_NPATCHES}
(*
* This bit is reserved for internal use
*)
DDSCAPS2_RESERVED3 = $04000000;
{$EXTERNALSYM DDSCAPS2_RESERVED3}
(*
* Indicates that the contents of the backbuffer do not have to be preserved
* the contents of the backbuffer after they are presented.
*)
DDSCAPS2_DISCARDBACKBUFFER = $10000000;
{$EXTERNALSYM DDSCAPS2_DISCARDBACKBUFFER}
(*
* Indicates that all surfaces in this creation chain should be given an alpha channel.
* This flag will be set on primary surface chains that may have no explicit pixel format
* (and thus take on the format of the current display mode).
* The driver should infer that all these surfaces have a format having an alpha channel.
* (e.g. assume D3DFMT_A8R8G8B8 if the display mode is x888.)
*)
DDSCAPS2_ENABLEALPHACHANNEL = $20000000;
{$EXTERNALSYM DDSCAPS2_ENABLEALPHACHANNEL}
(*
* This is a mask that indicates the set of bits that may be set
* at createsurface time to indicate number of samples per pixel
* when multisampling
*)
DDSCAPS3_MULTISAMPLE_MASK = $0000001F;
{$EXTERNALSYM DDSCAPS3_MULTISAMPLE_MASK}
(****************************************************************************
*
* DIRECTDRAW DRIVER CAPABILITY FLAGS
*
****************************************************************************)
(*
* Display hardware has 3D acceleration.
*)
DDCAPS_3D = $00000001;
{$EXTERNALSYM DDCAPS_3D}
(*
* Indicates that DirectDraw will support only dest rectangles that are aligned
* on DIRECTDRAWCAPS.dwAlignBoundaryDest boundaries of the surface, respectively.
* READ ONLY.
*)
DDCAPS_ALIGNBOUNDARYDEST = $00000002;
{$EXTERNALSYM DDCAPS_ALIGNBOUNDARYDEST}
(*
* Indicates that DirectDraw will support only source rectangles whose sizes in
* BYTEs are DIRECTDRAWCAPS.dwAlignSizeDest multiples, respectively. READ ONLY.
*)
DDCAPS_ALIGNSIZEDEST = $00000004;
{$EXTERNALSYM DDCAPS_ALIGNSIZEDEST}
(*
* Indicates that DirectDraw will support only source rectangles that are aligned
* on DIRECTDRAWCAPS.dwAlignBoundarySrc boundaries of the surface, respectively.
* READ ONLY.
*)
DDCAPS_ALIGNBOUNDARYSRC = $00000008;
{$EXTERNALSYM DDCAPS_ALIGNBOUNDARYSRC}
(*
* Indicates that DirectDraw will support only source rectangles whose sizes in
* BYTEs are DIRECTDRAWCAPS.dwAlignSizeSrc multiples, respectively. READ ONLY.
*)
DDCAPS_ALIGNSIZESRC = $00000010;
{$EXTERNALSYM DDCAPS_ALIGNSIZESRC}
(*
* Indicates that DirectDraw will create video memory surfaces that have a stride
* alignment equal to DIRECTDRAWCAPS.dwAlignStride. READ ONLY.
*)
DDCAPS_ALIGNSTRIDE = $00000020;
{$EXTERNALSYM DDCAPS_ALIGNSTRIDE}
(*
* Display hardware is capable of blt operations.
*)
DDCAPS_BLT = $00000040;
{$EXTERNALSYM DDCAPS_BLT}
(*
* Display hardware is capable of asynchronous blt operations.
*)
DDCAPS_BLTQUEUE = $00000080;
{$EXTERNALSYM DDCAPS_BLTQUEUE}
(*
* Display hardware is capable of color space conversions during the blt operation.
*)
DDCAPS_BLTFOURCC = $00000100;
{$EXTERNALSYM DDCAPS_BLTFOURCC}
(*
* Display hardware is capable of stretching during blt operations.
*)
DDCAPS_BLTSTRETCH = $00000200;
{$EXTERNALSYM DDCAPS_BLTSTRETCH}
(*
* Display hardware is shared with GDI.
*)
DDCAPS_GDI = $00000400;
{$EXTERNALSYM DDCAPS_GDI}
(*
* Display hardware can overlay.
*)
DDCAPS_OVERLAY = $00000800;
{$EXTERNALSYM DDCAPS_OVERLAY}
(*
* Set if display hardware supports overlays but can not clip them.
*)
DDCAPS_OVERLAYCANTCLIP = $00001000;
{$EXTERNALSYM DDCAPS_OVERLAYCANTCLIP}
(*
* Indicates that overlay hardware is capable of color space conversions during
* the overlay operation.
*)
DDCAPS_OVERLAYFOURCC = $00002000;
{$EXTERNALSYM DDCAPS_OVERLAYFOURCC}
(*
* Indicates that stretching can be done by the overlay hardware.
*)
DDCAPS_OVERLAYSTRETCH = $00004000;
{$EXTERNALSYM DDCAPS_OVERLAYSTRETCH}
(*
* Indicates that unique DirectDrawPalettes can be created for DirectDrawSurfaces
* other than the primary surface.
*)
DDCAPS_PALETTE = $00008000;
{$EXTERNALSYM DDCAPS_PALETTE}
(*
* Indicates that palette changes can be syncd with the veritcal refresh.
*)
DDCAPS_PALETTEVSYNC = $00010000;
{$EXTERNALSYM DDCAPS_PALETTEVSYNC}
(*
* Display hardware can return the current scan line.
*)
DDCAPS_READSCANLINE = $00020000;
{$EXTERNALSYM DDCAPS_READSCANLINE}
(*
* This flag used to bo DDCAPS_STEREOVIEW, which is now obsolete
*)
DDCAPS_RESERVED1 = $00040000;
{$EXTERNALSYM DDCAPS_RESERVED1}
(*
* Display hardware is capable of generating a vertical blank interrupt.
*)
DDCAPS_VBI = $00080000;
{$EXTERNALSYM DDCAPS_VBI}
(*
* Supports the use of z buffers with blt operations.
*)
DDCAPS_ZBLTS = $00100000;
{$EXTERNALSYM DDCAPS_ZBLTS}
(*
* Supports Z Ordering of overlays.
*)
DDCAPS_ZOVERLAYS = $00200000;
{$EXTERNALSYM DDCAPS_ZOVERLAYS}
(*
* Supports color key
*)
DDCAPS_COLORKEY = $00400000;
{$EXTERNALSYM DDCAPS_COLORKEY}
(*
* Supports alpha surfaces
*)
DDCAPS_ALPHA = $00800000;
{$EXTERNALSYM DDCAPS_ALPHA}
(*
* colorkey is hardware assisted(DDCAPS_COLORKEY will also be set)
*)
DDCAPS_COLORKEYHWASSIST = $01000000;
{$EXTERNALSYM DDCAPS_COLORKEYHWASSIST}
(*
* no hardware support at all
*)
DDCAPS_NOHARDWARE = $02000000;
{$EXTERNALSYM DDCAPS_NOHARDWARE}
(*
* Display hardware is capable of color fill with bltter
*)
DDCAPS_BLTCOLORFILL = $04000000;
{$EXTERNALSYM DDCAPS_BLTCOLORFILL}
(*
* Display hardware is bank switched, and potentially very slow at
* random access to VRAM.
*)
DDCAPS_BANKSWITCHED = $08000000;
{$EXTERNALSYM DDCAPS_BANKSWITCHED}
(*
* Display hardware is capable of depth filling Z-buffers with bltter
*)
DDCAPS_BLTDEPTHFILL = $10000000;
{$EXTERNALSYM DDCAPS_BLTDEPTHFILL}
(*
* Display hardware is capable of clipping while bltting.
*)
DDCAPS_CANCLIP = $20000000;
{$EXTERNALSYM DDCAPS_CANCLIP}
(*
* Display hardware is capable of clipping while stretch bltting.
*)
DDCAPS_CANCLIPSTRETCHED = $40000000;
{$EXTERNALSYM DDCAPS_CANCLIPSTRETCHED}
(*
* Display hardware is capable of bltting to or from system memory
*)
DDCAPS_CANBLTSYSMEM = $80000000;
{$EXTERNALSYM DDCAPS_CANBLTSYSMEM}
(****************************************************************************
*
* MORE DIRECTDRAW DRIVER CAPABILITY FLAGS (dwCaps2)
*
****************************************************************************)
(*
* Display hardware is certified
*)
DDCAPS2_CERTIFIED = $00000001;
{$EXTERNALSYM DDCAPS2_CERTIFIED}
(*
* Driver cannot interleave 2D operations (lock and blt) to surfaces with
* Direct3D rendering operations between calls to BeginScene() and EndScene()
*)
DDCAPS2_NO2DDURING3DSCENE = $00000002;
{$EXTERNALSYM DDCAPS2_NO2DDURING3DSCENE}
(*
* Display hardware contains a video port
*)
DDCAPS2_VIDEOPORT = $00000004;
{$EXTERNALSYM DDCAPS2_VIDEOPORT}
(*
* 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 = $00000008;
{$EXTERNALSYM DDCAPS2_AUTOFLIPOVERLAY}
(*
* Overlay can display each field of interlaced data individually while
* it is interleaved in memory without causing jittery artifacts.
*)
DDCAPS2_CANBOBINTERLEAVED = $00000010;
{$EXTERNALSYM DDCAPS2_CANBOBINTERLEAVED}
(*
* Overlay can display each field of interlaced data individually while
* it is not interleaved in memory without causing jittery artifacts.
*)
DDCAPS2_CANBOBNONINTERLEAVED = $00000020;
{$EXTERNALSYM DDCAPS2_CANBOBNONINTERLEAVED}
(*
* The overlay surface contains color controls (brightness, sharpness, etc.)
*)
DDCAPS2_COLORCONTROLOVERLAY = $00000040;
{$EXTERNALSYM DDCAPS2_COLORCONTROLOVERLAY}
(*
* The primary surface contains color controls (gamma, etc.)
*)
DDCAPS2_COLORCONTROLPRIMARY = $00000080;
{$EXTERNALSYM DDCAPS2_COLORCONTROLPRIMARY}
(*
* RGBZ -> RGB supported for 16:16 RGB:Z
*)
DDCAPS2_CANDROPZ16BIT = $00000100;
{$EXTERNALSYM DDCAPS2_CANDROPZ16BIT}
(*
* Driver supports non-local video memory.
*)
DDCAPS2_NONLOCALVIDMEM = $00000200;
{$EXTERNALSYM DDCAPS2_NONLOCALVIDMEM}
(*
* 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 = $00000400;
{$EXTERNALSYM DDCAPS2_NONLOCALVIDMEMCAPS}
(*
* Driver neither requires nor prefers surfaces to be pagelocked when performing
* blts involving system memory surfaces
*)
DDCAPS2_NOPAGELOCKREQUIRED = $00000800;
{$EXTERNALSYM DDCAPS2_NOPAGELOCKREQUIRED}
(*
* Driver can create surfaces which are wider than the primary surface
*)
DDCAPS2_WIDESURFACES = $00001000;
{$EXTERNALSYM DDCAPS2_WIDESURFACES}
(*
* Driver supports bob without using a video port by handling the
* DDFLIP_ODD and DDFLIP_EVEN flags specified in Flip.
*)
DDCAPS2_CANFLIPODDEVEN = $00002000;
{$EXTERNALSYM DDCAPS2_CANFLIPODDEVEN}
(*
* Driver supports bob using hardware
*)
DDCAPS2_CANBOBHARDWARE = $00004000;
{$EXTERNALSYM DDCAPS2_CANBOBHARDWARE}
(*
* Driver supports bltting any FOURCC surface to another surface of the same FOURCC
*)
DDCAPS2_COPYFOURCC = $00008000;
{$EXTERNALSYM DDCAPS2_COPYFOURCC}
(*
* Driver supports loadable gamma ramps for the primary surface
*)
DDCAPS2_PRIMARYGAMMA = $00020000;
{$EXTERNALSYM DDCAPS2_PRIMARYGAMMA}
(*
* Driver can render in windowed mode.
*)
DDCAPS2_CANRENDERWINDOWED = $00080000;
{$EXTERNALSYM DDCAPS2_CANRENDERWINDOWED}
(*
* A calibrator is available to adjust the gamma ramp according to the
* physical display properties so that the result will be identical on
* all calibrated systems.
*)
DDCAPS2_CANCALIBRATEGAMMA = $00100000;
{$EXTERNALSYM DDCAPS2_CANCALIBRATEGAMMA}
(*
* Indicates that the driver will respond to DDFLIP_INTERVALn flags
*)
DDCAPS2_FLIPINTERVAL = $00200000;
{$EXTERNALSYM DDCAPS2_FLIPINTERVAL}
(*
* Indicates that the driver will respond to DDFLIP_NOVSYNC
*)
DDCAPS2_FLIPNOVSYNC = $00400000;
{$EXTERNALSYM DDCAPS2_FLIPNOVSYNC}
(*
* Driver supports management of video memory, if this flag is ON,
* driver manages the texture if requested with DDSCAPS2_TEXTUREMANAGE on
* DirectX manages the texture if this flag is OFF and surface has DDSCAPS2_TEXTUREMANAGE on
*)
DDCAPS2_CANMANAGETEXTURE = $00800000;
{$EXTERNALSYM DDCAPS2_CANMANAGETEXTURE}
(*
* The Direct3D texture manager uses this cap to decide whether to put managed
* surfaces in non-local video memory. If the cap is set, the texture manager will
* put managed surfaces in non-local vidmem. Drivers that cannot texture from
* local vidmem SHOULD NOT set this cap.
*)
DDCAPS2_TEXMANINNONLOCALVIDMEM = $01000000;
{$EXTERNALSYM DDCAPS2_TEXMANINNONLOCALVIDMEM}
(*
* Indicates that the driver supports DX7 type of stereo in at least one mode (which may
* not necessarily be the current mode). Applications should use IDirectDraw7 (or higher)
* ::EnumDisplayModes and check the DDSURFACEDESC.ddsCaps.dwCaps2 field for the presence of
* DDSCAPS2_STEREOSURFACELEFT to check if a particular mode supports stereo. The application
* can also use IDirectDraw7(or higher)::GetDisplayMode to check the current mode.
*)
DDCAPS2_STEREO = $02000000;
{$EXTERNALSYM DDCAPS2_STEREO}
(*
* This caps bit is intended for internal DirectDraw use.
* -It is only valid if DDCAPS2_NONLOCALVIDMEMCAPS is set.
* -If this bit is set, then DDCAPS_CANBLTSYSMEM MUST be set by the driver (and
* all the assoicated system memory blt caps must be correct).
* -It implies that the system->video blt caps in DDCAPS also apply to system to
* nonlocal blts. I.e. the dwSVBCaps, dwSVBCKeyCaps, dwSVBFXCaps and dwSVBRops
* members of DDCAPS (DDCORECAPS) are filled in correctly.
* -Any blt from system to nonlocal memory that matches these caps bits will
* be passed to the driver.
*
* NOTE: This is intended to enable the driver itself to do efficient reordering
* of textures. This is NOT meant to imply that hardware can write into AGP memory.
* This operation is not currently supported.
*)
DDCAPS2_SYSTONONLOCAL_AS_SYSTOLOCAL = $04000000;
{$EXTERNALSYM DDCAPS2_SYSTONONLOCAL_AS_SYSTOLOCAL}
(*
* was DDCAPS2_PUREHAL
*)
DDCAPS2_RESERVED1 = $08000000;
{$EXTERNALSYM DDCAPS2_RESERVED1}
(*
* Driver supports management of video memory, if this flag is ON,
* driver manages the resource if requested with DDSCAPS2_TEXTUREMANAGE on
* DirectX manages the resource if this flag is OFF and surface has DDSCAPS2_TEXTUREMANAGE on
*)
DDCAPS2_CANMANAGERESOURCE = $10000000;
{$EXTERNALSYM DDCAPS2_CANMANAGERESOURCE}
(*
* Driver supports dynamic textures. This will allow the application to set
* D3DUSAGE_DYNAMIC (DDSCAPS2_HINTDYNAMIC for drivers) at texture create time.
* Video memory dynamic textures WILL be lockable by applications. It is
* expected that these locks will be very efficient (which implies that the
* driver should always maintain a linear copy, a pointer to which can be
* quickly handed out to the application).
*)
DDCAPS2_DYNAMICTEXTURES = $20000000;
{$EXTERNALSYM DDCAPS2_DYNAMICTEXTURES}
(****************************************************************************
*
* DIRECTDRAW FX ALPHA CAPABILITY FLAGS
*
****************************************************************************)
(*
* Supports alpha blending around the edge of a source color keyed surface.
* For Blt.
*)
DDFXALPHACAPS_BLTALPHAEDGEBLEND = $00000001;
{$EXTERNALSYM DDFXALPHACAPS_BLTALPHAEDGEBLEND}
(*
* 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 = $00000002;
{$EXTERNALSYM DDFXALPHACAPS_BLTALPHAPIXELS}
(*
* 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 = $00000004;
{$EXTERNALSYM DDFXALPHACAPS_BLTALPHAPIXELSNEG}
(*
* 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 = $00000008;
{$EXTERNALSYM DDFXALPHACAPS_BLTALPHASURFACES}
(*
* 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 = $00000010;
{$EXTERNALSYM DDFXALPHACAPS_BLTALPHASURFACESNEG}
(*
* Supports alpha blending around the edge of a source color keyed surface.
* For Overlays.
*)
DDFXALPHACAPS_OVERLAYALPHAEDGEBLEND = $00000020;
{$EXTERNALSYM DDFXALPHACAPS_OVERLAYALPHAEDGEBLEND}
(*
* 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 = $00000040;
{$EXTERNALSYM DDFXALPHACAPS_OVERLAYALPHAPIXELS}
(*
* 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 = $00000080;
{$EXTERNALSYM DDFXALPHACAPS_OVERLAYALPHAPIXELSNEG}
(*
* 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 = $00000100;
{$EXTERNALSYM DDFXALPHACAPS_OVERLAYALPHASURFACES}
(*
* 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 = $00000200;
{$EXTERNALSYM DDFXALPHACAPS_OVERLAYALPHASURFACESNEG}
(****************************************************************************
*
* 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 = $00000020;
{$EXTERNALSYM DDFXCAPS_BLTARITHSTRETCHY}
(*
* Uses arithmetic operations to stretch during blt
* rather than pixel doubling techniques. Along the Y axis. Only
* works for x1, x2, etc.
*)
DDFXCAPS_BLTARITHSTRETCHYN = $00000010;
{$EXTERNALSYM DDFXCAPS_BLTARITHSTRETCHYN}
(*
* Supports mirroring left to right in blt.
*)
DDFXCAPS_BLTMIRRORLEFTRIGHT = $00000040;
{$EXTERNALSYM DDFXCAPS_BLTMIRRORLEFTRIGHT}
(*
* Supports mirroring top to bottom in blt.
*)
DDFXCAPS_BLTMIRRORUPDOWN = $00000080;
{$EXTERNALSYM DDFXCAPS_BLTMIRRORUPDOWN}
(*
* Supports arbitrary rotation for blts.
*)
DDFXCAPS_BLTROTATION = $00000100;
{$EXTERNALSYM DDFXCAPS_BLTROTATION}
(*
* Supports 90 degree rotations for blts.
*)
DDFXCAPS_BLTROTATION90 = $00000200;
{$EXTERNALSYM DDFXCAPS_BLTROTATION90}
(*
* DirectDraw supports arbitrary shrinking of a surface along the
* x axis (horizontal direction) for blts.
*)
DDFXCAPS_BLTSHRINKX = $00000400;
{$EXTERNALSYM DDFXCAPS_BLTSHRINKX}
(*
* DirectDraw supports integer shrinking (1x,2x,) of a surface
* along the x axis (horizontal direction) for blts.
*)
DDFXCAPS_BLTSHRINKXN = $00000800;
{$EXTERNALSYM DDFXCAPS_BLTSHRINKXN}
(*
* DirectDraw supports arbitrary shrinking of a surface along the
* y axis (horizontal direction) for blts.
*)
DDFXCAPS_BLTSHRINKY = $00001000;
{$EXTERNALSYM DDFXCAPS_BLTSHRINKY}
(*
* DirectDraw supports integer shrinking (1x,2x,) of a surface
* along the y axis (vertical direction) for blts.
*)
DDFXCAPS_BLTSHRINKYN = $00002000;
{$EXTERNALSYM DDFXCAPS_BLTSHRINKYN}
(*
* DirectDraw supports arbitrary stretching of a surface along the
* x axis (horizontal direction) for blts.
*)
DDFXCAPS_BLTSTRETCHX = $00004000;
{$EXTERNALSYM DDFXCAPS_BLTSTRETCHX}
(*
* DirectDraw supports integer stretching (1x,2x,) of a surface
* along the x axis (horizontal direction) for blts.
*)
DDFXCAPS_BLTSTRETCHXN = $00008000;
{$EXTERNALSYM DDFXCAPS_BLTSTRETCHXN}
(*
* DirectDraw supports arbitrary stretching of a surface along the
* y axis (horizontal direction) for blts.
*)
DDFXCAPS_BLTSTRETCHY = $00010000;
{$EXTERNALSYM DDFXCAPS_BLTSTRETCHY}
(*
* DirectDraw supports integer stretching (1x,2x,) of a surface
* along the y axis (vertical direction) for blts.
*)
DDFXCAPS_BLTSTRETCHYN = $00020000;
{$EXTERNALSYM DDFXCAPS_BLTSTRETCHYN}
(*
* Uses arithmetic operations to stretch and shrink surfaces during
* overlay rather than pixel doubling techniques. Along the Y axis
* for overlays.
*)
DDFXCAPS_OVERLAYARITHSTRETCHY = $00040000;
{$EXTERNALSYM DDFXCAPS_OVERLAYARITHSTRETCHY}
(*
* 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 = $00000008;
{$EXTERNALSYM DDFXCAPS_OVERLAYARITHSTRETCHYN}
(*
* DirectDraw supports arbitrary shrinking of a surface along the
* x axis (horizontal direction) for overlays.
*)
DDFXCAPS_OVERLAYSHRINKX = $00080000;
{$EXTERNALSYM DDFXCAPS_OVERLAYSHRINKX}
(*
* DirectDraw supports integer shrinking (1x,2x,) of a surface
* along the x axis (horizontal direction) for overlays.
*)
DDFXCAPS_OVERLAYSHRINKXN = $00100000;
{$EXTERNALSYM DDFXCAPS_OVERLAYSHRINKXN}
(*
* DirectDraw supports arbitrary shrinking of a surface along the
* y axis (horizontal direction) for overlays.
*)
DDFXCAPS_OVERLAYSHRINKY = $00200000;
{$EXTERNALSYM DDFXCAPS_OVERLAYSHRINKY}
(*
* DirectDraw supports integer shrinking (1x,2x,) of a surface
* along the y axis (vertical direction) for overlays.
*)
DDFXCAPS_OVERLAYSHRINKYN = $00400000;
{$EXTERNALSYM DDFXCAPS_OVERLAYSHRINKYN}
(*
* DirectDraw supports arbitrary stretching of a surface along the
* x axis (horizontal direction) for overlays.
*)
DDFXCAPS_OVERLAYSTRETCHX = $00800000;
{$EXTERNALSYM DDFXCAPS_OVERLAYSTRETCHX}
(*
* DirectDraw supports integer stretching (1x,2x,) of a surface
* along the x axis (horizontal direction) for overlays.
*)
DDFXCAPS_OVERLAYSTRETCHXN = $01000000;
{$EXTERNALSYM DDFXCAPS_OVERLAYSTRETCHXN}
(*
* DirectDraw supports arbitrary stretching of a surface along the
* y axis (horizontal direction) for overlays.
*)
DDFXCAPS_OVERLAYSTRETCHY = $02000000;
{$EXTERNALSYM DDFXCAPS_OVERLAYSTRETCHY}
(*
* DirectDraw supports integer stretching (1x,2x,) of a surface
* along the y axis (vertical direction) for overlays.
*)
DDFXCAPS_OVERLAYSTRETCHYN = $04000000;
{$EXTERNALSYM DDFXCAPS_OVERLAYSTRETCHYN}
(*
* DirectDraw supports mirroring of overlays across the vertical axis
*)
DDFXCAPS_OVERLAYMIRRORLEFTRIGHT = $08000000;
{$EXTERNALSYM DDFXCAPS_OVERLAYMIRRORLEFTRIGHT}
(*
* DirectDraw supports mirroring of overlays across the horizontal axis
*)
DDFXCAPS_OVERLAYMIRRORUPDOWN = $10000000;
{$EXTERNALSYM DDFXCAPS_OVERLAYMIRRORUPDOWN}
(*
* DirectDraw supports deinterlacing of overlay surfaces
*)
DDFXCAPS_OVERLAYDEINTERLACE = $20000000;
{$EXTERNALSYM DDFXCAPS_OVERLAYDEINTERLACE}
(*
* Driver can do alpha blending for blits.
*)
DDFXCAPS_BLTALPHA = $00000001;
{$EXTERNALSYM DDFXCAPS_BLTALPHA}
(*
* Driver can do geometric transformations (or warps) for blits.
*)
DDFXCAPS_BLTTRANSFORM = $00000002;
{$EXTERNALSYM DDFXCAPS_BLTTRANSFORM}
(*
* Driver can do surface-reconstruction filtering for warped blits.
*)
DDFXCAPS_BLTFILTER = DDFXCAPS_BLTARITHSTRETCHY;
{$EXTERNALSYM DDFXCAPS_BLTFILTER}
(*
* Driver can do alpha blending for overlays.
*)
DDFXCAPS_OVERLAYALPHA = $00000004;
{$EXTERNALSYM DDFXCAPS_OVERLAYALPHA}
(*
* Driver can do geometric transformations (or warps) for overlays.
*)
DDFXCAPS_OVERLAYTRANSFORM = $20000000;
{$EXTERNALSYM DDFXCAPS_OVERLAYTRANSFORM}
(*
* Driver can do surface-reconstruction filtering for warped overlays.
*)
DDFXCAPS_OVERLAYFILTER = DDFXCAPS_OVERLAYARITHSTRETCHY;
{$EXTERNALSYM DDFXCAPS_OVERLAYFILTER}
(****************************************************************************
*
* DIRECTDRAW STEREO VIEW CAPABILITIES
*
****************************************************************************)
(*
* This flag used to be DDSVCAPS_ENIGMA, which is now obsolete
*)
DDSVCAPS_RESERVED1 = $00000001;
{$EXTERNALSYM DDSVCAPS_RESERVED1}
(*
* This flag used to be DDSVCAPS_FLICKER, which is now obsolete
*)
DDSVCAPS_RESERVED2 = $00000002;
{$EXTERNALSYM DDSVCAPS_RESERVED2}
(*
* This flag used to be DDSVCAPS_REDBLUE, which is now obsolete
*)
DDSVCAPS_RESERVED3 = $00000004;
{$EXTERNALSYM DDSVCAPS_RESERVED3}
(*
* This flag used to be DDSVCAPS_SPLIT, which is now obsolete
*)
DDSVCAPS_RESERVED4 = $00000008;
{$EXTERNALSYM DDSVCAPS_RESERVED4}
(*
* The stereo view is accomplished with switching technology
*)
DDSVCAPS_STEREOSEQUENTIAL = $00000010;
{$EXTERNALSYM DDSVCAPS_STEREOSEQUENTIAL}
(****************************************************************************
*
* DIRECTDRAWPALETTE CAPABILITIES
*
****************************************************************************)
(*
* Index is 4 bits. There are sixteen color entries in the palette table.
*)
DDPCAPS_4BIT = $00000001;
{$EXTERNALSYM DDPCAPS_4BIT}
(*
* 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 long and is an index
* into destination surface's 8bpp palette.
*)
DDPCAPS_8BITENTRIES = $00000002;
{$EXTERNALSYM DDPCAPS_8BITENTRIES}
(*
* Index is 8 bits. There are 256 color entries in the palette table.
*)
DDPCAPS_8BIT = $00000004;
{$EXTERNALSYM DDPCAPS_8BIT}
(*
* Indicates that this DIRECTDRAWPALETTE should use the palette color array
* passed into the lpDDColorArray parameter to initialize the DIRECTDRAWPALETTE
* object.
* This flag is obsolete. DirectDraw always initializes the color array from
* the lpDDColorArray parameter. The definition remains for source-level
* compatibility.
*)
DDPCAPS_INITIALIZE = $00000008;
{$EXTERNALSYM DDPCAPS_INITIALIZE}
(*
* 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 = $00000010;
{$EXTERNALSYM DDPCAPS_PRIMARYSURFACE}
(*
* 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 = $00000020;
{$EXTERNALSYM DDPCAPS_PRIMARYSURFACELEFT}
(*
* This palette can have all 256 entries defined
*)
DDPCAPS_ALLOW256 = $00000040;
{$EXTERNALSYM DDPCAPS_ALLOW256}
(*
* This palette can have modifications to it synced with the monitors
* refresh rate.
*)
DDPCAPS_VSYNC = $00000080;
{$EXTERNALSYM DDPCAPS_VSYNC}
(*
* Index is 1 bit. There are two color entries in the palette table.
*)
DDPCAPS_1BIT = $00000100;
{$EXTERNALSYM DDPCAPS_1BIT}
(*
* Index is 2 bit. There are four color entries in the palette table.
*)
DDPCAPS_2BIT = $00000200;
{$EXTERNALSYM DDPCAPS_2BIT}
(*
* The peFlags member of PALETTEENTRY denotes an 8 bit alpha value
*)
DDPCAPS_ALPHA = $00000400;
{$EXTERNALSYM DDPCAPS_ALPHA}
(****************************************************************************
*
* DIRECTDRAWPALETTE SETENTRY CONSTANTS
*
****************************************************************************)
(****************************************************************************
*
* DIRECTDRAWPALETTE GETENTRY CONSTANTS
*
****************************************************************************)
(* 0 is the only legal value *)
(****************************************************************************
*
* DIRECTDRAWSURFACE SETPRIVATEDATA CONSTANTS
*
****************************************************************************)
(*
* The passed pointer is an IUnknown ptr. The cbData argument to SetPrivateData
* must be set to SizeOf(IUnknown^). DirectDraw will call AddRef through this
* pointer and Release when the private data is destroyed. This includes when
* the surface or palette is destroyed before such priovate data is destroyed.
*)
DDSPD_IUNKNOWNPOINTER = $00000001;
{$EXTERNALSYM DDSPD_IUNKNOWNPOINTER}
(*
* Private data is only valid for the current state of the object,
* as determined by the uniqueness value.
*)
DDSPD_VOLATILE = $00000002;
{$EXTERNALSYM DDSPD_VOLATILE}
(****************************************************************************
*
* 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 = $00004000;
{$EXTERNALSYM DDBD_1}
(*
* 2 bits per pixel.
*)
DDBD_2 = $00002000;
{$EXTERNALSYM DDBD_2}
(*
* 4 bits per pixel.
*)
DDBD_4 = $00001000;
{$EXTERNALSYM DDBD_4}
(*
* 8 bits per pixel.
*)
DDBD_8 = $00000800;
{$EXTERNALSYM DDBD_8}
(*
* 16 bits per pixel.
*)
DDBD_16 = $00000400;
{$EXTERNALSYM DDBD_16}
(*
* 24 bits per pixel.
*)
DDBD_24 = $00000200;
{$EXTERNALSYM DDBD_24}
(*
* 32 bits per pixel.
*)
DDBD_32 = $00000100;
{$EXTERNALSYM DDBD_32}
(****************************************************************************
*
* 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 = $00000001;
{$EXTERNALSYM DDCKEY_COLORSPACE}
(*
* 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 = $00000002;
{$EXTERNALSYM DDCKEY_DESTBLT}
(*
* 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 = $00000004;
{$EXTERNALSYM DDCKEY_DESTOVERLAY}
(*
* 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 = $00000008;
{$EXTERNALSYM DDCKEY_SRCBLT}
(*
* 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 = $00000010;
{$EXTERNALSYM DDCKEY_SRCOVERLAY}
(****************************************************************************
*
* 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 = $00000001;
{$EXTERNALSYM DDCKEYCAPS_DESTBLT}
(*
* Supports transparent blting using a color space to identify the replaceable
* bits of the destination surface for RGB colors.
*)
DDCKEYCAPS_DESTBLTCLRSPACE = $00000002;
{$EXTERNALSYM DDCKEYCAPS_DESTBLTCLRSPACE}
(*
* Supports transparent blting using a color space to identify the replaceable
* bits of the destination surface for YUV colors.
*)
DDCKEYCAPS_DESTBLTCLRSPACEYUV = $00000004;
{$EXTERNALSYM DDCKEYCAPS_DESTBLTCLRSPACEYUV}
(*
* Supports transparent blting using a color key to identify the replaceable
* bits of the destination surface for YUV colors.
*)
DDCKEYCAPS_DESTBLTYUV = $00000008;
{$EXTERNALSYM DDCKEYCAPS_DESTBLTYUV}
(*
* Supports overlaying using colorkeying of the replaceable bits of the surface
* being overlayed for RGB colors.
*)
DDCKEYCAPS_DESTOVERLAY = $00000010;
{$EXTERNALSYM DDCKEYCAPS_DESTOVERLAY}
(*
* Supports a color space as the color key for the destination for RGB colors.
*)
DDCKEYCAPS_DESTOVERLAYCLRSPACE = $00000020;
{$EXTERNALSYM DDCKEYCAPS_DESTOVERLAYCLRSPACE}
(*
* Supports a color space as the color key for the destination for YUV colors.
*)
DDCKEYCAPS_DESTOVERLAYCLRSPACEYUV = $00000040;
{$EXTERNALSYM DDCKEYCAPS_DESTOVERLAYCLRSPACEYUV}
(*
* Supports only one active destination color key value for visible overlay
* surfaces.
*)
DDCKEYCAPS_DESTOVERLAYONEACTIVE = $00000080;
{$EXTERNALSYM DDCKEYCAPS_DESTOVERLAYONEACTIVE}
(*
* Supports overlaying using colorkeying of the replaceable bits of the
* surface being overlayed for YUV colors.
*)
DDCKEYCAPS_DESTOVERLAYYUV = $00000100;
{$EXTERNALSYM DDCKEYCAPS_DESTOVERLAYYUV}
(*
* Supports transparent blting using the color key for the source with
* this surface for RGB colors.
*)
DDCKEYCAPS_SRCBLT = $00000200;
{$EXTERNALSYM DDCKEYCAPS_SRCBLT}
(*
* Supports transparent blting using a color space for the source with
* this surface for RGB colors.
*)
DDCKEYCAPS_SRCBLTCLRSPACE = $00000400;
{$EXTERNALSYM DDCKEYCAPS_SRCBLTCLRSPACE}
(*
* Supports transparent blting using a color space for the source with
* this surface for YUV colors.
*)
DDCKEYCAPS_SRCBLTCLRSPACEYUV = $00000800;
{$EXTERNALSYM DDCKEYCAPS_SRCBLTCLRSPACEYUV}
(*
* Supports transparent blting using the color key for the source with
* this surface for YUV colors.
*)
DDCKEYCAPS_SRCBLTYUV = $00001000;
{$EXTERNALSYM DDCKEYCAPS_SRCBLTYUV}
(*
* Supports overlays using the color key for the source with this
* overlay surface for RGB colors.
*)
DDCKEYCAPS_SRCOVERLAY = $00002000;
{$EXTERNALSYM DDCKEYCAPS_SRCOVERLAY}
(*
* Supports overlays using a color space as the source color key for
* the overlay surface for RGB colors.
*)
DDCKEYCAPS_SRCOVERLAYCLRSPACE = $00004000;
{$EXTERNALSYM DDCKEYCAPS_SRCOVERLAYCLRSPACE}
(*
* Supports overlays using a color space as the source color key for
* the overlay surface for YUV colors.
*)
DDCKEYCAPS_SRCOVERLAYCLRSPACEYUV = $00008000;
{$EXTERNALSYM DDCKEYCAPS_SRCOVERLAYCLRSPACEYUV}
(*
* Supports only one active source color key value for visible
* overlay surfaces.
*)
DDCKEYCAPS_SRCOVERLAYONEACTIVE = $00010000;
{$EXTERNALSYM DDCKEYCAPS_SRCOVERLAYONEACTIVE}
(*
* Supports overlays using the color key for the source with this
* overlay surface for YUV colors.
*)
DDCKEYCAPS_SRCOVERLAYYUV = $00020000;
{$EXTERNALSYM DDCKEYCAPS_SRCOVERLAYYUV}
(*
* there are no bandwidth trade-offs for using colorkey with an overlay
*)
DDCKEYCAPS_NOCOSTOVERLAY = $00040000;
{$EXTERNALSYM DDCKEYCAPS_NOCOSTOVERLAY}
(****************************************************************************
*
* DIRECTDRAW PIXELFORMAT FLAGS
*
****************************************************************************)
(*
* The surface has alpha channel information in the pixel format.
*)
DDPF_ALPHAPIXELS = $00000001;
{$EXTERNALSYM DDPF_ALPHAPIXELS}
(*
* The pixel format contains alpha only information
*)
DDPF_ALPHA = $00000002;
{$EXTERNALSYM DDPF_ALPHA}
(*
* The FourCC code is valid.
*)
DDPF_FOURCC = $00000004;
{$EXTERNALSYM DDPF_FOURCC}
(*
* The surface is 4-bit color indexed.
*)
DDPF_PALETTEINDEXED4 = $00000008;
{$EXTERNALSYM DDPF_PALETTEINDEXED4}
(*
* The surface is indexed into a palette which stores indices
* into the destination surface's 8-bit palette.
*)
DDPF_PALETTEINDEXEDTO8 = $00000010;
{$EXTERNALSYM DDPF_PALETTEINDEXEDTO8}
(*
* The surface is 8-bit color indexed.
*)
DDPF_PALETTEINDEXED8 = $00000020;
{$EXTERNALSYM DDPF_PALETTEINDEXED8}
(*
* The RGB data in the pixel format structure is valid.
*)
DDPF_RGB = $00000040;
{$EXTERNALSYM DDPF_RGB}
(*
* The surface will accept pixel data in the format specified
* and compress it during the write.
*)
DDPF_COMPRESSED = $00000080;
{$EXTERNALSYM DDPF_COMPRESSED}
(*
* 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 = $00000100;
{$EXTERNALSYM DDPF_RGBTOYUV}
(*
* pixel format is YUV - YUV data in pixel format struct is valid
*)
DDPF_YUV = $00000200;
{$EXTERNALSYM DDPF_YUV}
(*
* pixel format is a z buffer only surface
*)
DDPF_ZBUFFER = $00000400;
{$EXTERNALSYM DDPF_ZBUFFER}
(*
* The surface is 1-bit color indexed.
*)
DDPF_PALETTEINDEXED1 = $00000800;
{$EXTERNALSYM DDPF_PALETTEINDEXED1}
(*
* The surface is 2-bit color indexed.
*)
DDPF_PALETTEINDEXED2 = $00001000;
{$EXTERNALSYM DDPF_PALETTEINDEXED2}
(*
* The surface contains Z information in the pixels
*)
DDPF_ZPIXELS = $00002000;
{$EXTERNALSYM DDPF_ZPIXELS}
(*
* The surface contains stencil information along with Z
*)
DDPF_STENCILBUFFER = $00004000;
{$EXTERNALSYM DDPF_STENCILBUFFER}
(*
* Premultiplied alpha format -- the color components have been
* premultiplied by the alpha component.
*)
DDPF_ALPHAPREMULT = $00008000;
{$EXTERNALSYM DDPF_ALPHAPREMULT}
(*
* Luminance data in the pixel format is valid.
* Use this flag for luminance-only or luminance+alpha surfaces,
* the bit depth is then ddpf.dwLuminanceBitCount.
*)
DDPF_LUMINANCE = $00020000;
{$EXTERNALSYM DDPF_LUMINANCE}
(*
* Luminance data in the pixel format is valid.
* Use this flag when hanging luminance off bumpmap surfaces,
* the bit mask for the luminance portion of the pixel is then
* ddpf.dwBumpLuminanceBitMask
*)
DDPF_BUMPLUMINANCE = $00040000;
{$EXTERNALSYM DDPF_BUMPLUMINANCE}
(*
* Bump map dUdV data in the pixel format is valid.
*)
DDPF_BUMPDUDV = $00080000;
{$EXTERNALSYM DDPF_BUMPDUDV}
(*===========================================================================
*
*
* DIRECTDRAW CALLBACK FLAGS
*
*
*==========================================================================*)
(****************************************************************************
*
* DIRECTDRAW ENUMSURFACES FLAGS
*
****************************************************************************)
(*
* Enumerate all of the surfaces that meet the search criterion.
*)
DDENUMSURFACES_ALL = $00000001;
{$EXTERNALSYM DDENUMSURFACES_ALL}
{$EXTERNALSYM DDENUMSURFACES_ALL}
(*
* A search hit is a surface that matches the surface description.
*)
DDENUMSURFACES_MATCH = $00000002;
{$EXTERNALSYM DDENUMSURFACES_MATCH}
(*
* A search hit is a surface that does not match the surface description.
*)
DDENUMSURFACES_NOMATCH = $00000004;
{$EXTERNALSYM DDENUMSURFACES_NOMATCH}
(*
* Enumerate the first surface that can be created which meets the search criterion.
*)
DDENUMSURFACES_CANBECREATED = $00000008;
{$EXTERNALSYM DDENUMSURFACES_CANBECREATED}
(*
* Enumerate the surfaces that already exist that meet the search criterion.
*)
DDENUMSURFACES_DOESEXIST = $00000010;
{$EXTERNALSYM DDENUMSURFACES_DOESEXIST}
(****************************************************************************
*
* DIRECTDRAW SETDISPLAYMODE FLAGS
*
****************************************************************************)
(*
* The desired mode is a standard VGA mode
*)
DDSDM_STANDARDVGAMODE = $00000001;
{$EXTERNALSYM DDSDM_STANDARDVGAMODE}
(****************************************************************************
*
* 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 = $00000001;
{$EXTERNALSYM DDEDM_REFRESHRATES}
(*
* 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 = $00000002;
{$EXTERNALSYM DDEDM_STANDARDVGAMODES}
(****************************************************************************
*
* DIRECTDRAW SETCOOPERATIVELEVEL FLAGS
*
****************************************************************************)
(*
* Exclusive mode owner will be responsible for the entire primary surface.
* GDI can be ignored. used with DD
*)
DDSCL_FULLSCREEN = $00000001;
{$EXTERNALSYM DDSCL_FULLSCREEN}
(*
* allow CTRL_ALT_DEL to work while in fullscreen exclusive mode
*)
DDSCL_ALLOWREBOOT = $00000002;
{$EXTERNALSYM DDSCL_ALLOWREBOOT}
(*
* prevents DDRAW from modifying the application window.
* prevents DDRAW from minimize/restore the application window on activation.
*)
DDSCL_NOWINDOWCHANGES = $00000004;
{$EXTERNALSYM DDSCL_NOWINDOWCHANGES}
(*
* app wants to work as a regular Windows application
*)
DDSCL_NORMAL = $00000008;
{$EXTERNALSYM DDSCL_NORMAL}
(*
* app wants exclusive access
*)
DDSCL_EXCLUSIVE = $00000010;
{$EXTERNALSYM DDSCL_EXCLUSIVE}
(*
* app can deal with non-windows display modes
*)
DDSCL_ALLOWMODEX = $00000040;
{$EXTERNALSYM DDSCL_ALLOWMODEX}
(*
* this window will receive the focus messages
*)
DDSCL_SETFOCUSWINDOW = $00000080;
{$EXTERNALSYM DDSCL_SETFOCUSWINDOW}
(*
* this window is associated with the DDRAW object and will
* cover the screen in fullscreen mode
*)
DDSCL_SETDEVICEWINDOW = $00000100;
{$EXTERNALSYM DDSCL_SETDEVICEWINDOW}
(*
* app wants DDRAW to create a window to be associated with the
* DDRAW object
*)
DDSCL_CREATEDEVICEWINDOW = $00000200;
{$EXTERNALSYM DDSCL_CREATEDEVICEWINDOW}
(*
* App explicitly asks DDRAW/D3D to be multithread safe. This makes D3D
* take the global crtisec more frequently.
*)
DDSCL_MULTITHREADED = $00000400;
{$EXTERNALSYM DDSCL_MULTITHREADED}
(*
* App specifies that it would like to keep the FPU set up for optimal Direct3D
* performance (single precision and exceptions disabled) so Direct3D
* does not need to explicitly set the FPU each time. This is assumed by
* default in DirectX 7. See also DDSCL_FPUPRESERVE
*)
DDSCL_FPUSETUP = $00000800;
{$EXTERNALSYM DDSCL_FPUSETUP}
(*
* App specifies that it needs either double precision FPU or FPU exceptions
* enabled. This makes Direct3D explicitly set the FPU state eah time it is
* called. Setting the flag will reduce Direct3D performance. The flag is
* assumed by default in DirectX 6 and earlier. See also DDSCL_FPUSETUP
*)
DDSCL_FPUPRESERVE = $00001000;
{$EXTERNALSYM DDSCL_FPUPRESERVE}
(****************************************************************************
*
* 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 = $00000001;
{$EXTERNALSYM DDBLT_ALPHADEST}
(*
* Use the dwConstAlphaDest field in the DDBLTFX structure as the alpha channel
* for the destination surface for this blt.
*)
DDBLT_ALPHADESTCONSTOVERRIDE = $00000002;
{$EXTERNALSYM DDBLT_ALPHADESTCONSTOVERRIDE}
(*
* The NEG suffix indicates that the destination surface becomes more
* transparent as the alpha value increases. (0 is opaque)
*)
DDBLT_ALPHADESTNEG = $00000004;
{$EXTERNALSYM DDBLT_ALPHADESTNEG}
(*
* Use the lpDDSAlphaDest field in the DDBLTFX structure as the alpha
* channel for the destination for this blt.
*)
DDBLT_ALPHADESTSURFACEOVERRIDE = $00000008;
{$EXTERNALSYM DDBLT_ALPHADESTSURFACEOVERRIDE}
(*
* 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 = $00000010;
{$EXTERNALSYM DDBLT_ALPHAEDGEBLEND}
(*
* 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 = $00000020;
{$EXTERNALSYM DDBLT_ALPHASRC}
(*
* Use the dwConstAlphaSrc field in the DDBLTFX structure as the alpha channel
* for the source for this blt.
*)
DDBLT_ALPHASRCCONSTOVERRIDE = $00000040;
{$EXTERNALSYM DDBLT_ALPHASRCCONSTOVERRIDE}
(*
* The NEG suffix indicates that the source surface becomes more transparent
* as the alpha value increases. (0 is opaque)
*)
DDBLT_ALPHASRCNEG = $00000080;
{$EXTERNALSYM DDBLT_ALPHASRCNEG}
(*
* Use the lpDDSAlphaSrc field in the DDBLTFX structure as the alpha channel
* for the source for this blt.
*)
DDBLT_ALPHASRCSURFACEOVERRIDE = $00000100;
{$EXTERNALSYM DDBLT_ALPHASRCSURFACEOVERRIDE}
(*
* 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 = $00000200;
{$EXTERNALSYM DDBLT_ASYNC}
(*
* Uses the dwFillColor field in the DDBLTFX structure as the RGB color
* to fill the destination rectangle on the destination surface with.
*)
DDBLT_COLORFILL = $00000400;
{$EXTERNALSYM DDBLT_COLORFILL}
(*
* Uses the dwDDFX field in the DDBLTFX structure to specify the effects
* to use for the blt.
*)
DDBLT_DDFX = $00000800;
{$EXTERNALSYM DDBLT_DDFX}
(*
* Uses the dwDDROPS field in the DDBLTFX structure to specify the ROPS
* that are not part of the Win32 API.
*)
DDBLT_DDROPS = $00001000;
{$EXTERNALSYM DDBLT_DDROPS}
(*
* Use the color key associated with the destination surface.
*)
DDBLT_KEYDEST = $00002000;
{$EXTERNALSYM DDBLT_KEYDEST}
(*
* Use the dckDestColorkey field in the DDBLTFX structure as the color key
* for the destination surface.
*)
DDBLT_KEYDESTOVERRIDE = $00004000;
{$EXTERNALSYM DDBLT_KEYDESTOVERRIDE}
(*
* Use the color key associated with the source surface.
*)
DDBLT_KEYSRC = $00008000;
{$EXTERNALSYM DDBLT_KEYSRC}
(*
* Use the dckSrcColorkey field in the DDBLTFX structure as the color key
* for the source surface.
*)
DDBLT_KEYSRCOVERRIDE = $00010000;
{$EXTERNALSYM DDBLT_KEYSRCOVERRIDE}
(*
* 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 = $00020000;
{$EXTERNALSYM DDBLT_ROP}
(*
* Use the dwRotationAngle field in the DDBLTFX structure as the angle
* (specified in 1/100th of a degree) to rotate the surface.
*)
DDBLT_ROTATIONANGLE = $00040000;
{$EXTERNALSYM DDBLT_ROTATIONANGLE}
(*
* 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 = $00080000;
{$EXTERNALSYM DDBLT_ZBUFFER}
(*
* 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 = $00100000;
{$EXTERNALSYM DDBLT_ZBUFFERDESTCONSTOVERRIDE}
(*
* 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 = $00200000;
{$EXTERNALSYM DDBLT_ZBUFFERDESTOVERRIDE}
(*
* 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 = $00400000;
{$EXTERNALSYM DDBLT_ZBUFFERSRCCONSTOVERRIDE}
(*
* 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 = $00800000;
{$EXTERNALSYM DDBLT_ZBUFFERSRCOVERRIDE}
(*
* wait until the device is ready to handle the blt
* this will cause blt to not return DDERR_WASSTILLDRAWING
*)
DDBLT_WAIT = $01000000;
{$EXTERNALSYM DDBLT_WAIT}
(*
* 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 = $02000000;
{$EXTERNALSYM DDBLT_DEPTHFILL}
(*
* wait until the device is ready to handle the blt
* this will cause blt to not return DDERR_WASSTILLDRAWING
*)
DDBLT_DONOTWAIT = $08000000;
{$EXTERNALSYM DDBLT_DONOTWAIT}
(*
* These flags indicate a presentation blt (i.e. a blt
* that moves surface contents from an offscreen back buffer to the primary
* surface). The driver is not allowed to "queue" more than three such blts.
* The "end" of the presentation blt is indicated, since the
* blt may be clipped, in which case the runtime will call the driver with
* several blts. All blts (even if not clipped) are tagged with DDBLT_PRESENTATION
* and the last (even if not clipped) additionally with DDBLT_LAST_PRESENTATION.
* Thus the true rule is that the driver must not schedule a DDBLT_PRESENTATION
* blt if there are 3 or more DDBLT_PRESENTLAST blts in the hardware pipe.
* If there are such blts in the pipe, the driver should return DDERR_WASSTILLDRAWING
* until the oldest queued DDBLT_LAST_PRESENTATION blts has been retired (i.e. the
* pixels have been actually written to the primary surface). Once the oldest blt
* has been retired, the driver is free to schedule the current blt.
* The goal is to provide a mechanism whereby the device's hardware queue never
* gets more than 3 frames ahead of the frames being generated by the application.
* When excessive queueing occurs, applications become unusable because the application
* visibly lags user input, and such problems make windowed interactive applications impossible.
* Some drivers may not have sufficient knowledge of their hardware's FIFO to know
* when a certain blt has been retired. Such drivers should code cautiously, and
* simply not allow any frames to be queued at all. DDBLT_LAST_PRESENTATION should cause
* such drivers to return DDERR_WASSTILLDRAWING until the accelerator is completely
* finished- exactly as if the application had called Lock on the source surface
* before calling Blt.
* In other words, the driver is allowed and encouraged to
* generate as much latency as it can, but never more than 3 frames worth.
* Implementation detail: Drivers should count blts against the SOURCE surface, not
* against the primary surface. This enables multiple parallel windowed application
* to function more optimally.
* This flag is passed only to DX8 or higher drivers.
*
* APPLICATIONS DO NOT SET THESE FLAGS. THEY ARE SET BY THE DIRECTDRAW RUNTIME.
*
*)
DDBLT_PRESENTATION = $10000000;
{$EXTERNALSYM DDBLT_PRESENTATION}
DDBLT_LAST_PRESENTATION = $20000000;
{$EXTERNALSYM DDBLT_LAST_PRESENTATION}
(****************************************************************************
*
* BLTFAST FLAGS
*
****************************************************************************)
DDBLTFAST_NOCOLORKEY = $00000000;
{$EXTERNALSYM DDBLTFAST_NOCOLORKEY}
DDBLTFAST_SRCCOLORKEY = $00000001;
{$EXTERNALSYM DDBLTFAST_SRCCOLORKEY}
DDBLTFAST_DESTCOLORKEY = $00000002;
{$EXTERNALSYM DDBLTFAST_DESTCOLORKEY}
DDBLTFAST_WAIT = $00000010;
{$EXTERNALSYM DDBLTFAST_WAIT}
DDBLTFAST_DONOTWAIT = $00000020;
{$EXTERNALSYM DDBLTFAST_DONOTWAIT}
(****************************************************************************
*
* FLIP FLAGS
*
****************************************************************************)
DDFLIP_WAIT = $00000001;
{$EXTERNALSYM DDFLIP_WAIT}
(*
* Indicates that the target surface contains the even field of video data.
* This flag is only valid with an overlay surface.
*)
DDFLIP_EVEN = $00000002;
{$EXTERNALSYM DDFLIP_EVEN}
(*
* Indicates that the target surface contains the odd field of video data.
* This flag is only valid with an overlay surface.
*)
DDFLIP_ODD = $00000004;
{$EXTERNALSYM DDFLIP_ODD}
(*
* Causes DirectDraw to perform the physical flip immediately and return
* to the application. Typically, what was the front buffer but is now the back
* buffer will still be visible (depending on timing) until the next vertical
* retrace. Subsequent operations involving the two flipped surfaces will
* not check to see if the physical flip has finished (i.e. will not return
* DDERR_WASSTILLDRAWING for that reason (but may for other reasons)).
* This allows an application to perform Flips at a higher frequency than the
* monitor refresh rate, but may introduce visible artifacts.
* Only effective if DDCAPS2_FLIPNOVSYNC is set. If that bit is not set,
* DDFLIP_NOVSYNC has no effect.
*)
DDFLIP_NOVSYNC = $00000008;
{$EXTERNALSYM DDFLIP_NOVSYNC}
(*
* Flip Interval Flags. These flags indicate how many vertical retraces to wait between
* each flip. The default is one. DirectDraw will return DDERR_WASSTILLDRAWING for each
* surface involved in the flip until the specified number of vertical retraces has
* ocurred. Only effective if DDCAPS2_FLIPINTERVAL is set. If that bit is not set,
* DDFLIP_INTERVALn has no effect.
*)
(*
* DirectDraw will flip on every other vertical sync
*)
DDFLIP_INTERVAL2 = $02000000;
{$EXTERNALSYM DDFLIP_INTERVAL2}
(*
* DirectDraw will flip on every third vertical sync
*)
DDFLIP_INTERVAL3 = $03000000;
{$EXTERNALSYM DDFLIP_INTERVAL3}
(*
* DirectDraw will flip on every fourth vertical sync
*)
DDFLIP_INTERVAL4 = $04000000;
{$EXTERNALSYM DDFLIP_INTERVAL4}
(*
* DirectDraw will flip and display a main stereo surface
*)
DDFLIP_STEREO = $00000010;
{$EXTERNALSYM DDFLIP_STEREO}
(*
* On IDirectDrawSurface7 and higher interfaces, the default is DDFLIP_WAIT. If you wish
* to override the default and use time when the accelerator is busy (as denoted by
* the DDERR_WASSTILLDRAWING return code) then use DDFLIP_DONOTWAIT.
*)
DDFLIP_DONOTWAIT = $00000020;
{$EXTERNALSYM DDFLIP_DONOTWAIT}
(****************************************************************************
*
* 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 = $00000001;
{$EXTERNALSYM DDOVER_ALPHADEST}
(*
* Use the dwConstAlphaDest field in the DDOVERLAYFX structure as the
* destination alpha channel for this overlay.
*)
DDOVER_ALPHADESTCONSTOVERRIDE = $00000002;
{$EXTERNALSYM DDOVER_ALPHADESTCONSTOVERRIDE}
(*
* The NEG suffix indicates that the destination surface becomes more
* transparent as the alpha value increases.
*)
DDOVER_ALPHADESTNEG = $00000004;
{$EXTERNALSYM DDOVER_ALPHADESTNEG}
(*
* Use the lpDDSAlphaDest field in the DDOVERLAYFX structure as the alpha
* channel destination for this overlay.
*)
DDOVER_ALPHADESTSURFACEOVERRIDE = $00000008;
{$EXTERNALSYM DDOVER_ALPHADESTSURFACEOVERRIDE}
(*
* 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 = $00000010;
{$EXTERNALSYM DDOVER_ALPHAEDGEBLEND}
(*
* 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 = $00000020;
{$EXTERNALSYM DDOVER_ALPHASRC}
(*
* Use the dwConstAlphaSrc field in the DDOVERLAYFX structure as the source
* alpha channel for this overlay.
*)
DDOVER_ALPHASRCCONSTOVERRIDE = $00000040;
{$EXTERNALSYM DDOVER_ALPHASRCCONSTOVERRIDE}
(*
* The NEG suffix indicates that the source surface becomes more transparent
* as the alpha value increases.
*)
DDOVER_ALPHASRCNEG = $00000080;
{$EXTERNALSYM DDOVER_ALPHASRCNEG}
(*
* Use the lpDDSAlphaSrc field in the DDOVERLAYFX structure as the alpha channel
* source for this overlay.
*)
DDOVER_ALPHASRCSURFACEOVERRIDE = $00000100;
{$EXTERNALSYM DDOVER_ALPHASRCSURFACEOVERRIDE}
(*
* Turn this overlay off.
*)
DDOVER_HIDE = $00000200;
{$EXTERNALSYM DDOVER_HIDE}
(*
* Use the color key associated with the destination surface.
*)
DDOVER_KEYDEST = $00000400;
{$EXTERNALSYM DDOVER_KEYDEST}
(*
* Use the dckDestColorkey field in the DDOVERLAYFX structure as the color key
* for the destination surface
*)
DDOVER_KEYDESTOVERRIDE = $00000800;
{$EXTERNALSYM DDOVER_KEYDESTOVERRIDE}
(*
* Use the color key associated with the source surface.
*)
DDOVER_KEYSRC = $00001000;
{$EXTERNALSYM DDOVER_KEYSRC}
(*
* Use the dckSrcColorkey field in the DDOVERLAYFX structure as the color key
* for the source surface.
*)
DDOVER_KEYSRCOVERRIDE = $00002000;
{$EXTERNALSYM DDOVER_KEYSRCOVERRIDE}
(*
* Turn this overlay on.
*)
DDOVER_SHOW = $00004000;
{$EXTERNALSYM DDOVER_SHOW}
(*
* Add a dirty rect to an emulated overlayed surface.
*)
DDOVER_ADDDIRTYRECT = $00008000;
{$EXTERNALSYM DDOVER_ADDDIRTYRECT}
(*
* Redraw all dirty rects on an emulated overlayed surface.
*)
DDOVER_REFRESHDIRTYRECTS = $00010000;
{$EXTERNALSYM DDOVER_REFRESHDIRTYRECTS}
(*
* Redraw the entire surface on an emulated overlayed surface.
*)
DDOVER_REFRESHALL = $00020000;
{$EXTERNALSYM DDOVER_REFRESHALL}
(*
* Use the overlay FX flags to define special overlay FX
*)
DDOVER_DDFX = $00080000;
{$EXTERNALSYM DDOVER_DDFX}
(*
* Autoflip the overlay when ever the video port autoflips
*)
DDOVER_AUTOFLIP = $00100000;
{$EXTERNALSYM DDOVER_AUTOFLIP}
(*
* Display each field of video port data individually without
* causing any jittery artifacts
*)
DDOVER_BOB = $00200000;
{$EXTERNALSYM DDOVER_BOB}
(*
* Indicates that bob/weave decisions should not be overridden by other
* interfaces.
*)
DDOVER_OVERRIDEBOBWEAVE = $00400000;
{$EXTERNALSYM DDOVER_OVERRIDEBOBWEAVE}
(*
* Indicates that the surface memory is composed of interleaved fields.
*)
DDOVER_INTERLEAVED = $00800000;
{$EXTERNALSYM DDOVER_INTERLEAVED}
(*
* Indicates that bob will be performed using hardware rather than
* software or emulated.
*)
DDOVER_BOBHARDWARE = $01000000;
{$EXTERNALSYM DDOVER_BOBHARDWARE}
(*
* Indicates that overlay FX structure contains valid ARGB scaling factors.
*)
DDOVER_ARGBSCALEFACTORS = $02000000;
{$EXTERNALSYM DDOVER_ARGBSCALEFACTORS}
(*
* Indicates that ARGB scaling factors can be degraded to fit driver capabilities.
*)
DDOVER_DEGRADEARGBSCALING = $04000000;
{$EXTERNALSYM DDOVER_DEGRADEARGBSCALING}
(****************************************************************************
*
* 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 = $00000000; // = default
{$EXTERNALSYM DDLOCK_SURFACEMEMORYPTR}
(*
* 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 = $00000001;
{$EXTERNALSYM DDLOCK_WAIT}
(*
* 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 = $00000002;
{$EXTERNALSYM DDLOCK_EVENT}
(*
* Indicates that the surface being locked will only be read from.
*)
DDLOCK_READONLY = $00000010;
{$EXTERNALSYM DDLOCK_READONLY}
(*
* Indicates that the surface being locked will only be written to
*)
DDLOCK_WRITEONLY = $00000020;
{$EXTERNALSYM DDLOCK_WRITEONLY}
(*
* 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 = $00000800;
{$EXTERNALSYM DDLOCK_NOSYSLOCK}
(*
* Used only with Direct3D Vertex Buffer Locks. Indicates that no vertices
* that were referred to in Draw*PrimtiveVB calls since the start of the
* frame (or the last lock without this flag) will be modified during the
* lock. This can be useful when one is only appending data to the vertex
* buffer
*)
DDLOCK_NOOVERWRITE = $00001000;
{$EXTERNALSYM DDLOCK_NOOVERWRITE}
(*
* Indicates that no assumptions will be made about the contents of the
* surface or vertex buffer during this lock.
* This enables two things:
* - Direct3D or the driver may provide an alternative memory
* area as the vertex buffer. This is useful when one plans to clear the
* contents of the vertex buffer and fill in new data.
* - Drivers sometimes store surface data in a re-ordered format.
* When the application locks the surface, the driver is forced to un-re-order
* the surface data before allowing the application to see the surface contents.
* This flag is a hint to the driver that it can skip the un-re-ordering process
* since the application plans to overwrite every single pixel in the surface
* or locked rectangle (and so erase any un-re-ordered pixels anyway).
* Applications should always set this flag when they intend to overwrite the entire
* surface or locked rectangle.
*)
DDLOCK_DISCARDCONTENTS = $00002000;
{$EXTERNALSYM DDLOCK_DISCARDCONTENTS}
(*
* DDLOCK_OKTOSWAP is an older, less informative name for DDLOCK_DISCARDCONTENTS
*)
DDLOCK_OKTOSWAP = $00002000;
{$EXTERNALSYM DDLOCK_OKTOSWAP}
(*
* On IDirectDrawSurface7 and higher interfaces, the default is DDLOCK_WAIT. If you wish
* to override the default and use time when the accelerator is busy (as denoted by
* the DDERR_WASSTILLDRAWING return code) then use DDLOCK_DONOTWAIT.
*)
DDLOCK_DONOTWAIT = $00004000;
{$EXTERNALSYM DDLOCK_DONOTWAIT}
(*
* This indicates volume texture lock with front and back specified.
*)
DDLOCK_HASVOLUMETEXTUREBOXRECT = $00008000;
{$EXTERNALSYM DDLOCK_HASVOLUMETEXTUREBOXRECT}
(*
* This indicates that the driver should not update dirty rect information for this lock.
*)
DDLOCK_NODIRTYUPDATE = $00010000;
{$EXTERNALSYM DDLOCK_NODIRTYUPDATE}
(****************************************************************************
*
* 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 = $00000001;
{$EXTERNALSYM DDBLTFX_ARITHSTRETCHY}
(*
* Do this blt mirroring the surface left to right. Spin the
* surface around its y-axis.
*)
DDBLTFX_MIRRORLEFTRIGHT = $00000002;
{$EXTERNALSYM DDBLTFX_MIRRORLEFTRIGHT}
(*
* Do this blt mirroring the surface up and down. Spin the surface
* around its x-axis.
*)
DDBLTFX_MIRRORUPDOWN = $00000004;
{$EXTERNALSYM DDBLTFX_MIRRORUPDOWN}
(*
* Schedule this blt to avoid tearing.
*)
DDBLTFX_NOTEARING = $00000008;
{$EXTERNALSYM DDBLTFX_NOTEARING}
(*
* Do this blt rotating the surface one hundred and eighty degrees.
*)
DDBLTFX_ROTATE180 = $00000010;
{$EXTERNALSYM DDBLTFX_ROTATE180}
(*
* Do this blt rotating the surface two hundred and seventy degrees.
*)
DDBLTFX_ROTATE270 = $00000020;
{$EXTERNALSYM DDBLTFX_ROTATE270}
(*
* Do this blt rotating the surface ninety degrees.
*)
DDBLTFX_ROTATE90 = $00000040;
{$EXTERNALSYM DDBLTFX_ROTATE90}
(*
* Do this z blt using dwZBufferLow and dwZBufferHigh as range values
* specified to limit the bits copied from the source surface.
*)
DDBLTFX_ZBUFFERRANGE = $00000080;
{$EXTERNALSYM DDBLTFX_ZBUFFERRANGE}
(*
* Do this z blt adding the dwZBufferBaseDest to each of the sources z values
* before comparing it with the desting z values.
*)
DDBLTFX_ZBUFFERBASEDEST = $00000100;
{$EXTERNALSYM DDBLTFX_ZBUFFERBASEDEST}
(****************************************************************************
*
* DIRECTDRAWSURFACE OVERLAY FX FLAGS
*
****************************************************************************)
(*
* If stretching, use arithmetic stretching along the Y axis for this overlay.
*)
DDOVERFX_ARITHSTRETCHY = $00000001;
{$EXTERNALSYM DDOVERFX_ARITHSTRETCHY}
(*
* Mirror the overlay across the vertical axis
*)
DDOVERFX_MIRRORLEFTRIGHT = $00000002;
{$EXTERNALSYM DDOVERFX_MIRRORLEFTRIGHT}
(*
* Mirror the overlay across the horizontal axis
*)
DDOVERFX_MIRRORUPDOWN = $00000004;
{$EXTERNALSYM DDOVERFX_MIRRORUPDOWN}
(*
* Deinterlace the overlay, if possible
*)
DDOVERFX_DEINTERLACE = $00000008;
{$EXTERNALSYM DDOVERFX_DEINTERLACE}
(****************************************************************************
*
* DIRECTDRAW WAITFORVERTICALBLANK FLAGS
*
****************************************************************************)
(*
* return when the vertical blank interval begins
*)
DDWAITVB_BLOCKBEGIN = $00000001;
{$EXTERNALSYM DDWAITVB_BLOCKBEGIN}
(*
* set up an event to trigger when the vertical blank begins
*)
DDWAITVB_BLOCKBEGINEVENT = $00000002;
{$EXTERNALSYM DDWAITVB_BLOCKBEGINEVENT}
(*
* return when the vertical blank interval ends and display begins
*)
DDWAITVB_BLOCKEND = $00000004;
{$EXTERNALSYM DDWAITVB_BLOCKEND}
(****************************************************************************
*
* DIRECTDRAW GETFLIPSTATUS FLAGS
*
****************************************************************************)
(*
* is it OK to flip now?
*)
DDGFS_CANFLIP = $00000001;
{$EXTERNALSYM DDGFS_CANFLIP}
(*
* is the last flip finished?
*)
DDGFS_ISFLIPDONE = $00000002;
{$EXTERNALSYM DDGFS_ISFLIPDONE}
(****************************************************************************
*
* DIRECTDRAW GETBLTSTATUS FLAGS
*
****************************************************************************)
(*
* is it OK to blt now?
*)
DDGBS_CANBLT = $00000001;
{$EXTERNALSYM DDGBS_CANBLT}
(*
* is the blt to the surface finished?
*)
DDGBS_ISBLTDONE = $00000002;
{$EXTERNALSYM DDGBS_ISBLTDONE}
(****************************************************************************
*
* DIRECTDRAW ENUMOVERLAYZORDER FLAGS
*
****************************************************************************)
(*
* Enumerate overlays back to front.