mmddraw.pas

一套及时通讯的原码

    //
    // Supports Z Ordering of overlays.
    //
    DDCAPS_ZOVERLAYS                    = $00200000;

    //
    // Supports color key
    //
    DDCAPS_COLORKEY                     = $00400000;

    //
    // Supports alpha surfaces
    //
    DDCAPS_ALPHA                        = $00800000;

    //
    // colorkey is hardware assisted(DDCAPS_COLORKEY will also be set)
    //
    DDCAPS_COLORKEYHWASSIST             = $01000000;

    //
    // no hardware support at all
    //
    DDCAPS_NOHARDWARE                   = $02000000;

    //
    // Display hardware is capable of color fill with bltter
    //
    DDCAPS_BLTCOLORFILL                 = $04000000;

    //
    // Display hardware is bank switched, and potentially very slow at
    // random access to VRAM.
    //
    DDCAPS_BANKSWITCHED                 = $08000000;

    //
    // Display hardware is capable of depth filling Z-buffers with bltter
    //
    DDCAPS_BLTDEPTHFILL                 = $10000000;

    //
    // Display hardware is capable of clipping while bltting.
    //
    DDCAPS_CANCLIP                      = $20000000;

    //
    // Display hardware is capable of clipping while stretch bltting.
    //
    DDCAPS_CANCLIPSTRETCHED             = $40000000;

    //
    // Display hardware is capable of bltting to or from system memory
    //
    DDCAPS_CANBLTSYSMEM                 = $80000000;

{-- More driver capability flags (dwCaps2) -----------------------------------}

    //
    // Display hardware is certified
    //
    DDCAPS2_CERTIFIED                   = $00000001;

    //
    // Driver cannot interleave 2D operations (lock and blt) to surfaces with
    // Direct3D rendering operations between calls to BeginScene() and EndScene()
    //
    DDCAPS2_NO2DDURING3DSCENE           = $00000002;

{-- DirectDraw FX ALPHA capability flags -------------------------------------}

    //
    // Supports alpha blending around the edge of a source color keyed surface.
    // For Blt.
    //
    DDFXALPHACAPS_BLTALPHAEDGEBLEND             = $00000001;

    //
    // 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;

    //
    // 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;

    //
    // 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;

    //
    // 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;

    //
    // Supports alpha blending around the edge of a source color keyed surface.
    // For Overlays.
    //
    DDFXALPHACAPS_OVERLAYALPHAEDGEBLEND         = $00000020;

    //
    // 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;

    //
    // 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;

    //
    // 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;

    //
    // 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;

{-- 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;

    //
    // 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;

    //
    // Supports mirroring left to right in blt.
    //
    DDFXCAPS_BLTMIRRORLEFTRIGHT                 = $00000040;

    //
    // Supports mirroring top to bottom in blt.
    //
    DDFXCAPS_BLTMIRRORUPDOWN                    = $00000080;

    //
    // Supports arbitrary rotation for blts.
    //
    DDFXCAPS_BLTROTATION                        = $00000100;

    //
    // Supports 90 degree rotations for blts.
    //
    DDFXCAPS_BLTROTATION90                      = $00000200;

    //
    // DirectDraw supports arbitrary shrinking of a surface along the
    // x axis (horizontal direction) for blts.
    //
    DDFXCAPS_BLTSHRINKX                         = $00000400;

    //
    // DirectDraw supports integer shrinking (1x,2x,) of a surface
    // along the x axis (horizontal direction) for blts.
    //
    DDFXCAPS_BLTSHRINKXN                        = $00000800;

    //
    // DirectDraw supports arbitrary shrinking of a surface along the
    // y axis (horizontal direction) for blts.
    //
    DDFXCAPS_BLTSHRINKY                         = $00001000;

    //
    // DirectDraw supports integer shrinking (1x,2x,) of a surface
    // along the y axis (vertical direction) for blts.
    //
    DDFXCAPS_BLTSHRINKYN                        = $00002000;

    //
    // DirectDraw supports arbitrary stretching of a surface along the
    // x axis (horizontal direction) for blts.
    //
    DDFXCAPS_BLTSTRETCHX                        = $00004000;

    //
    // DirectDraw supports integer stretching (1x,2x,) of a surface
    // along the x axis (horizontal direction) for blts.
    //
    DDFXCAPS_BLTSTRETCHXN                       = $00008000;

    //
    // DirectDraw supports arbitrary stretching of a surface along the
    // y axis (horizontal direction) for blts.
    //
    DDFXCAPS_BLTSTRETCHY                        = $00010000;

    //
    // DirectDraw supports integer stretching (1x,2x,) of a surface
    // along the y axis (vertical direction) for blts.
    //
    DDFXCAPS_BLTSTRETCHYN                       = $00020000;

    //
    // Uses arithmetic operations to stretch and shrink surfaces during
    // overlay rather than pixel doubling techniques.  Along the Y axis
    // for overlays.
    //
    DDFXCAPS_OVERLAYARITHSTRETCHY               = $00040000;

    //
    // 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;

    //
    // DirectDraw supports arbitrary shrinking of a surface along the
    // x axis (horizontal direction) for overlays.
    //
    DDFXCAPS_OVERLAYSHRINKX                     = $00080000;

    //
    // DirectDraw supports integer shrinking (1x,2x,) of a surface
    // along the x axis (horizontal direction) for overlays.
    //
    DDFXCAPS_OVERLAYSHRINKXN                    = $00100000;

    //
    // DirectDraw supports arbitrary shrinking of a surface along the
    // y axis (horizontal direction) for overlays.
    //
    DDFXCAPS_OVERLAYSHRINKY                     = $00200000;

    //
    // DirectDraw supports integer shrinking (1x,2x,) of a surface
    // along the y axis (vertical direction) for overlays.
    //
    DDFXCAPS_OVERLAYSHRINKYN                    = $00400000;

    //
    // DirectDraw supports arbitrary stretching of a surface along the
    // x axis (horizontal direction) for overlays.
    //