mmddraw.pas

一套及时通讯的原码

    // precedeces the DDSCAPS_FRONTBUFFER has this capability bit set.
    // The other surfaces are identified as back buffers by the presence
    // of the DDSCAPS_FLIP capability, their attachment order, and the
    // absence of the DDSCAPS_FRONTBUFFER and DDSCAPS_BACKBUFFER
    // capabilities.  The bit is sent to CreateSurface when a standalone
    // back buffer is being created.  This surface could be attached to
    // a front buffer and/or back buffers to form a flipping surface
    // structure after the CreateSurface call.  See AddAttachments for
    // a detailed description of the behaviors in this case.
    //
    DDSCAPS_BACKBUFFER                  = $00000004;

    //
    // Indicates a complex surface structure is being described.  A
    // complex surface structure results in the creation of more than
    // one surface.  The additional surfaces are attached to the root
    // surface.  The complex structure can only be destroyed by
    // destroying the root.
    //
    DDSCAPS_COMPLEX                     = $00000008;

    //
    // Indicates that this surface is a part of a surface flipping structure.
    // When it is passed to CreateSurface the DDSCAPS_FRONTBUFFER and
    // DDSCAP_BACKBUFFER bits are not set.  They are set by CreateSurface
    // on the resulting creations.  The dwBackBufferCount field in the
    // DDSURFACEDESC structure must be set to at least 1 in order for
    // the CreateSurface call to succeed.  The DDSCAPS_COMPLEX capability
    // must always be set with creating multiple surfaces through CreateSurface.
    //
    DDSCAPS_FLIP                        = $00000010;

    //
    // Indicates that this surface is THE front buffer of a surface flipping
    // structure.  It is generally set by CreateSurface when the DDSCAPS_FLIP
    // capability bit is set.
    // If this capability is sent to CreateSurface then a standalone front buffer
    // is created.  This surface will not have the DDSCAPS_FlIP capability.
    // It can be attached to other back buffers to form a flipping structure.
    // See AddAttachments for a detailed description of the behaviors in this
    // case.
    //
    DDSCAPS_FRONTBUFFER                 = $00000020;

    //
    // Indicates that this surface is any offscreen surface that is not an overlay,
    // texture, zbuffer, front buffer, back buffer, or alpha surface.  It is used
    // to identify plain vanilla surfaces.
    //
    DDSCAPS_OFFSCREENPLAIN              = $00000040;

    //
    // Indicates that this surface is an overlay.  It may or may not be directly visible
    // depending on whether or not it is currently being overlayed onto the primary
    // surface.  DDSCAPS_VISIBLE can be used to determine whether or not it is being
    // overlayed at the moment.
    //
    DDSCAPS_OVERLAY                     = $00000080;

    //
    // Indicates that unique DirectDrawPalette objects can be created and
    // attached to this surface.
    //
    DDSCAPS_PALETTE                     = $00000100;

    //
    // Indicates that this surface is the primary surface.  The primary
    // surface represents what the user is seeing at the moment.
    //
    DDSCAPS_PRIMARYSURFACE              = $00000200;

    //
    // Indicates that this surface is the primary surface for the left eye.
    // The primary surface for the left eye represents what the user is seeing
    // at the moment with the users left eye.  When this surface is created the
    // DDSCAPS_PRIMARYSURFACE represents what the user is seeing with the users
    // right eye.
    //
    DDSCAPS_PRIMARYSURFACELEFT          = $00000400;

    //
    // Indicates that this surface memory was allocated in system memory
    // 
    DDSCAPS_SYSTEMMEMORY                = $00000800;

    //
    // Indicates that this surface can be used as a 3D texture.  It does not
    // indicate whether or not the surface is being used for that purpose.
    //
    DDSCAPS_TEXTURE                     = $00001000;

    //
    // Indicates that a surface may be a destination for 3D rendering.  This
    // bit must be set in order to query for a Direct3D Device Interface
    // from this surface.
    // 
    DDSCAPS_3DDEVICE                    = $00002000;

    //
    // Indicates that this surface exists in video memory.
    //
    DDSCAPS_VIDEOMEMORY                 = $00004000;

    //
    // Indicates that changes made to this surface are immediately visible.
    // It is always set for the primary surface and is set for overlays while
    // they are being overlayed and texture maps while they are being textured.
    // 
    DDSCAPS_VISIBLE                     = $00008000;

    //
    // Indicates that only writes are permitted to the surface.  Read accesses
    // from the surface may or may not generate a protection fault, but the
    // results of a read from this surface will not be meaningful.  READ ONLY.
    //
    DDSCAPS_WRITEONLY                   = $00010000;

    //
    // Indicates that this surface is a z buffer. A z buffer does not contain
    // displayable information.  Instead it contains bit depth information that is
    // used to determine which pixels are visible and which are obscured.
    //
    DDSCAPS_ZBUFFER                     = $00020000;

    //
    // Indicates surface will have a DC associated long term
    //
    DDSCAPS_OWNDC                       = $00040000;

    //
    // Indicates surface should be able to receive live video
    //
    DDSCAPS_LIVEVIDEO                   = $00080000;

    //
    // Indicates surface should be able to have a stream decompressed
    // to it by the hardware.
    //
    DDSCAPS_HWCODEC                     = $00100000;

    //
    // Surface is a 320x200 or 320x240 ModeX surface
    // 
    DDSCAPS_MODEX                       = $00200000;

    //
    // Indicates surface is one level of a mip-map. This surface will
    // be attached to other DDSCAPS_MIPMAP surfaces to form the mip-map.
    // This can be done explicitly, by creating a number of surfaces and
    // attaching them with AddAttachedSurface or by implicitly by CreateSurface.
    // If this bit is set then DDSCAPS_TEXTURE must also be set.
    //
    DDSCAPS_MIPMAP                      = $00400000;

    //
    // Indicates that memory for the surface is not allocated until the surface
    // is loaded (via the Direct3D texture load() function).
    //
    DDSCAPS_ALLOCONLOAD                 = $04000000;

{-- Driver capability flags --------------------------------------------------}

    //
    // Display hardware has 3D acceleration.
    //
    DDCAPS_3D                           = $00000001;

    //
    // Indicates that DirectDraw will support only dest rectangles that are aligned
    // on DIRECTDRAWCAPS.dwAlignBoundaryDest boundaries of the surface, respectively.
    // READ ONLY.
    //
    DDCAPS_ALIGNBOUNDARYDEST            = $00000002;

    //
    // Indicates that DirectDraw will support only source rectangles  whose sizes in 
    // BYTEs are DIRECTDRAWCAPS.dwAlignSizeDest multiples, respectively.  READ ONLY.
    //
    DDCAPS_ALIGNSIZEDEST                = $00000004;
    //
    // Indicates that DirectDraw will support only source rectangles that are aligned
    // on DIRECTDRAWCAPS.dwAlignBoundarySrc boundaries of the surface, respectively.
    // READ ONLY.
    //
    DDCAPS_ALIGNBOUNDARYSRC             = $00000008;

    //
    // Indicates that DirectDraw will support only source rectangles  whose sizes in 
    // BYTEs are DIRECTDRAWCAPS.dwAlignSizeSrc multiples, respectively.  READ ONLY.
    //
    DDCAPS_ALIGNSIZESRC                 = $00000010;

    //
    // Indicates that DirectDraw will create video memory surfaces that have a stride 
    // alignment equal to DIRECTDRAWCAPS.dwAlignStride.  READ ONLY.
    //
    DDCAPS_ALIGNSTRIDE                  = $00000020;

    //
    // Display hardware is capable of blt operations.
    //
    DDCAPS_BLT                          = $00000040;

    //
    // Display hardware is capable of asynchronous blt operations.
    //
    DDCAPS_BLTQUEUE                     = $00000080;

    //
    // Display hardware is capable of color space conversions during the blt operation.
    //
    DDCAPS_BLTFOURCC                    = $00000100;

    //
    // Display hardware is capable of stretching during blt operations.
    //
    DDCAPS_BLTSTRETCH                   = $00000200;

    //
    // Display hardware is shared with GDI.
    //
    DDCAPS_GDI                          = $00000400;

    //
    // Display hardware can overlay.
    //
    DDCAPS_OVERLAY                      = $00000800;

    //
    // Set if display hardware supports overlays but can not clip them.
    //
    DDCAPS_OVERLAYCANTCLIP              = $00001000;

    //
    // Indicates that overlay hardware is capable of color space conversions during
    // the overlay operation.
    //
    DDCAPS_OVERLAYFOURCC                = $00002000;

    //
    // Indicates that stretching can be done by the overlay hardware.
    //
    DDCAPS_OVERLAYSTRETCH               = $00004000;

    //
    // Indicates that unique DirectDrawPalettes can be created for DirectDrawSurfaces
    // other than the primary surface.
    //
    DDCAPS_PALETTE                      = $00008000;

    //
    // Indicates that palette changes can be syncd with the veritcal refresh.
    //
    DDCAPS_PALETTEVSYNC                 = $00010000;

    //
    // Display hardware can return the current scan line.
    //
    DDCAPS_READSCANLINE                 = $00020000;

    //
    // Display hardware has stereo vision capabilities.  DDSCAPS_PRIMARYSURFACELEFT
    // can be created.
    //
    DDCAPS_STEREOVIEW                   = $00040000;

    //
    // Display hardware is capable of generating a vertical blank interrupt.
    //
    DDCAPS_VBI                          = $00080000;

    //
    // Supports the use of z buffers with blt operations.
    //
    DDCAPS_ZBLTS                        = $00100000;