~swag/armagetronad/0.2.9-sty+ct+ap-fork

« back to all changes in this revision

Viewing changes to win32/directx/include/ddraw.h

  • Committer: SwagTron
  • Date: 2019-03-03 20:57:16 UTC
  • Revision ID: swagtron-20190303205716-nk32wtrusb3tum54
As far as I am aware, compiling 2.9 sty+ct+ap was incredibly difficult and impossible without using older versions merged with the latest revision (thanks to Nelg's help). Created a proper win32 folder, a readme file, and made it simple to compile for windows.

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
/*==========================================================================;
 
2
 *
 
3
 *  Copyright (C) 1994-1997 Microsoft Corporation.  All Rights Reserved.
 
4
 *
 
5
 *  File:       ddraw.h
 
6
 *  Content:    DirectDraw include file
 
7
 *
 
8
 ***************************************************************************/
 
9
 
 
10
#ifndef __DDRAW_INCLUDED__
 
11
#define __DDRAW_INCLUDED__
 
12
 
 
13
//Disable the nameless union warning when building internally
 
14
#undef ENABLE_NAMELESS_UNION_PRAGMA
 
15
#ifdef DIRECTX_REDIST
 
16
#define ENABLE_NAMELESS_UNION_PRAGMA
 
17
#endif
 
18
 
 
19
#ifdef ENABLE_NAMELESS_UNION_PRAGMA
 
20
#pragma warning(disable:4201)
 
21
#endif
 
22
 
 
23
/*
 
24
 * If you wish an application built against the newest version of DirectDraw
 
25
 * to run against an older DirectDraw run time then define DIRECTDRAW_VERSION
 
26
 * to be the earlies version of DirectDraw you wish to run against. For,
 
27
 * example if you wish an application to run against a DX 3 runtime define
 
28
 * DIRECTDRAW_VERSION to be 0x0300.
 
29
 */
 
30
#ifndef   DIRECTDRAW_VERSION
 
31
#define   DIRECTDRAW_VERSION 0x0700
 
32
#endif /* DIRECTDRAW_VERSION */
 
33
 
 
34
#if defined( _WIN32 )  && !defined( _NO_COM )
 
35
#define COM_NO_WINDOWS_H
 
36
#include <objbase.h>
 
37
#else
 
38
#define IUnknown            void
 
39
#if !defined( NT_BUILD_ENVIRONMENT ) && !defined(WINNT)
 
40
        #define CO_E_NOTINITIALIZED 0x800401F0L
 
41
#endif
 
42
#endif
 
43
 
 
44
#define _FACDD  0x876
 
45
#define MAKE_DDHRESULT( code )  MAKE_HRESULT( 1, _FACDD, code )
 
46
 
 
47
#ifdef __cplusplus
 
48
extern "C" {
 
49
#endif
 
50
 
 
51
//
 
52
// For compilers that don't support nameless unions, do a
 
53
//
 
54
// #define NONAMELESSUNION
 
55
//
 
56
// before #include <ddraw.h>
 
57
//
 
58
#ifndef DUMMYUNIONNAMEN
 
59
#if defined(__cplusplus) || !defined(NONAMELESSUNION)
 
60
#define DUMMYUNIONNAMEN(n)
 
61
#else
 
62
#define DUMMYUNIONNAMEN(n)      u##n
 
63
#endif
 
64
#endif
 
65
 
 
66
#ifndef MAKEFOURCC
 
67
    #define MAKEFOURCC(ch0, ch1, ch2, ch3)                              \
 
68
                ((DWORD)(BYTE)(ch0) | ((DWORD)(BYTE)(ch1) << 8) |   \
 
69
                ((DWORD)(BYTE)(ch2) << 16) | ((DWORD)(BYTE)(ch3) << 24 ))
 
70
#endif //defined(MAKEFOURCC)
 
71
 
 
72
/*
 
73
 * FOURCC codes for DX compressed-texture pixel formats
 
74
 */
 
75
#define FOURCC_DXT1  (MAKEFOURCC('D','X','T','1'))
 
76
#define FOURCC_DXT2  (MAKEFOURCC('D','X','T','2'))
 
77
#define FOURCC_DXT3  (MAKEFOURCC('D','X','T','3'))
 
78
#define FOURCC_DXT4  (MAKEFOURCC('D','X','T','4'))
 
79
#define FOURCC_DXT5  (MAKEFOURCC('D','X','T','5'))
 
80
 
 
81
/*
 
82
 * GUIDS used by DirectDraw objects
 
83
 */
 
84
#if defined( _WIN32 ) && !defined( _NO_COM )
 
85
 
 
86
DEFINE_GUID( CLSID_DirectDraw,                  0xD7B70EE0,0x4340,0x11CF,0xB0,0x63,0x00,0x20,0xAF,0xC2,0xCD,0x35 );
 
87
DEFINE_GUID( CLSID_DirectDraw7,                 0x3c305196,0x50db,0x11d3,0x9c,0xfe,0x00,0xc0,0x4f,0xd9,0x30,0xc5 );
 
88
DEFINE_GUID( CLSID_DirectDrawClipper,           0x593817A0,0x7DB3,0x11CF,0xA2,0xDE,0x00,0xAA,0x00,0xb9,0x33,0x56 );
 
89
DEFINE_GUID( IID_IDirectDraw,                   0x6C14DB80,0xA733,0x11CE,0xA5,0x21,0x00,0x20,0xAF,0x0B,0xE5,0x60 );
 
90
DEFINE_GUID( IID_IDirectDraw2,                  0xB3A6F3E0,0x2B43,0x11CF,0xA2,0xDE,0x00,0xAA,0x00,0xB9,0x33,0x56 );
 
91
DEFINE_GUID( IID_IDirectDraw4,                  0x9c59509a,0x39bd,0x11d1,0x8c,0x4a,0x00,0xc0,0x4f,0xd9,0x30,0xc5 );
 
92
DEFINE_GUID( IID_IDirectDraw7,                  0x15e65ec0,0x3b9c,0x11d2,0xb9,0x2f,0x00,0x60,0x97,0x97,0xea,0x5b );
 
93
DEFINE_GUID( IID_IDirectDrawSurface,            0x6C14DB81,0xA733,0x11CE,0xA5,0x21,0x00,0x20,0xAF,0x0B,0xE5,0x60 );
 
94
DEFINE_GUID( IID_IDirectDrawSurface2,           0x57805885,0x6eec,0x11cf,0x94,0x41,0xa8,0x23,0x03,0xc1,0x0e,0x27 );
 
95
DEFINE_GUID( IID_IDirectDrawSurface3,           0xDA044E00,0x69B2,0x11D0,0xA1,0xD5,0x00,0xAA,0x00,0xB8,0xDF,0xBB );
 
96
DEFINE_GUID( IID_IDirectDrawSurface4,           0x0B2B8630,0xAD35,0x11D0,0x8E,0xA6,0x00,0x60,0x97,0x97,0xEA,0x5B );
 
97
DEFINE_GUID( IID_IDirectDrawSurface7,           0x06675a80,0x3b9b,0x11d2,0xb9,0x2f,0x00,0x60,0x97,0x97,0xea,0x5b );
 
98
DEFINE_GUID( IID_IDirectDrawPalette,            0x6C14DB84,0xA733,0x11CE,0xA5,0x21,0x00,0x20,0xAF,0x0B,0xE5,0x60 );
 
99
DEFINE_GUID( IID_IDirectDrawClipper,            0x6C14DB85,0xA733,0x11CE,0xA5,0x21,0x00,0x20,0xAF,0x0B,0xE5,0x60 );
 
100
DEFINE_GUID( IID_IDirectDrawColorControl,       0x4B9F0EE0,0x0D7E,0x11D0,0x9B,0x06,0x00,0xA0,0xC9,0x03,0xA3,0xB8 );
 
101
DEFINE_GUID( IID_IDirectDrawGammaControl,       0x69C11C3E,0xB46B,0x11D1,0xAD,0x7A,0x00,0xC0,0x4F,0xC2,0x9B,0x4E );
 
102
 
 
103
#endif
 
104
 
 
105
/*============================================================================
 
106
 *
 
107
 * DirectDraw Structures
 
108
 *
 
109
 * Various structures used to invoke DirectDraw.
 
110
 *
 
111
 *==========================================================================*/
 
112
 
 
113
struct IDirectDraw;
 
114
struct IDirectDrawSurface;
 
115
struct IDirectDrawPalette;
 
116
struct IDirectDrawClipper;
 
117
 
 
118
typedef struct IDirectDraw              FAR *LPDIRECTDRAW;
 
119
typedef struct IDirectDraw2             FAR *LPDIRECTDRAW2;
 
120
typedef struct IDirectDraw4             FAR *LPDIRECTDRAW4;
 
121
typedef struct IDirectDraw7             FAR *LPDIRECTDRAW7;
 
122
typedef struct IDirectDrawSurface       FAR *LPDIRECTDRAWSURFACE;
 
123
typedef struct IDirectDrawSurface2      FAR *LPDIRECTDRAWSURFACE2;
 
124
typedef struct IDirectDrawSurface3      FAR *LPDIRECTDRAWSURFACE3;
 
125
typedef struct IDirectDrawSurface4      FAR *LPDIRECTDRAWSURFACE4;
 
126
typedef struct IDirectDrawSurface7      FAR *LPDIRECTDRAWSURFACE7;
 
127
typedef struct IDirectDrawPalette               FAR *LPDIRECTDRAWPALETTE;
 
128
typedef struct IDirectDrawClipper               FAR *LPDIRECTDRAWCLIPPER;
 
129
typedef struct IDirectDrawColorControl          FAR *LPDIRECTDRAWCOLORCONTROL;
 
130
typedef struct IDirectDrawGammaControl          FAR *LPDIRECTDRAWGAMMACONTROL;
 
131
 
 
132
typedef struct _DDFXROP                 FAR *LPDDFXROP;
 
133
typedef struct _DDSURFACEDESC           FAR *LPDDSURFACEDESC;
 
134
typedef struct _DDSURFACEDESC2          FAR *LPDDSURFACEDESC2;
 
135
typedef struct _DDCOLORCONTROL          FAR *LPDDCOLORCONTROL;
 
136
 
 
137
/*
 
138
 * API's
 
139
 */
 
140
#if (defined (WIN32) || defined( _WIN32 ) ) && !defined( _NO_COM )
 
141
//#if defined( _WIN32 ) && !defined( _NO_ENUM )
 
142
    typedef BOOL (FAR PASCAL * LPDDENUMCALLBACKA)(GUID FAR *, LPSTR, LPSTR, LPVOID);
 
143
    typedef BOOL (FAR PASCAL * LPDDENUMCALLBACKW)(GUID FAR *, LPWSTR, LPWSTR, LPVOID);
 
144
    extern HRESULT WINAPI DirectDrawEnumerateW( LPDDENUMCALLBACKW lpCallback, LPVOID lpContext );
 
145
    extern HRESULT WINAPI DirectDrawEnumerateA( LPDDENUMCALLBACKA lpCallback, LPVOID lpContext );
 
146
    /*
 
147
     * Protect against old SDKs
 
148
     */
 
149
    #if !defined(HMONITOR_DECLARED) && (WINVER < 0x0500)
 
150
        #define HMONITOR_DECLARED
 
151
        DECLARE_HANDLE(HMONITOR);
 
152
    #endif
 
153
    typedef BOOL (FAR PASCAL * LPDDENUMCALLBACKEXA)(GUID FAR *, LPSTR, LPSTR, LPVOID, HMONITOR);
 
154
    typedef BOOL (FAR PASCAL * LPDDENUMCALLBACKEXW)(GUID FAR *, LPWSTR, LPWSTR, LPVOID, HMONITOR);
 
155
    extern HRESULT WINAPI DirectDrawEnumerateExW( LPDDENUMCALLBACKEXW lpCallback, LPVOID lpContext, DWORD dwFlags);
 
156
    extern HRESULT WINAPI DirectDrawEnumerateExA( LPDDENUMCALLBACKEXA lpCallback, LPVOID lpContext, DWORD dwFlags);
 
157
    typedef HRESULT (WINAPI * LPDIRECTDRAWENUMERATEEXA)( LPDDENUMCALLBACKEXA lpCallback, LPVOID lpContext, DWORD dwFlags);
 
158
    typedef HRESULT (WINAPI * LPDIRECTDRAWENUMERATEEXW)( LPDDENUMCALLBACKEXW lpCallback, LPVOID lpContext, DWORD dwFlags);
 
159
 
 
160
    #ifdef UNICODE
 
161
        typedef LPDDENUMCALLBACKW           LPDDENUMCALLBACK;
 
162
        #define DirectDrawEnumerate         DirectDrawEnumerateW
 
163
        typedef LPDDENUMCALLBACKEXW         LPDDENUMCALLBACKEX;
 
164
        typedef LPDIRECTDRAWENUMERATEEXW        LPDIRECTDRAWENUMERATEEX;
 
165
        #define DirectDrawEnumerateEx       DirectDrawEnumerateExW
 
166
    #else
 
167
        typedef LPDDENUMCALLBACKA           LPDDENUMCALLBACK;
 
168
        #define DirectDrawEnumerate         DirectDrawEnumerateA
 
169
        typedef LPDDENUMCALLBACKEXA         LPDDENUMCALLBACKEX;
 
170
        typedef LPDIRECTDRAWENUMERATEEXA        LPDIRECTDRAWENUMERATEEX;
 
171
        #define DirectDrawEnumerateEx       DirectDrawEnumerateExA
 
172
    #endif
 
173
    extern HRESULT WINAPI DirectDrawCreate( GUID FAR *lpGUID, LPDIRECTDRAW FAR *lplpDD, IUnknown FAR *pUnkOuter );
 
174
    extern HRESULT WINAPI DirectDrawCreateEx( GUID FAR * lpGuid, LPVOID  *lplpDD, REFIID  iid,IUnknown FAR *pUnkOuter );
 
175
    extern HRESULT WINAPI DirectDrawCreateClipper( DWORD dwFlags, LPDIRECTDRAWCLIPPER FAR *lplpDDClipper, IUnknown FAR *pUnkOuter );
 
176
#endif
 
177
/*
 
178
 * Flags for DirectDrawEnumerateEx
 
179
 * DirectDrawEnumerateEx supercedes DirectDrawEnumerate. You must use GetProcAddress to
 
180
 * obtain a function pointer (of type LPDIRECTDRAWENUMERATEEX) to DirectDrawEnumerateEx.
 
181
 * By default, only the primary display device is enumerated.
 
182
 * DirectDrawEnumerate is equivalent to DirectDrawEnumerate(,,DDENUM_NONDISPLAYDEVICES)
 
183
 */
 
184
 
 
185
/*
 
186
 * This flag causes enumeration of any GDI display devices which are part of
 
187
 * the Windows Desktop
 
188
 */
 
189
#define DDENUM_ATTACHEDSECONDARYDEVICES     0x00000001L
 
190
 
 
191
/*
 
192
 * This flag causes enumeration of any GDI display devices which are not
 
193
 * part of the Windows Desktop
 
194
 */
 
195
#define DDENUM_DETACHEDSECONDARYDEVICES     0x00000002L
 
196
 
 
197
/*
 
198
 * This flag causes enumeration of non-display devices
 
199
 */
 
200
#define DDENUM_NONDISPLAYDEVICES            0x00000004L
 
201
 
 
202
 
 
203
#define REGSTR_KEY_DDHW_DESCRIPTION     "Description"
 
204
#define REGSTR_KEY_DDHW_DRIVERNAME      "DriverName"
 
205
#define REGSTR_PATH_DDHW                "Hardware\\DirectDrawDrivers"
 
206
 
 
207
#define DDCREATE_HARDWAREONLY           0x00000001l
 
208
#define DDCREATE_EMULATIONONLY          0x00000002l
 
209
 
 
210
#if defined(WINNT) || !defined(WIN32)
 
211
typedef long HRESULT;
 
212
#endif
 
213
 
 
214
//#ifndef WINNT
 
215
typedef HRESULT (FAR PASCAL * LPDDENUMMODESCALLBACK)(LPDDSURFACEDESC, LPVOID);
 
216
typedef HRESULT (FAR PASCAL * LPDDENUMMODESCALLBACK2)(LPDDSURFACEDESC2, LPVOID);
 
217
typedef HRESULT (FAR PASCAL * LPDDENUMSURFACESCALLBACK)(LPDIRECTDRAWSURFACE, LPDDSURFACEDESC, LPVOID);
 
218
typedef HRESULT (FAR PASCAL * LPDDENUMSURFACESCALLBACK2)(LPDIRECTDRAWSURFACE4, LPDDSURFACEDESC2, LPVOID);
 
219
typedef HRESULT (FAR PASCAL * LPDDENUMSURFACESCALLBACK7)(LPDIRECTDRAWSURFACE7, LPDDSURFACEDESC2, LPVOID);
 
220
//#endif
 
221
 
 
222
/*
 
223
 * Generic pixel format with 8-bit RGB and alpha components
 
224
 */
 
225
typedef struct _DDARGB
 
226
{
 
227
    BYTE blue;
 
228
    BYTE green;
 
229
    BYTE red;
 
230
    BYTE alpha;
 
231
} DDARGB;
 
232
 
 
233
typedef DDARGB FAR *LPDDARGB;
 
234
 
 
235
/*
 
236
 * This version of the structure remains for backwards source compatibility.
 
237
 * The DDARGB structure is the one that should be used for all DirectDraw APIs.
 
238
 */
 
239
typedef struct _DDRGBA
 
240
{
 
241
    BYTE red;
 
242
    BYTE green;
 
243
    BYTE blue;
 
244
    BYTE alpha;
 
245
} DDRGBA;
 
246
 
 
247
typedef DDRGBA FAR *LPDDRGBA;
 
248
 
 
249
 
 
250
/*
 
251
 * DDCOLORKEY
 
252
 */
 
253
typedef struct _DDCOLORKEY
 
254
{
 
255
    DWORD       dwColorSpaceLowValue;   // low boundary of color space that is to
 
256
                                        // be treated as Color Key, inclusive
 
257
    DWORD       dwColorSpaceHighValue;  // high boundary of color space that is
 
258
                                        // to be treated as Color Key, inclusive
 
259
} DDCOLORKEY;
 
260
 
 
261
typedef DDCOLORKEY FAR* LPDDCOLORKEY;
 
262
 
 
263
/*
 
264
 * DDBLTFX
 
265
 * Used to pass override information to the DIRECTDRAWSURFACE callback Blt.
 
266
 */
 
267
typedef struct _DDBLTFX
 
268
{
 
269
    DWORD       dwSize;                         // size of structure
 
270
    DWORD       dwDDFX;                         // FX operations
 
271
    DWORD       dwROP;                          // Win32 raster operations
 
272
    DWORD       dwDDROP;                        // Raster operations new for DirectDraw
 
273
    DWORD       dwRotationAngle;                // Rotation angle for blt
 
274
    DWORD       dwZBufferOpCode;                // ZBuffer compares
 
275
    DWORD       dwZBufferLow;                   // Low limit of Z buffer
 
276
    DWORD       dwZBufferHigh;                  // High limit of Z buffer
 
277
    DWORD       dwZBufferBaseDest;              // Destination base value
 
278
    DWORD       dwZDestConstBitDepth;           // Bit depth used to specify Z constant for destination
 
279
    union
 
280
    {
 
281
        DWORD   dwZDestConst;                   // Constant to use as Z buffer for dest
 
282
        LPDIRECTDRAWSURFACE lpDDSZBufferDest;   // Surface to use as Z buffer for dest
 
283
    } DUMMYUNIONNAMEN(1);
 
284
    DWORD       dwZSrcConstBitDepth;            // Bit depth used to specify Z constant for source
 
285
    union
 
286
    {
 
287
        DWORD   dwZSrcConst;                    // Constant to use as Z buffer for src
 
288
        LPDIRECTDRAWSURFACE lpDDSZBufferSrc;    // Surface to use as Z buffer for src
 
289
    } DUMMYUNIONNAMEN(2);
 
290
    DWORD       dwAlphaEdgeBlendBitDepth;       // Bit depth used to specify constant for alpha edge blend
 
291
    DWORD       dwAlphaEdgeBlend;               // Alpha for edge blending
 
292
    DWORD       dwReserved;
 
293
    DWORD       dwAlphaDestConstBitDepth;       // Bit depth used to specify alpha constant for destination
 
294
    union
 
295
    {
 
296
        DWORD   dwAlphaDestConst;               // Constant to use as Alpha Channel
 
297
        LPDIRECTDRAWSURFACE lpDDSAlphaDest;     // Surface to use as Alpha Channel
 
298
    } DUMMYUNIONNAMEN(3);
 
299
    DWORD       dwAlphaSrcConstBitDepth;        // Bit depth used to specify alpha constant for source
 
300
    union
 
301
    {
 
302
        DWORD   dwAlphaSrcConst;                // Constant to use as Alpha Channel
 
303
        LPDIRECTDRAWSURFACE lpDDSAlphaSrc;      // Surface to use as Alpha Channel
 
304
    } DUMMYUNIONNAMEN(4);
 
305
    union
 
306
    {
 
307
        DWORD   dwFillColor;                    // color in RGB or Palettized
 
308
        DWORD   dwFillDepth;                    // depth value for z-buffer
 
309
        DWORD   dwFillPixel;                    // pixel value for RGBA or RGBZ
 
310
        LPDIRECTDRAWSURFACE lpDDSPattern;       // Surface to use as pattern
 
311
    } DUMMYUNIONNAMEN(5);
 
312
    DDCOLORKEY  ddckDestColorkey;               // DestColorkey override
 
313
    DDCOLORKEY  ddckSrcColorkey;                // SrcColorkey override
 
314
} DDBLTFX;
 
315
 
 
316
typedef DDBLTFX FAR* LPDDBLTFX;
 
317
 
 
318
 
 
319
 
 
320
/*
 
321
 * DDSCAPS
 
322
 */
 
323
typedef struct _DDSCAPS
 
324
{
 
325
    DWORD       dwCaps;         // capabilities of surface wanted
 
326
} DDSCAPS;
 
327
 
 
328
typedef DDSCAPS FAR* LPDDSCAPS;
 
329
 
 
330
 
 
331
/*
 
332
 * DDOSCAPS
 
333
 */
 
334
typedef struct _DDOSCAPS
 
335
{
 
336
    DWORD       dwCaps;         // capabilities of surface wanted
 
337
} DDOSCAPS;
 
338
 
 
339
typedef DDOSCAPS FAR* LPDDOSCAPS;
 
340
 
 
341
/*
 
342
 * This structure is used internally by DirectDraw.
 
343
 */
 
344
typedef struct _DDSCAPSEX
 
345
{
 
346
    DWORD       dwCaps2;
 
347
    DWORD       dwCaps3;
 
348
    union
 
349
    {
 
350
        DWORD       dwCaps4;
 
351
        DWORD       dwVolumeDepth;
 
352
    } DUMMYUNIONNAMEN(1);
 
353
} DDSCAPSEX, FAR * LPDDSCAPSEX;
 
354
 
 
355
/*
 
356
 * DDSCAPS2
 
357
 */
 
358
typedef struct _DDSCAPS2
 
359
{
 
360
    DWORD       dwCaps;         // capabilities of surface wanted
 
361
    DWORD       dwCaps2;
 
362
    DWORD       dwCaps3;
 
363
    union
 
364
    {
 
365
        DWORD       dwCaps4;
 
366
        DWORD       dwVolumeDepth;
 
367
    } DUMMYUNIONNAMEN(1);
 
368
} DDSCAPS2;
 
369
 
 
370
typedef DDSCAPS2 FAR* LPDDSCAPS2;
 
371
 
 
372
/*
 
373
 * DDCAPS
 
374
 */
 
375
#define DD_ROP_SPACE            (256/32)        // space required to store ROP array
 
376
/*
 
377
 * NOTE: Our choosen structure number scheme is to append a single digit to
 
378
 * the end of the structure giving the version that structure is associated
 
379
 * with.
 
380
 */
 
381
 
 
382
/*
 
383
 * This structure represents the DDCAPS structure released in DirectDraw 1.0.  It is used internally
 
384
 * by DirectDraw to interpret caps passed into ddraw by drivers written prior to the release of DirectDraw 2.0.
 
385
 * New applications should use the DDCAPS structure defined below.
 
386
 */
 
387
typedef struct _DDCAPS_DX1
 
388
{
 
389
    DWORD       dwSize;                 // size of the DDDRIVERCAPS structure
 
390
    DWORD       dwCaps;                 // driver specific capabilities
 
391
    DWORD       dwCaps2;                // more driver specific capabilites
 
392
    DWORD       dwCKeyCaps;             // color key capabilities of the surface
 
393
    DWORD       dwFXCaps;               // driver specific stretching and effects capabilites
 
394
    DWORD       dwFXAlphaCaps;          // alpha driver specific capabilities
 
395
    DWORD       dwPalCaps;              // palette capabilities
 
396
    DWORD       dwSVCaps;               // stereo vision capabilities
 
397
    DWORD       dwAlphaBltConstBitDepths;       // DDBD_2,4,8
 
398
    DWORD       dwAlphaBltPixelBitDepths;       // DDBD_1,2,4,8
 
399
    DWORD       dwAlphaBltSurfaceBitDepths;     // DDBD_1,2,4,8
 
400
    DWORD       dwAlphaOverlayConstBitDepths;   // DDBD_2,4,8
 
401
    DWORD       dwAlphaOverlayPixelBitDepths;   // DDBD_1,2,4,8
 
402
    DWORD       dwAlphaOverlaySurfaceBitDepths; // DDBD_1,2,4,8
 
403
    DWORD       dwZBufferBitDepths;             // DDBD_8,16,24,32
 
404
    DWORD       dwVidMemTotal;          // total amount of video memory
 
405
    DWORD       dwVidMemFree;           // amount of free video memory
 
406
    DWORD       dwMaxVisibleOverlays;   // maximum number of visible overlays
 
407
    DWORD       dwCurrVisibleOverlays;  // current number of visible overlays
 
408
    DWORD       dwNumFourCCCodes;       // number of four cc codes
 
409
    DWORD       dwAlignBoundarySrc;     // source rectangle alignment
 
410
    DWORD       dwAlignSizeSrc;         // source rectangle byte size
 
411
    DWORD       dwAlignBoundaryDest;    // dest rectangle alignment
 
412
    DWORD       dwAlignSizeDest;        // dest rectangle byte size
 
413
    DWORD       dwAlignStrideAlign;     // stride alignment
 
414
    DWORD       dwRops[DD_ROP_SPACE];   // ROPS supported
 
415
    DDSCAPS     ddsCaps;                // DDSCAPS structure has all the general capabilities
 
416
    DWORD       dwMinOverlayStretch;    // minimum overlay stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3
 
417
    DWORD       dwMaxOverlayStretch;    // maximum overlay stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3
 
418
    DWORD       dwMinLiveVideoStretch;  // OBSOLETE! This field remains for compatability reasons only
 
419
    DWORD       dwMaxLiveVideoStretch;  // OBSOLETE! This field remains for compatability reasons only
 
420
    DWORD       dwMinHwCodecStretch;    // OBSOLETE! This field remains for compatability reasons only
 
421
    DWORD       dwMaxHwCodecStretch;    // OBSOLETE! This field remains for compatability reasons only
 
422
    DWORD       dwReserved1;            // reserved
 
423
    DWORD       dwReserved2;            // reserved
 
424
    DWORD       dwReserved3;            // reserved
 
425
} DDCAPS_DX1;
 
426
 
 
427
typedef DDCAPS_DX1 FAR* LPDDCAPS_DX1;
 
428
 
 
429
/*
 
430
 * This structure is the DDCAPS structure as it was in version 2 and 3 of Direct X.
 
431
 * It is present for back compatability.
 
432
 */
 
433
typedef struct _DDCAPS_DX3
 
434
{
 
435
    DWORD       dwSize;                 // size of the DDDRIVERCAPS structure
 
436
    DWORD       dwCaps;                 // driver specific capabilities
 
437
    DWORD       dwCaps2;                // more driver specific capabilites
 
438
    DWORD       dwCKeyCaps;             // color key capabilities of the surface
 
439
    DWORD       dwFXCaps;               // driver specific stretching and effects capabilites
 
440
    DWORD       dwFXAlphaCaps;          // alpha driver specific capabilities
 
441
    DWORD       dwPalCaps;              // palette capabilities
 
442
    DWORD       dwSVCaps;               // stereo vision capabilities
 
443
    DWORD       dwAlphaBltConstBitDepths;       // DDBD_2,4,8
 
444
    DWORD       dwAlphaBltPixelBitDepths;       // DDBD_1,2,4,8
 
445
    DWORD       dwAlphaBltSurfaceBitDepths;     // DDBD_1,2,4,8
 
446
    DWORD       dwAlphaOverlayConstBitDepths;   // DDBD_2,4,8
 
447
    DWORD       dwAlphaOverlayPixelBitDepths;   // DDBD_1,2,4,8
 
448
    DWORD       dwAlphaOverlaySurfaceBitDepths; // DDBD_1,2,4,8
 
449
    DWORD       dwZBufferBitDepths;             // DDBD_8,16,24,32
 
450
    DWORD       dwVidMemTotal;          // total amount of video memory
 
451
    DWORD       dwVidMemFree;           // amount of free video memory
 
452
    DWORD       dwMaxVisibleOverlays;   // maximum number of visible overlays
 
453
    DWORD       dwCurrVisibleOverlays;  // current number of visible overlays
 
454
    DWORD       dwNumFourCCCodes;       // number of four cc codes
 
455
    DWORD       dwAlignBoundarySrc;     // source rectangle alignment
 
456
    DWORD       dwAlignSizeSrc;         // source rectangle byte size
 
457
    DWORD       dwAlignBoundaryDest;    // dest rectangle alignment
 
458
    DWORD       dwAlignSizeDest;        // dest rectangle byte size
 
459
    DWORD       dwAlignStrideAlign;     // stride alignment
 
460
    DWORD       dwRops[DD_ROP_SPACE];   // ROPS supported
 
461
    DDSCAPS     ddsCaps;                // DDSCAPS structure has all the general capabilities
 
462
    DWORD       dwMinOverlayStretch;    // minimum overlay stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3
 
463
    DWORD       dwMaxOverlayStretch;    // maximum overlay stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3
 
464
    DWORD       dwMinLiveVideoStretch;  // minimum live video stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3
 
465
    DWORD       dwMaxLiveVideoStretch;  // maximum live video stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3
 
466
    DWORD       dwMinHwCodecStretch;    // minimum hardware codec stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3
 
467
    DWORD       dwMaxHwCodecStretch;    // maximum hardware codec stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3
 
468
    DWORD       dwReserved1;            // reserved
 
469
    DWORD       dwReserved2;            // reserved
 
470
    DWORD       dwReserved3;            // reserved
 
471
    DWORD       dwSVBCaps;              // driver specific capabilities for System->Vmem blts
 
472
    DWORD       dwSVBCKeyCaps;          // driver color key capabilities for System->Vmem blts
 
473
    DWORD       dwSVBFXCaps;            // driver FX capabilities for System->Vmem blts
 
474
    DWORD       dwSVBRops[DD_ROP_SPACE];// ROPS supported for System->Vmem blts
 
475
    DWORD       dwVSBCaps;              // driver specific capabilities for Vmem->System blts
 
476
    DWORD       dwVSBCKeyCaps;          // driver color key capabilities for Vmem->System blts
 
477
    DWORD       dwVSBFXCaps;            // driver FX capabilities for Vmem->System blts
 
478
    DWORD       dwVSBRops[DD_ROP_SPACE];// ROPS supported for Vmem->System blts
 
479
    DWORD       dwSSBCaps;              // driver specific capabilities for System->System blts
 
480
    DWORD       dwSSBCKeyCaps;          // driver color key capabilities for System->System blts
 
481
    DWORD       dwSSBFXCaps;            // driver FX capabilities for System->System blts
 
482
    DWORD       dwSSBRops[DD_ROP_SPACE];// ROPS supported for System->System blts
 
483
    DWORD       dwReserved4;            // reserved
 
484
    DWORD       dwReserved5;            // reserved
 
485
    DWORD       dwReserved6;            // reserved
 
486
} DDCAPS_DX3;
 
487
typedef DDCAPS_DX3 FAR* LPDDCAPS_DX3;
 
488
 
 
489
/*
 
490
 * This structure is the DDCAPS structure as it was in version 5 of Direct X.
 
491
 * It is present for back compatability.
 
492
 */
 
493
typedef struct _DDCAPS_DX5
 
494
{
 
495
/*  0*/ DWORD   dwSize;                 // size of the DDDRIVERCAPS structure
 
496
/*  4*/ DWORD   dwCaps;                 // driver specific capabilities
 
497
/*  8*/ DWORD   dwCaps2;                // more driver specific capabilites
 
498
/*  c*/ DWORD   dwCKeyCaps;             // color key capabilities of the surface
 
499
/* 10*/ DWORD   dwFXCaps;               // driver specific stretching and effects capabilites
 
500
/* 14*/ DWORD   dwFXAlphaCaps;          // alpha driver specific capabilities
 
501
/* 18*/ DWORD   dwPalCaps;              // palette capabilities
 
502
/* 1c*/ DWORD   dwSVCaps;               // stereo vision capabilities
 
503
/* 20*/ DWORD   dwAlphaBltConstBitDepths;       // DDBD_2,4,8
 
504
/* 24*/ DWORD   dwAlphaBltPixelBitDepths;       // DDBD_1,2,4,8
 
505
/* 28*/ DWORD   dwAlphaBltSurfaceBitDepths;     // DDBD_1,2,4,8
 
506
/* 2c*/ DWORD   dwAlphaOverlayConstBitDepths;   // DDBD_2,4,8
 
507
/* 30*/ DWORD   dwAlphaOverlayPixelBitDepths;   // DDBD_1,2,4,8
 
508
/* 34*/ DWORD   dwAlphaOverlaySurfaceBitDepths; // DDBD_1,2,4,8
 
509
/* 38*/ DWORD   dwZBufferBitDepths;             // DDBD_8,16,24,32
 
510
/* 3c*/ DWORD   dwVidMemTotal;          // total amount of video memory
 
511
/* 40*/ DWORD   dwVidMemFree;           // amount of free video memory
 
512
/* 44*/ DWORD   dwMaxVisibleOverlays;   // maximum number of visible overlays
 
513
/* 48*/ DWORD   dwCurrVisibleOverlays;  // current number of visible overlays
 
514
/* 4c*/ DWORD   dwNumFourCCCodes;       // number of four cc codes
 
515
/* 50*/ DWORD   dwAlignBoundarySrc;     // source rectangle alignment
 
516
/* 54*/ DWORD   dwAlignSizeSrc;         // source rectangle byte size
 
517
/* 58*/ DWORD   dwAlignBoundaryDest;    // dest rectangle alignment
 
518
/* 5c*/ DWORD   dwAlignSizeDest;        // dest rectangle byte size
 
519
/* 60*/ DWORD   dwAlignStrideAlign;     // stride alignment
 
520
/* 64*/ DWORD   dwRops[DD_ROP_SPACE];   // ROPS supported
 
521
/* 84*/ DDSCAPS ddsCaps;                // DDSCAPS structure has all the general capabilities
 
522
/* 88*/ DWORD   dwMinOverlayStretch;    // minimum overlay stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3
 
523
/* 8c*/ DWORD   dwMaxOverlayStretch;    // maximum overlay stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3
 
524
/* 90*/ DWORD   dwMinLiveVideoStretch;  // minimum live video stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3
 
525
/* 94*/ DWORD   dwMaxLiveVideoStretch;  // maximum live video stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3
 
526
/* 98*/ DWORD   dwMinHwCodecStretch;    // minimum hardware codec stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3
 
527
/* 9c*/ DWORD   dwMaxHwCodecStretch;    // maximum hardware codec stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3
 
528
/* a0*/ DWORD   dwReserved1;            // reserved
 
529
/* a4*/ DWORD   dwReserved2;            // reserved
 
530
/* a8*/ DWORD   dwReserved3;            // reserved
 
531
/* ac*/ DWORD   dwSVBCaps;              // driver specific capabilities for System->Vmem blts
 
532
/* b0*/ DWORD   dwSVBCKeyCaps;          // driver color key capabilities for System->Vmem blts
 
533
/* b4*/ DWORD   dwSVBFXCaps;            // driver FX capabilities for System->Vmem blts
 
534
/* b8*/ DWORD   dwSVBRops[DD_ROP_SPACE];// ROPS supported for System->Vmem blts
 
535
/* d8*/ DWORD   dwVSBCaps;              // driver specific capabilities for Vmem->System blts
 
536
/* dc*/ DWORD   dwVSBCKeyCaps;          // driver color key capabilities for Vmem->System blts
 
537
/* e0*/ DWORD   dwVSBFXCaps;            // driver FX capabilities for Vmem->System blts
 
538
/* e4*/ DWORD   dwVSBRops[DD_ROP_SPACE];// ROPS supported for Vmem->System blts
 
539
/*104*/ DWORD   dwSSBCaps;              // driver specific capabilities for System->System blts
 
540
/*108*/ DWORD   dwSSBCKeyCaps;          // driver color key capabilities for System->System blts
 
541
/*10c*/ DWORD   dwSSBFXCaps;            // driver FX capabilities for System->System blts
 
542
/*110*/ DWORD   dwSSBRops[DD_ROP_SPACE];// ROPS supported for System->System blts
 
543
// Members added for DX5:
 
544
/*130*/ DWORD   dwMaxVideoPorts;        // maximum number of usable video ports
 
545
/*134*/ DWORD   dwCurrVideoPorts;       // current number of video ports used
 
546
/*138*/ DWORD   dwSVBCaps2;             // more driver specific capabilities for System->Vmem blts
 
547
/*13c*/ DWORD   dwNLVBCaps;               // driver specific capabilities for non-local->local vidmem blts
 
548
/*140*/ DWORD   dwNLVBCaps2;              // more driver specific capabilities non-local->local vidmem blts
 
549
/*144*/ DWORD   dwNLVBCKeyCaps;           // driver color key capabilities for non-local->local vidmem blts
 
550
/*148*/ DWORD   dwNLVBFXCaps;             // driver FX capabilities for non-local->local blts
 
551
/*14c*/ DWORD   dwNLVBRops[DD_ROP_SPACE]; // ROPS supported for non-local->local blts
 
552
} DDCAPS_DX5;
 
553
typedef DDCAPS_DX5 FAR* LPDDCAPS_DX5;
 
554
 
 
555
typedef struct _DDCAPS_DX6
 
556
{
 
557
/*  0*/ DWORD   dwSize;                 // size of the DDDRIVERCAPS structure
 
558
/*  4*/ DWORD   dwCaps;                 // driver specific capabilities
 
559
/*  8*/ DWORD   dwCaps2;                // more driver specific capabilites
 
560
/*  c*/ DWORD   dwCKeyCaps;             // color key capabilities of the surface
 
561
/* 10*/ DWORD   dwFXCaps;               // driver specific stretching and effects capabilites
 
562
/* 14*/ DWORD   dwFXAlphaCaps;          // alpha caps
 
563
/* 18*/ DWORD   dwPalCaps;              // palette capabilities
 
564
/* 1c*/ DWORD   dwSVCaps;               // stereo vision capabilities
 
565
/* 20*/ DWORD   dwAlphaBltConstBitDepths;       // DDBD_2,4,8
 
566
/* 24*/ DWORD   dwAlphaBltPixelBitDepths;       // DDBD_1,2,4,8
 
567
/* 28*/ DWORD   dwAlphaBltSurfaceBitDepths;     // DDBD_1,2,4,8
 
568
/* 2c*/ DWORD   dwAlphaOverlayConstBitDepths;   // DDBD_2,4,8
 
569
/* 30*/ DWORD   dwAlphaOverlayPixelBitDepths;   // DDBD_1,2,4,8
 
570
/* 34*/ DWORD   dwAlphaOverlaySurfaceBitDepths; // DDBD_1,2,4,8
 
571
/* 38*/ DWORD   dwZBufferBitDepths;             // DDBD_8,16,24,32
 
572
/* 3c*/ DWORD   dwVidMemTotal;          // total amount of video memory
 
573
/* 40*/ DWORD   dwVidMemFree;           // amount of free video memory
 
574
/* 44*/ DWORD   dwMaxVisibleOverlays;   // maximum number of visible overlays
 
575
/* 48*/ DWORD   dwCurrVisibleOverlays;  // current number of visible overlays
 
576
/* 4c*/ DWORD   dwNumFourCCCodes;       // number of four cc codes
 
577
/* 50*/ DWORD   dwAlignBoundarySrc;     // source rectangle alignment
 
578
/* 54*/ DWORD   dwAlignSizeSrc;         // source rectangle byte size
 
579
/* 58*/ DWORD   dwAlignBoundaryDest;    // dest rectangle alignment
 
580
/* 5c*/ DWORD   dwAlignSizeDest;        // dest rectangle byte size
 
581
/* 60*/ DWORD   dwAlignStrideAlign;     // stride alignment
 
582
/* 64*/ DWORD   dwRops[DD_ROP_SPACE];   // ROPS supported
 
583
/* 84*/ DDSCAPS ddsOldCaps;             // Was DDSCAPS  ddsCaps. ddsCaps is of type DDSCAPS2 for DX6
 
584
/* 88*/ DWORD   dwMinOverlayStretch;    // minimum overlay stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3
 
585
/* 8c*/ DWORD   dwMaxOverlayStretch;    // maximum overlay stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3
 
586
/* 90*/ DWORD   dwMinLiveVideoStretch;  // minimum live video stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3
 
587
/* 94*/ DWORD   dwMaxLiveVideoStretch;  // maximum live video stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3
 
588
/* 98*/ DWORD   dwMinHwCodecStretch;    // minimum hardware codec stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3
 
589
/* 9c*/ DWORD   dwMaxHwCodecStretch;    // maximum hardware codec stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3
 
590
/* a0*/ DWORD   dwReserved1;            // reserved
 
591
/* a4*/ DWORD   dwReserved2;            // reserved
 
592
/* a8*/ DWORD   dwReserved3;            // reserved
 
593
/* ac*/ DWORD   dwSVBCaps;              // driver specific capabilities for System->Vmem blts
 
594
/* b0*/ DWORD   dwSVBCKeyCaps;          // driver color key capabilities for System->Vmem blts
 
595
/* b4*/ DWORD   dwSVBFXCaps;            // driver FX capabilities for System->Vmem blts
 
596
/* b8*/ DWORD   dwSVBRops[DD_ROP_SPACE];// ROPS supported for System->Vmem blts
 
597
/* d8*/ DWORD   dwVSBCaps;              // driver specific capabilities for Vmem->System blts
 
598
/* dc*/ DWORD   dwVSBCKeyCaps;          // driver color key capabilities for Vmem->System blts
 
599
/* e0*/ DWORD   dwVSBFXCaps;            // driver FX capabilities for Vmem->System blts
 
600
/* e4*/ DWORD   dwVSBRops[DD_ROP_SPACE];// ROPS supported for Vmem->System blts
 
601
/*104*/ DWORD   dwSSBCaps;              // driver specific capabilities for System->System blts
 
602
/*108*/ DWORD   dwSSBCKeyCaps;          // driver color key capabilities for System->System blts
 
603
/*10c*/ DWORD   dwSSBFXCaps;            // driver FX capabilities for System->System blts
 
604
/*110*/ DWORD   dwSSBRops[DD_ROP_SPACE];// ROPS supported for System->System blts
 
605
/*130*/ DWORD   dwMaxVideoPorts;        // maximum number of usable video ports
 
606
/*134*/ DWORD   dwCurrVideoPorts;       // current number of video ports used
 
607
/*138*/ DWORD   dwSVBCaps2;             // more driver specific capabilities for System->Vmem blts
 
608
/*13c*/ DWORD   dwNLVBCaps;               // driver specific capabilities for non-local->local vidmem blts
 
609
/*140*/ DWORD   dwNLVBCaps2;              // more driver specific capabilities non-local->local vidmem blts
 
610
/*144*/ DWORD   dwNLVBCKeyCaps;           // driver color key capabilities for non-local->local vidmem blts
 
611
/*148*/ DWORD   dwNLVBFXCaps;             // driver FX capabilities for non-local->local blts
 
612
/*14c*/ DWORD   dwNLVBRops[DD_ROP_SPACE]; // ROPS supported for non-local->local blts
 
613
// Members added for DX6 release
 
614
/*16c*/ DDSCAPS2 ddsCaps;               // Surface Caps
 
615
} DDCAPS_DX6;
 
616
typedef DDCAPS_DX6 FAR* LPDDCAPS_DX6;
 
617
 
 
618
typedef struct _DDCAPS_DX7
 
619
{
 
620
/*  0*/ DWORD   dwSize;                 // size of the DDDRIVERCAPS structure
 
621
/*  4*/ DWORD   dwCaps;                 // driver specific capabilities
 
622
/*  8*/ DWORD   dwCaps2;                // more driver specific capabilites
 
623
/*  c*/ DWORD   dwCKeyCaps;             // color key capabilities of the surface
 
624
/* 10*/ DWORD   dwFXCaps;               // driver specific stretching and effects capabilites
 
625
/* 14*/ DWORD   dwFXAlphaCaps;          // alpha driver specific capabilities
 
626
/* 18*/ DWORD   dwPalCaps;              // palette capabilities
 
627
/* 1c*/ DWORD   dwSVCaps;               // stereo vision capabilities
 
628
/* 20*/ DWORD   dwAlphaBltConstBitDepths;       // DDBD_2,4,8
 
629
/* 24*/ DWORD   dwAlphaBltPixelBitDepths;       // DDBD_1,2,4,8
 
630
/* 28*/ DWORD   dwAlphaBltSurfaceBitDepths;     // DDBD_1,2,4,8
 
631
/* 2c*/ DWORD   dwAlphaOverlayConstBitDepths;   // DDBD_2,4,8
 
632
/* 30*/ DWORD   dwAlphaOverlayPixelBitDepths;   // DDBD_1,2,4,8
 
633
/* 34*/ DWORD   dwAlphaOverlaySurfaceBitDepths; // DDBD_1,2,4,8
 
634
/* 38*/ DWORD   dwZBufferBitDepths;             // DDBD_8,16,24,32
 
635
/* 3c*/ DWORD   dwVidMemTotal;          // total amount of video memory
 
636
/* 40*/ DWORD   dwVidMemFree;           // amount of free video memory
 
637
/* 44*/ DWORD   dwMaxVisibleOverlays;   // maximum number of visible overlays
 
638
/* 48*/ DWORD   dwCurrVisibleOverlays;  // current number of visible overlays
 
639
/* 4c*/ DWORD   dwNumFourCCCodes;       // number of four cc codes
 
640
/* 50*/ DWORD   dwAlignBoundarySrc;     // source rectangle alignment
 
641
/* 54*/ DWORD   dwAlignSizeSrc;         // source rectangle byte size
 
642
/* 58*/ DWORD   dwAlignBoundaryDest;    // dest rectangle alignment
 
643
/* 5c*/ DWORD   dwAlignSizeDest;        // dest rectangle byte size
 
644
/* 60*/ DWORD   dwAlignStrideAlign;     // stride alignment
 
645
/* 64*/ DWORD   dwRops[DD_ROP_SPACE];   // ROPS supported
 
646
/* 84*/ DDSCAPS ddsOldCaps;             // Was DDSCAPS  ddsCaps. ddsCaps is of type DDSCAPS2 for DX6
 
647
/* 88*/ DWORD   dwMinOverlayStretch;    // minimum overlay stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3
 
648
/* 8c*/ DWORD   dwMaxOverlayStretch;    // maximum overlay stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3
 
649
/* 90*/ DWORD   dwMinLiveVideoStretch;  // minimum live video stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3
 
650
/* 94*/ DWORD   dwMaxLiveVideoStretch;  // maximum live video stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3
 
651
/* 98*/ DWORD   dwMinHwCodecStretch;    // minimum hardware codec stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3
 
652
/* 9c*/ DWORD   dwMaxHwCodecStretch;    // maximum hardware codec stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3
 
653
/* a0*/ DWORD   dwReserved1;            // reserved
 
654
/* a4*/ DWORD   dwReserved2;            // reserved
 
655
/* a8*/ DWORD   dwReserved3;            // reserved
 
656
/* ac*/ DWORD   dwSVBCaps;              // driver specific capabilities for System->Vmem blts
 
657
/* b0*/ DWORD   dwSVBCKeyCaps;          // driver color key capabilities for System->Vmem blts
 
658
/* b4*/ DWORD   dwSVBFXCaps;            // driver FX capabilities for System->Vmem blts
 
659
/* b8*/ DWORD   dwSVBRops[DD_ROP_SPACE];// ROPS supported for System->Vmem blts
 
660
/* d8*/ DWORD   dwVSBCaps;              // driver specific capabilities for Vmem->System blts
 
661
/* dc*/ DWORD   dwVSBCKeyCaps;          // driver color key capabilities for Vmem->System blts
 
662
/* e0*/ DWORD   dwVSBFXCaps;            // driver FX capabilities for Vmem->System blts
 
663
/* e4*/ DWORD   dwVSBRops[DD_ROP_SPACE];// ROPS supported for Vmem->System blts
 
664
/*104*/ DWORD   dwSSBCaps;              // driver specific capabilities for System->System blts
 
665
/*108*/ DWORD   dwSSBCKeyCaps;          // driver color key capabilities for System->System blts
 
666
/*10c*/ DWORD   dwSSBFXCaps;            // driver FX capabilities for System->System blts
 
667
/*110*/ DWORD   dwSSBRops[DD_ROP_SPACE];// ROPS supported for System->System blts
 
668
/*130*/ DWORD   dwMaxVideoPorts;        // maximum number of usable video ports
 
669
/*134*/ DWORD   dwCurrVideoPorts;       // current number of video ports used
 
670
/*138*/ DWORD   dwSVBCaps2;             // more driver specific capabilities for System->Vmem blts
 
671
/*13c*/ DWORD   dwNLVBCaps;               // driver specific capabilities for non-local->local vidmem blts
 
672
/*140*/ DWORD   dwNLVBCaps2;              // more driver specific capabilities non-local->local vidmem blts
 
673
/*144*/ DWORD   dwNLVBCKeyCaps;           // driver color key capabilities for non-local->local vidmem blts
 
674
/*148*/ DWORD   dwNLVBFXCaps;             // driver FX capabilities for non-local->local blts
 
675
/*14c*/ DWORD   dwNLVBRops[DD_ROP_SPACE]; // ROPS supported for non-local->local blts
 
676
// Members added for DX6 release
 
677
/*16c*/ DDSCAPS2 ddsCaps;               // Surface Caps
 
678
} DDCAPS_DX7;
 
679
typedef DDCAPS_DX7 FAR* LPDDCAPS_DX7;
 
680
 
 
681
 
 
682
#if DIRECTDRAW_VERSION <= 0x300
 
683
    typedef DDCAPS_DX3 DDCAPS;
 
684
#elif DIRECTDRAW_VERSION <= 0x500
 
685
    typedef DDCAPS_DX5 DDCAPS;
 
686
#elif DIRECTDRAW_VERSION <= 0x600
 
687
    typedef DDCAPS_DX6 DDCAPS;
 
688
#else
 
689
    typedef DDCAPS_DX7 DDCAPS;
 
690
#endif
 
691
 
 
692
typedef DDCAPS FAR* LPDDCAPS;
 
693
 
 
694
 
 
695
 
 
696
/*
 
697
 * DDPIXELFORMAT
 
698
 */
 
699
typedef struct _DDPIXELFORMAT
 
700
{
 
701
    DWORD       dwSize;                 // size of structure
 
702
    DWORD       dwFlags;                // pixel format flags
 
703
    DWORD       dwFourCC;               // (FOURCC code)
 
704
    union
 
705
    {
 
706
        DWORD   dwRGBBitCount;          // how many bits per pixel
 
707
        DWORD   dwYUVBitCount;          // how many bits per pixel
 
708
        DWORD   dwZBufferBitDepth;      // how many total bits/pixel in z buffer (including any stencil bits)
 
709
        DWORD   dwAlphaBitDepth;        // how many bits for alpha channels
 
710
        DWORD   dwLuminanceBitCount;    // how many bits per pixel
 
711
        DWORD   dwBumpBitCount;         // how many bits per "buxel", total
 
712
        DWORD   dwPrivateFormatBitCount;// Bits per pixel of private driver formats. Only valid in texture
 
713
                                        // format list and if DDPF_D3DFORMAT is set
 
714
    } DUMMYUNIONNAMEN(1);
 
715
    union
 
716
    {
 
717
        DWORD   dwRBitMask;             // mask for red bit
 
718
        DWORD   dwYBitMask;             // mask for Y bits
 
719
        DWORD   dwStencilBitDepth;      // how many stencil bits (note: dwZBufferBitDepth-dwStencilBitDepth is total Z-only bits)
 
720
        DWORD   dwLuminanceBitMask;     // mask for luminance bits
 
721
        DWORD   dwBumpDuBitMask;        // mask for bump map U delta bits
 
722
        DWORD   dwOperations;           // DDPF_D3DFORMAT Operations
 
723
    } DUMMYUNIONNAMEN(2);
 
724
    union
 
725
    {
 
726
        DWORD   dwGBitMask;             // mask for green bits
 
727
        DWORD   dwUBitMask;             // mask for U bits
 
728
        DWORD   dwZBitMask;             // mask for Z bits
 
729
        DWORD   dwBumpDvBitMask;        // mask for bump map V delta bits
 
730
        struct
 
731
        {
 
732
            WORD    wFlipMSTypes;       // Multisample methods supported via flip for this D3DFORMAT
 
733
            WORD    wBltMSTypes;        // Multisample methods supported via blt for this D3DFORMAT
 
734
        } MultiSampleCaps;
 
735
 
 
736
    } DUMMYUNIONNAMEN(3);
 
737
    union
 
738
    {
 
739
        DWORD   dwBBitMask;             // mask for blue bits
 
740
        DWORD   dwVBitMask;             // mask for V bits
 
741
        DWORD   dwStencilBitMask;       // mask for stencil bits
 
742
        DWORD   dwBumpLuminanceBitMask; // mask for luminance in bump map
 
743
    } DUMMYUNIONNAMEN(4);
 
744
    union
 
745
    {
 
746
        DWORD   dwRGBAlphaBitMask;      // mask for alpha channel
 
747
        DWORD   dwYUVAlphaBitMask;      // mask for alpha channel
 
748
        DWORD   dwLuminanceAlphaBitMask;// mask for alpha channel
 
749
        DWORD   dwRGBZBitMask;          // mask for Z channel
 
750
        DWORD   dwYUVZBitMask;          // mask for Z channel
 
751
    } DUMMYUNIONNAMEN(5);
 
752
} DDPIXELFORMAT;
 
753
 
 
754
typedef DDPIXELFORMAT FAR* LPDDPIXELFORMAT;
 
755
 
 
756
/*
 
757
 * DDOVERLAYFX
 
758
 */
 
759
typedef struct _DDOVERLAYFX
 
760
{
 
761
    DWORD       dwSize;                         // size of structure
 
762
    DWORD       dwAlphaEdgeBlendBitDepth;       // Bit depth used to specify constant for alpha edge blend
 
763
    DWORD       dwAlphaEdgeBlend;               // Constant to use as alpha for edge blend
 
764
    DWORD       dwReserved;
 
765
    DWORD       dwAlphaDestConstBitDepth;       // Bit depth used to specify alpha constant for destination
 
766
    union
 
767
    {
 
768
        DWORD   dwAlphaDestConst;               // Constant to use as alpha channel for dest
 
769
        LPDIRECTDRAWSURFACE lpDDSAlphaDest;     // Surface to use as alpha channel for dest
 
770
    } DUMMYUNIONNAMEN(1);
 
771
    DWORD       dwAlphaSrcConstBitDepth;        // Bit depth used to specify alpha constant for source
 
772
    union
 
773
    {
 
774
        DWORD   dwAlphaSrcConst;                // Constant to use as alpha channel for src
 
775
        LPDIRECTDRAWSURFACE lpDDSAlphaSrc;      // Surface to use as alpha channel for src
 
776
    } DUMMYUNIONNAMEN(2);
 
777
    DDCOLORKEY  dckDestColorkey;                // DestColorkey override
 
778
    DDCOLORKEY  dckSrcColorkey;                 // DestColorkey override
 
779
    DWORD       dwDDFX;                         // Overlay FX
 
780
    DWORD       dwFlags;                        // flags
 
781
} DDOVERLAYFX;
 
782
 
 
783
typedef DDOVERLAYFX FAR *LPDDOVERLAYFX;
 
784
 
 
785
 
 
786
/*
 
787
 * DDBLTBATCH: BltBatch entry structure
 
788
 */
 
789
typedef struct _DDBLTBATCH
 
790
{
 
791
    LPRECT              lprDest;
 
792
    LPDIRECTDRAWSURFACE lpDDSSrc;
 
793
    LPRECT              lprSrc;
 
794
    DWORD               dwFlags;
 
795
    LPDDBLTFX           lpDDBltFx;
 
796
} DDBLTBATCH;
 
797
 
 
798
typedef DDBLTBATCH FAR * LPDDBLTBATCH;
 
799
 
 
800
 
 
801
/*
 
802
 * DDGAMMARAMP
 
803
 */
 
804
typedef struct _DDGAMMARAMP
 
805
{
 
806
    WORD                red[256];
 
807
    WORD                green[256];
 
808
    WORD                blue[256];
 
809
} DDGAMMARAMP;
 
810
typedef DDGAMMARAMP FAR * LPDDGAMMARAMP;
 
811
 
 
812
/*
 
813
 *  This is the structure within which DirectDraw returns data about the current graphics driver and chipset
 
814
 */
 
815
 
 
816
#define MAX_DDDEVICEID_STRING           512
 
817
 
 
818
typedef struct tagDDDEVICEIDENTIFIER
 
819
{
 
820
    /*
 
821
     * These elements are for presentation to the user only. They should not be used to identify particular
 
822
     * drivers, since this is unreliable and many different strings may be associated with the same
 
823
     * device, and the same driver from different vendors.
 
824
     */
 
825
    char    szDriver[MAX_DDDEVICEID_STRING];
 
826
    char    szDescription[MAX_DDDEVICEID_STRING];
 
827
 
 
828
    /*
 
829
     * This element is the version of the DirectDraw/3D driver. It is legal to do <, > comparisons
 
830
     * on the whole 64 bits. Caution should be exercised if you use this element to identify problematic
 
831
     * drivers. It is recommended that guidDeviceIdentifier is used for this purpose.
 
832
     *
 
833
     * This version has the form:
 
834
     *  wProduct = HIWORD(liDriverVersion.HighPart)
 
835
     *  wVersion = LOWORD(liDriverVersion.HighPart)
 
836
     *  wSubVersion = HIWORD(liDriverVersion.LowPart)
 
837
     *  wBuild = LOWORD(liDriverVersion.LowPart)
 
838
     */
 
839
#ifdef _WIN32
 
840
    LARGE_INTEGER liDriverVersion;      /* Defined for applications and other 32 bit components */
 
841
#else
 
842
    DWORD   dwDriverVersionLowPart;     /* Defined for 16 bit driver components */
 
843
    DWORD   dwDriverVersionHighPart;
 
844
#endif
 
845
 
 
846
 
 
847
    /*
 
848
     * These elements can be used to identify particular chipsets. Use with extreme caution.
 
849
     *   dwVendorId     Identifies the manufacturer. May be zero if unknown.
 
850
     *   dwDeviceId     Identifies the type of chipset. May be zero if unknown.
 
851
     *   dwSubSysId     Identifies the subsystem, typically this means the particular board. May be zero if unknown.
 
852
     *   dwRevision     Identifies the revision level of the chipset. May be zero if unknown.
 
853
     */
 
854
    DWORD   dwVendorId;
 
855
    DWORD   dwDeviceId;
 
856
    DWORD   dwSubSysId;
 
857
    DWORD   dwRevision;
 
858
 
 
859
    /*
 
860
     * This element can be used to check changes in driver/chipset. This GUID is a unique identifier for the
 
861
     * driver/chipset pair. Use this element if you wish to track changes to the driver/chipset in order to
 
862
     * reprofile the graphics subsystem.
 
863
     * This element can also be used to identify particular problematic drivers.
 
864
     */
 
865
    GUID    guidDeviceIdentifier;
 
866
} DDDEVICEIDENTIFIER, * LPDDDEVICEIDENTIFIER;
 
867
 
 
868
typedef struct tagDDDEVICEIDENTIFIER2
 
869
{
 
870
    /*
 
871
     * These elements are for presentation to the user only. They should not be used to identify particular
 
872
     * drivers, since this is unreliable and many different strings may be associated with the same
 
873
     * device, and the same driver from different vendors.
 
874
     */
 
875
    char    szDriver[MAX_DDDEVICEID_STRING];
 
876
    char    szDescription[MAX_DDDEVICEID_STRING];
 
877
 
 
878
    /*
 
879
     * This element is the version of the DirectDraw/3D driver. It is legal to do <, > comparisons
 
880
     * on the whole 64 bits. Caution should be exercised if you use this element to identify problematic
 
881
     * drivers. It is recommended that guidDeviceIdentifier is used for this purpose.
 
882
     *
 
883
     * This version has the form:
 
884
     *  wProduct = HIWORD(liDriverVersion.HighPart)
 
885
     *  wVersion = LOWORD(liDriverVersion.HighPart)
 
886
     *  wSubVersion = HIWORD(liDriverVersion.LowPart)
 
887
     *  wBuild = LOWORD(liDriverVersion.LowPart)
 
888
     */
 
889
#ifdef _WIN32
 
890
    LARGE_INTEGER liDriverVersion;      /* Defined for applications and other 32 bit components */
 
891
#else
 
892
    DWORD   dwDriverVersionLowPart;     /* Defined for 16 bit driver components */
 
893
    DWORD   dwDriverVersionHighPart;
 
894
#endif
 
895
 
 
896
 
 
897
    /*
 
898
     * These elements can be used to identify particular chipsets. Use with extreme caution.
 
899
     *   dwVendorId     Identifies the manufacturer. May be zero if unknown.
 
900
     *   dwDeviceId     Identifies the type of chipset. May be zero if unknown.
 
901
     *   dwSubSysId     Identifies the subsystem, typically this means the particular board. May be zero if unknown.
 
902
     *   dwRevision     Identifies the revision level of the chipset. May be zero if unknown.
 
903
     */
 
904
    DWORD   dwVendorId;
 
905
    DWORD   dwDeviceId;
 
906
    DWORD   dwSubSysId;
 
907
    DWORD   dwRevision;
 
908
 
 
909
    /*
 
910
     * This element can be used to check changes in driver/chipset. This GUID is a unique identifier for the
 
911
     * driver/chipset pair. Use this element if you wish to track changes to the driver/chipset in order to
 
912
     * reprofile the graphics subsystem.
 
913
     * This element can also be used to identify particular problematic drivers.
 
914
     */
 
915
    GUID    guidDeviceIdentifier;
 
916
 
 
917
    /*
 
918
     * This element is used to determine the Windows Hardware Quality Lab (WHQL)
 
919
     * certification level for this driver/device pair.
 
920
     */
 
921
    DWORD   dwWHQLLevel;
 
922
 
 
923
} DDDEVICEIDENTIFIER2, * LPDDDEVICEIDENTIFIER2;
 
924
 
 
925
/*
 
926
 * Flags for the IDirectDraw4::GetDeviceIdentifier method
 
927
 */
 
928
 
 
929
/*
 
930
 * This flag causes GetDeviceIdentifier to return information about the host (typically 2D) adapter in a system equipped
 
931
 * with a stacked secondary 3D adapter. Such an adapter appears to the application as if it were part of the
 
932
 * host adapter, but is typically physcially located on a separate card. The stacked secondary's information is
 
933
 * returned when GetDeviceIdentifier's dwFlags field is zero, since this most accurately reflects the qualities
 
934
 * of the DirectDraw object involved.
 
935
 */
 
936
#define DDGDI_GETHOSTIDENTIFIER         0x00000001L
 
937
 
 
938
/*
 
939
 * Macros for interpretting DDEVICEIDENTIFIER2.dwWHQLLevel
 
940
 */
 
941
#define GET_WHQL_YEAR( dwWHQLLevel ) \
 
942
    ( (dwWHQLLevel) / 0x10000 )
 
943
#define GET_WHQL_MONTH( dwWHQLLevel ) \
 
944
    ( ( (dwWHQLLevel) / 0x100 ) & 0x00ff )
 
945
#define GET_WHQL_DAY( dwWHQLLevel ) \
 
946
    ( (dwWHQLLevel) & 0xff )
 
947
 
 
948
 
 
949
/*
 
950
 * callbacks
 
951
 */
 
952
typedef DWORD   (FAR PASCAL *LPCLIPPERCALLBACK)(LPDIRECTDRAWCLIPPER lpDDClipper, HWND hWnd, DWORD code, LPVOID lpContext );
 
953
#ifdef STREAMING
 
954
typedef DWORD   (FAR PASCAL *LPSURFACESTREAMINGCALLBACK)(DWORD);
 
955
#endif
 
956
 
 
957
 
 
958
/*
 
959
 * INTERACES FOLLOW:
 
960
 *      IDirectDraw
 
961
 *      IDirectDrawClipper
 
962
 *      IDirectDrawPalette
 
963
 *      IDirectDrawSurface
 
964
 */
 
965
 
 
966
/*
 
967
 * IDirectDraw
 
968
 */
 
969
#if defined( _WIN32 ) && !defined( _NO_COM )
 
970
#undef INTERFACE
 
971
#define INTERFACE IDirectDraw
 
972
DECLARE_INTERFACE_( IDirectDraw, IUnknown )
 
973
{
 
974
    /*** IUnknown methods ***/
 
975
    STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE;
 
976
    STDMETHOD_(ULONG,AddRef) (THIS)  PURE;
 
977
    STDMETHOD_(ULONG,Release) (THIS) PURE;
 
978
    /*** IDirectDraw methods ***/
 
979
    STDMETHOD(Compact)(THIS) PURE;
 
980
    STDMETHOD(CreateClipper)(THIS_ DWORD, LPDIRECTDRAWCLIPPER FAR*, IUnknown FAR * ) PURE;
 
981
    STDMETHOD(CreatePalette)(THIS_ DWORD, LPPALETTEENTRY, LPDIRECTDRAWPALETTE FAR*, IUnknown FAR * ) PURE;
 
982
    STDMETHOD(CreateSurface)(THIS_  LPDDSURFACEDESC, LPDIRECTDRAWSURFACE FAR *, IUnknown FAR *) PURE;
 
983
    STDMETHOD(DuplicateSurface)( THIS_ LPDIRECTDRAWSURFACE, LPDIRECTDRAWSURFACE FAR * ) PURE;
 
984
    STDMETHOD(EnumDisplayModes)( THIS_ DWORD, LPDDSURFACEDESC, LPVOID, LPDDENUMMODESCALLBACK ) PURE;
 
985
    STDMETHOD(EnumSurfaces)(THIS_ DWORD, LPDDSURFACEDESC, LPVOID,LPDDENUMSURFACESCALLBACK ) PURE;
 
986
    STDMETHOD(FlipToGDISurface)(THIS) PURE;
 
987
    STDMETHOD(GetCaps)( THIS_ LPDDCAPS, LPDDCAPS) PURE;
 
988
    STDMETHOD(GetDisplayMode)( THIS_ LPDDSURFACEDESC) PURE;
 
989
    STDMETHOD(GetFourCCCodes)(THIS_  LPDWORD, LPDWORD ) PURE;
 
990
    STDMETHOD(GetGDISurface)(THIS_ LPDIRECTDRAWSURFACE FAR *) PURE;
 
991
    STDMETHOD(GetMonitorFrequency)(THIS_ LPDWORD) PURE;
 
992
    STDMETHOD(GetScanLine)(THIS_ LPDWORD) PURE;
 
993
    STDMETHOD(GetVerticalBlankStatus)(THIS_ LPBOOL ) PURE;
 
994
    STDMETHOD(Initialize)(THIS_ GUID FAR *) PURE;
 
995
    STDMETHOD(RestoreDisplayMode)(THIS) PURE;
 
996
    STDMETHOD(SetCooperativeLevel)(THIS_ HWND, DWORD) PURE;
 
997
    STDMETHOD(SetDisplayMode)(THIS_ DWORD, DWORD,DWORD) PURE;
 
998
    STDMETHOD(WaitForVerticalBlank)(THIS_ DWORD, HANDLE ) PURE;
 
999
};
 
1000
 
 
1001
#if !defined(__cplusplus) || defined(CINTERFACE)
 
1002
#define IDirectDraw_QueryInterface(p, a, b)         (p)->lpVtbl->QueryInterface(p, a, b)
 
1003
#define IDirectDraw_AddRef(p)                       (p)->lpVtbl->AddRef(p)
 
1004
#define IDirectDraw_Release(p)                      (p)->lpVtbl->Release(p)
 
1005
#define IDirectDraw_Compact(p)                      (p)->lpVtbl->Compact(p)
 
1006
#define IDirectDraw_CreateClipper(p, a, b, c)       (p)->lpVtbl->CreateClipper(p, a, b, c)
 
1007
#define IDirectDraw_CreatePalette(p, a, b, c, d)    (p)->lpVtbl->CreatePalette(p, a, b, c, d)
 
1008
#define IDirectDraw_CreateSurface(p, a, b, c)       (p)->lpVtbl->CreateSurface(p, a, b, c)
 
1009
#define IDirectDraw_DuplicateSurface(p, a, b)       (p)->lpVtbl->DuplicateSurface(p, a, b)
 
1010
#define IDirectDraw_EnumDisplayModes(p, a, b, c, d) (p)->lpVtbl->EnumDisplayModes(p, a, b, c, d)
 
1011
#define IDirectDraw_EnumSurfaces(p, a, b, c, d)     (p)->lpVtbl->EnumSurfaces(p, a, b, c, d)
 
1012
#define IDirectDraw_FlipToGDISurface(p)             (p)->lpVtbl->FlipToGDISurface(p)
 
1013
#define IDirectDraw_GetCaps(p, a, b)                (p)->lpVtbl->GetCaps(p, a, b)
 
1014
#define IDirectDraw_GetDisplayMode(p, a)            (p)->lpVtbl->GetDisplayMode(p, a)
 
1015
#define IDirectDraw_GetFourCCCodes(p, a, b)         (p)->lpVtbl->GetFourCCCodes(p, a, b)
 
1016
#define IDirectDraw_GetGDISurface(p, a)             (p)->lpVtbl->GetGDISurface(p, a)
 
1017
#define IDirectDraw_GetMonitorFrequency(p, a)       (p)->lpVtbl->GetMonitorFrequency(p, a)
 
1018
#define IDirectDraw_GetScanLine(p, a)               (p)->lpVtbl->GetScanLine(p, a)
 
1019
#define IDirectDraw_GetVerticalBlankStatus(p, a)    (p)->lpVtbl->GetVerticalBlankStatus(p, a)
 
1020
#define IDirectDraw_Initialize(p, a)                (p)->lpVtbl->Initialize(p, a)
 
1021
#define IDirectDraw_RestoreDisplayMode(p)           (p)->lpVtbl->RestoreDisplayMode(p)
 
1022
#define IDirectDraw_SetCooperativeLevel(p, a, b)    (p)->lpVtbl->SetCooperativeLevel(p, a, b)
 
1023
#define IDirectDraw_SetDisplayMode(p, a, b, c)      (p)->lpVtbl->SetDisplayMode(p, a, b, c)
 
1024
#define IDirectDraw_WaitForVerticalBlank(p, a, b)   (p)->lpVtbl->WaitForVerticalBlank(p, a, b)
 
1025
#else
 
1026
#define IDirectDraw_QueryInterface(p, a, b)         (p)->QueryInterface(a, b)
 
1027
#define IDirectDraw_AddRef(p)                       (p)->AddRef()
 
1028
#define IDirectDraw_Release(p)                      (p)->Release()
 
1029
#define IDirectDraw_Compact(p)                      (p)->Compact()
 
1030
#define IDirectDraw_CreateClipper(p, a, b, c)       (p)->CreateClipper(a, b, c)
 
1031
#define IDirectDraw_CreatePalette(p, a, b, c, d)    (p)->CreatePalette(a, b, c, d)
 
1032
#define IDirectDraw_CreateSurface(p, a, b, c)       (p)->CreateSurface(a, b, c)
 
1033
#define IDirectDraw_DuplicateSurface(p, a, b)       (p)->DuplicateSurface(a, b)
 
1034
#define IDirectDraw_EnumDisplayModes(p, a, b, c, d) (p)->EnumDisplayModes(a, b, c, d)
 
1035
#define IDirectDraw_EnumSurfaces(p, a, b, c, d)     (p)->EnumSurfaces(a, b, c, d)
 
1036
#define IDirectDraw_FlipToGDISurface(p)             (p)->FlipToGDISurface()
 
1037
#define IDirectDraw_GetCaps(p, a, b)                (p)->GetCaps(a, b)
 
1038
#define IDirectDraw_GetDisplayMode(p, a)            (p)->GetDisplayMode(a)
 
1039
#define IDirectDraw_GetFourCCCodes(p, a, b)         (p)->GetFourCCCodes(a, b)
 
1040
#define IDirectDraw_GetGDISurface(p, a)             (p)->GetGDISurface(a)
 
1041
#define IDirectDraw_GetMonitorFrequency(p, a)       (p)->GetMonitorFrequency(a)
 
1042
#define IDirectDraw_GetScanLine(p, a)               (p)->GetScanLine(a)
 
1043
#define IDirectDraw_GetVerticalBlankStatus(p, a)    (p)->GetVerticalBlankStatus(a)
 
1044
#define IDirectDraw_Initialize(p, a)                (p)->Initialize(a)
 
1045
#define IDirectDraw_RestoreDisplayMode(p)           (p)->RestoreDisplayMode()
 
1046
#define IDirectDraw_SetCooperativeLevel(p, a, b)    (p)->SetCooperativeLevel(a, b)
 
1047
#define IDirectDraw_SetDisplayMode(p, a, b, c)      (p)->SetDisplayMode(a, b, c)
 
1048
#define IDirectDraw_WaitForVerticalBlank(p, a, b)   (p)->WaitForVerticalBlank(a, b)
 
1049
#endif
 
1050
 
 
1051
#endif
 
1052
 
 
1053
#if defined( _WIN32 ) && !defined( _NO_COM )
 
1054
#undef INTERFACE
 
1055
#define INTERFACE IDirectDraw2
 
1056
DECLARE_INTERFACE_( IDirectDraw2, IUnknown )
 
1057
{
 
1058
    /*** IUnknown methods ***/
 
1059
    STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE;
 
1060
    STDMETHOD_(ULONG,AddRef) (THIS)  PURE;
 
1061
    STDMETHOD_(ULONG,Release) (THIS) PURE;
 
1062
    /*** IDirectDraw methods ***/
 
1063
    STDMETHOD(Compact)(THIS) PURE;
 
1064
    STDMETHOD(CreateClipper)(THIS_ DWORD, LPDIRECTDRAWCLIPPER FAR*, IUnknown FAR * ) PURE;
 
1065
    STDMETHOD(CreatePalette)(THIS_ DWORD, LPPALETTEENTRY, LPDIRECTDRAWPALETTE FAR*, IUnknown FAR * ) PURE;
 
1066
    STDMETHOD(CreateSurface)(THIS_  LPDDSURFACEDESC, LPDIRECTDRAWSURFACE FAR *, IUnknown FAR *) PURE;
 
1067
    STDMETHOD(DuplicateSurface)( THIS_ LPDIRECTDRAWSURFACE, LPDIRECTDRAWSURFACE FAR * ) PURE;
 
1068
    STDMETHOD(EnumDisplayModes)( THIS_ DWORD, LPDDSURFACEDESC, LPVOID, LPDDENUMMODESCALLBACK ) PURE;
 
1069
    STDMETHOD(EnumSurfaces)(THIS_ DWORD, LPDDSURFACEDESC, LPVOID,LPDDENUMSURFACESCALLBACK ) PURE;
 
1070
    STDMETHOD(FlipToGDISurface)(THIS) PURE;
 
1071
    STDMETHOD(GetCaps)( THIS_ LPDDCAPS, LPDDCAPS) PURE;
 
1072
    STDMETHOD(GetDisplayMode)( THIS_ LPDDSURFACEDESC) PURE;
 
1073
    STDMETHOD(GetFourCCCodes)(THIS_  LPDWORD, LPDWORD ) PURE;
 
1074
    STDMETHOD(GetGDISurface)(THIS_ LPDIRECTDRAWSURFACE FAR *) PURE;
 
1075
    STDMETHOD(GetMonitorFrequency)(THIS_ LPDWORD) PURE;
 
1076
    STDMETHOD(GetScanLine)(THIS_ LPDWORD) PURE;
 
1077
    STDMETHOD(GetVerticalBlankStatus)(THIS_ LPBOOL ) PURE;
 
1078
    STDMETHOD(Initialize)(THIS_ GUID FAR *) PURE;
 
1079
    STDMETHOD(RestoreDisplayMode)(THIS) PURE;
 
1080
    STDMETHOD(SetCooperativeLevel)(THIS_ HWND, DWORD) PURE;
 
1081
    STDMETHOD(SetDisplayMode)(THIS_ DWORD, DWORD,DWORD, DWORD, DWORD) PURE;
 
1082
    STDMETHOD(WaitForVerticalBlank)(THIS_ DWORD, HANDLE ) PURE;
 
1083
    /*** Added in the v2 interface ***/
 
1084
    STDMETHOD(GetAvailableVidMem)(THIS_ LPDDSCAPS, LPDWORD, LPDWORD) PURE;
 
1085
};
 
1086
#if !defined(__cplusplus) || defined(CINTERFACE)
 
1087
#define IDirectDraw2_QueryInterface(p, a, b)         (p)->lpVtbl->QueryInterface(p, a, b)
 
1088
#define IDirectDraw2_AddRef(p)                       (p)->lpVtbl->AddRef(p)
 
1089
#define IDirectDraw2_Release(p)                      (p)->lpVtbl->Release(p)
 
1090
#define IDirectDraw2_Compact(p)                      (p)->lpVtbl->Compact(p)
 
1091
#define IDirectDraw2_CreateClipper(p, a, b, c)       (p)->lpVtbl->CreateClipper(p, a, b, c)
 
1092
#define IDirectDraw2_CreatePalette(p, a, b, c, d)    (p)->lpVtbl->CreatePalette(p, a, b, c, d)
 
1093
#define IDirectDraw2_CreateSurface(p, a, b, c)       (p)->lpVtbl->CreateSurface(p, a, b, c)
 
1094
#define IDirectDraw2_DuplicateSurface(p, a, b)       (p)->lpVtbl->DuplicateSurface(p, a, b)
 
1095
#define IDirectDraw2_EnumDisplayModes(p, a, b, c, d) (p)->lpVtbl->EnumDisplayModes(p, a, b, c, d)
 
1096
#define IDirectDraw2_EnumSurfaces(p, a, b, c, d)     (p)->lpVtbl->EnumSurfaces(p, a, b, c, d)
 
1097
#define IDirectDraw2_FlipToGDISurface(p)             (p)->lpVtbl->FlipToGDISurface(p)
 
1098
#define IDirectDraw2_GetCaps(p, a, b)                (p)->lpVtbl->GetCaps(p, a, b)
 
1099
#define IDirectDraw2_GetDisplayMode(p, a)            (p)->lpVtbl->GetDisplayMode(p, a)
 
1100
#define IDirectDraw2_GetFourCCCodes(p, a, b)         (p)->lpVtbl->GetFourCCCodes(p, a, b)
 
1101
#define IDirectDraw2_GetGDISurface(p, a)             (p)->lpVtbl->GetGDISurface(p, a)
 
1102
#define IDirectDraw2_GetMonitorFrequency(p, a)       (p)->lpVtbl->GetMonitorFrequency(p, a)
 
1103
#define IDirectDraw2_GetScanLine(p, a)               (p)->lpVtbl->GetScanLine(p, a)
 
1104
#define IDirectDraw2_GetVerticalBlankStatus(p, a)    (p)->lpVtbl->GetVerticalBlankStatus(p, a)
 
1105
#define IDirectDraw2_Initialize(p, a)                (p)->lpVtbl->Initialize(p, a)
 
1106
#define IDirectDraw2_RestoreDisplayMode(p)           (p)->lpVtbl->RestoreDisplayMode(p)
 
1107
#define IDirectDraw2_SetCooperativeLevel(p, a, b)    (p)->lpVtbl->SetCooperativeLevel(p, a, b)
 
1108
#define IDirectDraw2_SetDisplayMode(p, a, b, c, d, e) (p)->lpVtbl->SetDisplayMode(p, a, b, c, d, e)
 
1109
#define IDirectDraw2_WaitForVerticalBlank(p, a, b)   (p)->lpVtbl->WaitForVerticalBlank(p, a, b)
 
1110
#define IDirectDraw2_GetAvailableVidMem(p, a, b, c)  (p)->lpVtbl->GetAvailableVidMem(p, a, b, c)
 
1111
#else
 
1112
#define IDirectDraw2_QueryInterface(p, a, b)         (p)->QueryInterface(a, b)
 
1113
#define IDirectDraw2_AddRef(p)                       (p)->AddRef()
 
1114
#define IDirectDraw2_Release(p)                      (p)->Release()
 
1115
#define IDirectDraw2_Compact(p)                      (p)->Compact()
 
1116
#define IDirectDraw2_CreateClipper(p, a, b, c)       (p)->CreateClipper(a, b, c)
 
1117
#define IDirectDraw2_CreatePalette(p, a, b, c, d)    (p)->CreatePalette(a, b, c, d)
 
1118
#define IDirectDraw2_CreateSurface(p, a, b, c)       (p)->CreateSurface(a, b, c)
 
1119
#define IDirectDraw2_DuplicateSurface(p, a, b)       (p)->DuplicateSurface(a, b)
 
1120
#define IDirectDraw2_EnumDisplayModes(p, a, b, c, d) (p)->EnumDisplayModes(a, b, c, d)
 
1121
#define IDirectDraw2_EnumSurfaces(p, a, b, c, d)     (p)->EnumSurfaces(a, b, c, d)
 
1122
#define IDirectDraw2_FlipToGDISurface(p)             (p)->FlipToGDISurface()
 
1123
#define IDirectDraw2_GetCaps(p, a, b)                (p)->GetCaps(a, b)
 
1124
#define IDirectDraw2_GetDisplayMode(p, a)            (p)->GetDisplayMode(a)
 
1125
#define IDirectDraw2_GetFourCCCodes(p, a, b)         (p)->GetFourCCCodes(a, b)
 
1126
#define IDirectDraw2_GetGDISurface(p, a)             (p)->GetGDISurface(a)
 
1127
#define IDirectDraw2_GetMonitorFrequency(p, a)       (p)->GetMonitorFrequency(a)
 
1128
#define IDirectDraw2_GetScanLine(p, a)               (p)->GetScanLine(a)
 
1129
#define IDirectDraw2_GetVerticalBlankStatus(p, a)    (p)->GetVerticalBlankStatus(a)
 
1130
#define IDirectDraw2_Initialize(p, a)                (p)->Initialize(a)
 
1131
#define IDirectDraw2_RestoreDisplayMode(p)           (p)->RestoreDisplayMode()
 
1132
#define IDirectDraw2_SetCooperativeLevel(p, a, b)    (p)->SetCooperativeLevel(a, b)
 
1133
#define IDirectDraw2_SetDisplayMode(p, a, b, c, d, e) (p)->SetDisplayMode(a, b, c, d, e)
 
1134
#define IDirectDraw2_WaitForVerticalBlank(p, a, b)   (p)->WaitForVerticalBlank(a, b)
 
1135
#define IDirectDraw2_GetAvailableVidMem(p, a, b, c)  (p)->GetAvailableVidMem(a, b, c)
 
1136
#endif
 
1137
 
 
1138
#endif
 
1139
 
 
1140
#if defined( _WIN32 ) && !defined( _NO_COM )
 
1141
#undef INTERFACE
 
1142
#define INTERFACE IDirectDraw4
 
1143
DECLARE_INTERFACE_( IDirectDraw4, IUnknown )
 
1144
{
 
1145
    /*** IUnknown methods ***/
 
1146
    STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE;
 
1147
    STDMETHOD_(ULONG,AddRef) (THIS)  PURE;
 
1148
    STDMETHOD_(ULONG,Release) (THIS) PURE;
 
1149
    /*** IDirectDraw methods ***/
 
1150
    STDMETHOD(Compact)(THIS) PURE;
 
1151
    STDMETHOD(CreateClipper)(THIS_ DWORD, LPDIRECTDRAWCLIPPER FAR*, IUnknown FAR * ) PURE;
 
1152
    STDMETHOD(CreatePalette)(THIS_ DWORD, LPPALETTEENTRY, LPDIRECTDRAWPALETTE FAR*, IUnknown FAR * ) PURE;
 
1153
    STDMETHOD(CreateSurface)(THIS_  LPDDSURFACEDESC2, LPDIRECTDRAWSURFACE4 FAR *, IUnknown FAR *) PURE;
 
1154
    STDMETHOD(DuplicateSurface)( THIS_ LPDIRECTDRAWSURFACE4, LPDIRECTDRAWSURFACE4 FAR * ) PURE;
 
1155
    STDMETHOD(EnumDisplayModes)( THIS_ DWORD, LPDDSURFACEDESC2, LPVOID, LPDDENUMMODESCALLBACK2 ) PURE;
 
1156
    STDMETHOD(EnumSurfaces)(THIS_ DWORD, LPDDSURFACEDESC2, LPVOID,LPDDENUMSURFACESCALLBACK2 ) PURE;
 
1157
    STDMETHOD(FlipToGDISurface)(THIS) PURE;
 
1158
    STDMETHOD(GetCaps)( THIS_ LPDDCAPS, LPDDCAPS) PURE;
 
1159
    STDMETHOD(GetDisplayMode)( THIS_ LPDDSURFACEDESC2) PURE;
 
1160
    STDMETHOD(GetFourCCCodes)(THIS_  LPDWORD, LPDWORD ) PURE;
 
1161
    STDMETHOD(GetGDISurface)(THIS_ LPDIRECTDRAWSURFACE4 FAR *) PURE;
 
1162
    STDMETHOD(GetMonitorFrequency)(THIS_ LPDWORD) PURE;
 
1163
    STDMETHOD(GetScanLine)(THIS_ LPDWORD) PURE;
 
1164
    STDMETHOD(GetVerticalBlankStatus)(THIS_ LPBOOL ) PURE;
 
1165
    STDMETHOD(Initialize)(THIS_ GUID FAR *) PURE;
 
1166
    STDMETHOD(RestoreDisplayMode)(THIS) PURE;
 
1167
    STDMETHOD(SetCooperativeLevel)(THIS_ HWND, DWORD) PURE;
 
1168
    STDMETHOD(SetDisplayMode)(THIS_ DWORD, DWORD,DWORD, DWORD, DWORD) PURE;
 
1169
    STDMETHOD(WaitForVerticalBlank)(THIS_ DWORD, HANDLE ) PURE;
 
1170
    /*** Added in the v2 interface ***/
 
1171
    STDMETHOD(GetAvailableVidMem)(THIS_ LPDDSCAPS2, LPDWORD, LPDWORD) PURE;
 
1172
    /*** Added in the V4 Interface ***/
 
1173
    STDMETHOD(GetSurfaceFromDC) (THIS_ HDC, LPDIRECTDRAWSURFACE4 *) PURE;
 
1174
    STDMETHOD(RestoreAllSurfaces)(THIS) PURE;
 
1175
    STDMETHOD(TestCooperativeLevel)(THIS) PURE;
 
1176
    STDMETHOD(GetDeviceIdentifier)(THIS_ LPDDDEVICEIDENTIFIER, DWORD ) PURE;
 
1177
};
 
1178
#if !defined(__cplusplus) || defined(CINTERFACE)
 
1179
#define IDirectDraw4_QueryInterface(p, a, b)         (p)->lpVtbl->QueryInterface(p, a, b)
 
1180
#define IDirectDraw4_AddRef(p)                       (p)->lpVtbl->AddRef(p)
 
1181
#define IDirectDraw4_Release(p)                      (p)->lpVtbl->Release(p)
 
1182
#define IDirectDraw4_Compact(p)                      (p)->lpVtbl->Compact(p)
 
1183
#define IDirectDraw4_CreateClipper(p, a, b, c)       (p)->lpVtbl->CreateClipper(p, a, b, c)
 
1184
#define IDirectDraw4_CreatePalette(p, a, b, c, d)    (p)->lpVtbl->CreatePalette(p, a, b, c, d)
 
1185
#define IDirectDraw4_CreateSurface(p, a, b, c)       (p)->lpVtbl->CreateSurface(p, a, b, c)
 
1186
#define IDirectDraw4_DuplicateSurface(p, a, b)       (p)->lpVtbl->DuplicateSurface(p, a, b)
 
1187
#define IDirectDraw4_EnumDisplayModes(p, a, b, c, d) (p)->lpVtbl->EnumDisplayModes(p, a, b, c, d)
 
1188
#define IDirectDraw4_EnumSurfaces(p, a, b, c, d)     (p)->lpVtbl->EnumSurfaces(p, a, b, c, d)
 
1189
#define IDirectDraw4_FlipToGDISurface(p)             (p)->lpVtbl->FlipToGDISurface(p)
 
1190
#define IDirectDraw4_GetCaps(p, a, b)                (p)->lpVtbl->GetCaps(p, a, b)
 
1191
#define IDirectDraw4_GetDisplayMode(p, a)            (p)->lpVtbl->GetDisplayMode(p, a)
 
1192
#define IDirectDraw4_GetFourCCCodes(p, a, b)         (p)->lpVtbl->GetFourCCCodes(p, a, b)
 
1193
#define IDirectDraw4_GetGDISurface(p, a)             (p)->lpVtbl->GetGDISurface(p, a)
 
1194
#define IDirectDraw4_GetMonitorFrequency(p, a)       (p)->lpVtbl->GetMonitorFrequency(p, a)
 
1195
#define IDirectDraw4_GetScanLine(p, a)               (p)->lpVtbl->GetScanLine(p, a)
 
1196
#define IDirectDraw4_GetVerticalBlankStatus(p, a)    (p)->lpVtbl->GetVerticalBlankStatus(p, a)
 
1197
#define IDirectDraw4_Initialize(p, a)                (p)->lpVtbl->Initialize(p, a)
 
1198
#define IDirectDraw4_RestoreDisplayMode(p)           (p)->lpVtbl->RestoreDisplayMode(p)
 
1199
#define IDirectDraw4_SetCooperativeLevel(p, a, b)    (p)->lpVtbl->SetCooperativeLevel(p, a, b)
 
1200
#define IDirectDraw4_SetDisplayMode(p, a, b, c, d, e) (p)->lpVtbl->SetDisplayMode(p, a, b, c, d, e)
 
1201
#define IDirectDraw4_WaitForVerticalBlank(p, a, b)   (p)->lpVtbl->WaitForVerticalBlank(p, a, b)
 
1202
#define IDirectDraw4_GetAvailableVidMem(p, a, b, c)  (p)->lpVtbl->GetAvailableVidMem(p, a, b, c)
 
1203
#define IDirectDraw4_GetSurfaceFromDC(p, a, b)       (p)->lpVtbl->GetSurfaceFromDC(p, a, b)
 
1204
#define IDirectDraw4_RestoreAllSurfaces(p)           (p)->lpVtbl->RestoreAllSurfaces(p)
 
1205
#define IDirectDraw4_TestCooperativeLevel(p)         (p)->lpVtbl->TestCooperativeLevel(p)
 
1206
#define IDirectDraw4_GetDeviceIdentifier(p,a,b)      (p)->lpVtbl->GetDeviceIdentifier(p,a,b)
 
1207
#else
 
1208
#define IDirectDraw4_QueryInterface(p, a, b)         (p)->QueryInterface(a, b)
 
1209
#define IDirectDraw4_AddRef(p)                       (p)->AddRef()
 
1210
#define IDirectDraw4_Release(p)                      (p)->Release()
 
1211
#define IDirectDraw4_Compact(p)                      (p)->Compact()
 
1212
#define IDirectDraw4_CreateClipper(p, a, b, c)       (p)->CreateClipper(a, b, c)
 
1213
#define IDirectDraw4_CreatePalette(p, a, b, c, d)    (p)->CreatePalette(a, b, c, d)
 
1214
#define IDirectDraw4_CreateSurface(p, a, b, c)       (p)->CreateSurface(a, b, c)
 
1215
#define IDirectDraw4_DuplicateSurface(p, a, b)       (p)->DuplicateSurface(a, b)
 
1216
#define IDirectDraw4_EnumDisplayModes(p, a, b, c, d) (p)->EnumDisplayModes(a, b, c, d)
 
1217
#define IDirectDraw4_EnumSurfaces(p, a, b, c, d)     (p)->EnumSurfaces(a, b, c, d)
 
1218
#define IDirectDraw4_FlipToGDISurface(p)             (p)->FlipToGDISurface()
 
1219
#define IDirectDraw4_GetCaps(p, a, b)                (p)->GetCaps(a, b)
 
1220
#define IDirectDraw4_GetDisplayMode(p, a)            (p)->GetDisplayMode(a)
 
1221
#define IDirectDraw4_GetFourCCCodes(p, a, b)         (p)->GetFourCCCodes(a, b)
 
1222
#define IDirectDraw4_GetGDISurface(p, a)             (p)->GetGDISurface(a)
 
1223
#define IDirectDraw4_GetMonitorFrequency(p, a)       (p)->GetMonitorFrequency(a)
 
1224
#define IDirectDraw4_GetScanLine(p, a)               (p)->GetScanLine(a)
 
1225
#define IDirectDraw4_GetVerticalBlankStatus(p, a)    (p)->GetVerticalBlankStatus(a)
 
1226
#define IDirectDraw4_Initialize(p, a)                (p)->Initialize(a)
 
1227
#define IDirectDraw4_RestoreDisplayMode(p)           (p)->RestoreDisplayMode()
 
1228
#define IDirectDraw4_SetCooperativeLevel(p, a, b)    (p)->SetCooperativeLevel(a, b)
 
1229
#define IDirectDraw4_SetDisplayMode(p, a, b, c, d, e) (p)->SetDisplayMode(a, b, c, d, e)
 
1230
#define IDirectDraw4_WaitForVerticalBlank(p, a, b)   (p)->WaitForVerticalBlank(a, b)
 
1231
#define IDirectDraw4_GetAvailableVidMem(p, a, b, c)  (p)->GetAvailableVidMem(a, b, c)
 
1232
#define IDirectDraw4_GetSurfaceFromDC(p, a, b)       (p)->GetSurfaceFromDC(a, b)
 
1233
#define IDirectDraw4_RestoreAllSurfaces(p)           (p)->RestoreAllSurfaces()
 
1234
#define IDirectDraw4_TestCooperativeLevel(p)         (p)->TestCooperativeLevel()
 
1235
#define IDirectDraw4_GetDeviceIdentifier(p,a,b)      (p)->GetDeviceIdentifier(a,b)
 
1236
#endif
 
1237
 
 
1238
#endif
 
1239
 
 
1240
#if defined( _WIN32 ) && !defined( _NO_COM )
 
1241
#undef INTERFACE
 
1242
#define INTERFACE IDirectDraw7
 
1243
DECLARE_INTERFACE_( IDirectDraw7, IUnknown )
 
1244
{
 
1245
    /*** IUnknown methods ***/
 
1246
    STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE;
 
1247
    STDMETHOD_(ULONG,AddRef) (THIS)  PURE;
 
1248
    STDMETHOD_(ULONG,Release) (THIS) PURE;
 
1249
    /*** IDirectDraw methods ***/
 
1250
    STDMETHOD(Compact)(THIS) PURE;
 
1251
    STDMETHOD(CreateClipper)(THIS_ DWORD, LPDIRECTDRAWCLIPPER FAR*, IUnknown FAR * ) PURE;
 
1252
    STDMETHOD(CreatePalette)(THIS_ DWORD, LPPALETTEENTRY, LPDIRECTDRAWPALETTE FAR*, IUnknown FAR * ) PURE;
 
1253
    STDMETHOD(CreateSurface)(THIS_  LPDDSURFACEDESC2, LPDIRECTDRAWSURFACE7 FAR *, IUnknown FAR *) PURE;
 
1254
    STDMETHOD(DuplicateSurface)( THIS_ LPDIRECTDRAWSURFACE7, LPDIRECTDRAWSURFACE7 FAR * ) PURE;
 
1255
    STDMETHOD(EnumDisplayModes)( THIS_ DWORD, LPDDSURFACEDESC2, LPVOID, LPDDENUMMODESCALLBACK2 ) PURE;
 
1256
    STDMETHOD(EnumSurfaces)(THIS_ DWORD, LPDDSURFACEDESC2, LPVOID,LPDDENUMSURFACESCALLBACK7 ) PURE;
 
1257
    STDMETHOD(FlipToGDISurface)(THIS) PURE;
 
1258
    STDMETHOD(GetCaps)( THIS_ LPDDCAPS, LPDDCAPS) PURE;
 
1259
    STDMETHOD(GetDisplayMode)( THIS_ LPDDSURFACEDESC2) PURE;
 
1260
    STDMETHOD(GetFourCCCodes)(THIS_  LPDWORD, LPDWORD ) PURE;
 
1261
    STDMETHOD(GetGDISurface)(THIS_ LPDIRECTDRAWSURFACE7 FAR *) PURE;
 
1262
    STDMETHOD(GetMonitorFrequency)(THIS_ LPDWORD) PURE;
 
1263
    STDMETHOD(GetScanLine)(THIS_ LPDWORD) PURE;
 
1264
    STDMETHOD(GetVerticalBlankStatus)(THIS_ LPBOOL ) PURE;
 
1265
    STDMETHOD(Initialize)(THIS_ GUID FAR *) PURE;
 
1266
    STDMETHOD(RestoreDisplayMode)(THIS) PURE;
 
1267
    STDMETHOD(SetCooperativeLevel)(THIS_ HWND, DWORD) PURE;
 
1268
    STDMETHOD(SetDisplayMode)(THIS_ DWORD, DWORD,DWORD, DWORD, DWORD) PURE;
 
1269
    STDMETHOD(WaitForVerticalBlank)(THIS_ DWORD, HANDLE ) PURE;
 
1270
    /*** Added in the v2 interface ***/
 
1271
    STDMETHOD(GetAvailableVidMem)(THIS_ LPDDSCAPS2, LPDWORD, LPDWORD) PURE;
 
1272
    /*** Added in the V4 Interface ***/
 
1273
    STDMETHOD(GetSurfaceFromDC) (THIS_ HDC, LPDIRECTDRAWSURFACE7 *) PURE;
 
1274
    STDMETHOD(RestoreAllSurfaces)(THIS) PURE;
 
1275
    STDMETHOD(TestCooperativeLevel)(THIS) PURE;
 
1276
    STDMETHOD(GetDeviceIdentifier)(THIS_ LPDDDEVICEIDENTIFIER2, DWORD ) PURE;
 
1277
    STDMETHOD(StartModeTest)(THIS_ LPSIZE, DWORD, DWORD ) PURE;
 
1278
    STDMETHOD(EvaluateMode)(THIS_ DWORD, DWORD * ) PURE;
 
1279
};
 
1280
#if !defined(__cplusplus) || defined(CINTERFACE)
 
1281
#define IDirectDraw7_QueryInterface(p, a, b)         (p)->lpVtbl->QueryInterface(p, a, b)
 
1282
#define IDirectDraw7_AddRef(p)                       (p)->lpVtbl->AddRef(p)
 
1283
#define IDirectDraw7_Release(p)                      (p)->lpVtbl->Release(p)
 
1284
#define IDirectDraw7_Compact(p)                      (p)->lpVtbl->Compact(p)
 
1285
#define IDirectDraw7_CreateClipper(p, a, b, c)       (p)->lpVtbl->CreateClipper(p, a, b, c)
 
1286
#define IDirectDraw7_CreatePalette(p, a, b, c, d)    (p)->lpVtbl->CreatePalette(p, a, b, c, d)
 
1287
#define IDirectDraw7_CreateSurface(p, a, b, c)       (p)->lpVtbl->CreateSurface(p, a, b, c)
 
1288
#define IDirectDraw7_DuplicateSurface(p, a, b)       (p)->lpVtbl->DuplicateSurface(p, a, b)
 
1289
#define IDirectDraw7_EnumDisplayModes(p, a, b, c, d) (p)->lpVtbl->EnumDisplayModes(p, a, b, c, d)
 
1290
#define IDirectDraw7_EnumSurfaces(p, a, b, c, d)     (p)->lpVtbl->EnumSurfaces(p, a, b, c, d)
 
1291
#define IDirectDraw7_FlipToGDISurface(p)             (p)->lpVtbl->FlipToGDISurface(p)
 
1292
#define IDirectDraw7_GetCaps(p, a, b)                (p)->lpVtbl->GetCaps(p, a, b)
 
1293
#define IDirectDraw7_GetDisplayMode(p, a)            (p)->lpVtbl->GetDisplayMode(p, a)
 
1294
#define IDirectDraw7_GetFourCCCodes(p, a, b)         (p)->lpVtbl->GetFourCCCodes(p, a, b)
 
1295
#define IDirectDraw7_GetGDISurface(p, a)             (p)->lpVtbl->GetGDISurface(p, a)
 
1296
#define IDirectDraw7_GetMonitorFrequency(p, a)       (p)->lpVtbl->GetMonitorFrequency(p, a)
 
1297
#define IDirectDraw7_GetScanLine(p, a)               (p)->lpVtbl->GetScanLine(p, a)
 
1298
#define IDirectDraw7_GetVerticalBlankStatus(p, a)    (p)->lpVtbl->GetVerticalBlankStatus(p, a)
 
1299
#define IDirectDraw7_Initialize(p, a)                (p)->lpVtbl->Initialize(p, a)
 
1300
#define IDirectDraw7_RestoreDisplayMode(p)           (p)->lpVtbl->RestoreDisplayMode(p)
 
1301
#define IDirectDraw7_SetCooperativeLevel(p, a, b)    (p)->lpVtbl->SetCooperativeLevel(p, a, b)
 
1302
#define IDirectDraw7_SetDisplayMode(p, a, b, c, d, e) (p)->lpVtbl->SetDisplayMode(p, a, b, c, d, e)
 
1303
#define IDirectDraw7_WaitForVerticalBlank(p, a, b)   (p)->lpVtbl->WaitForVerticalBlank(p, a, b)
 
1304
#define IDirectDraw7_GetAvailableVidMem(p, a, b, c)  (p)->lpVtbl->GetAvailableVidMem(p, a, b, c)
 
1305
#define IDirectDraw7_GetSurfaceFromDC(p, a, b)       (p)->lpVtbl->GetSurfaceFromDC(p, a, b)
 
1306
#define IDirectDraw7_RestoreAllSurfaces(p)           (p)->lpVtbl->RestoreAllSurfaces(p)
 
1307
#define IDirectDraw7_TestCooperativeLevel(p)         (p)->lpVtbl->TestCooperativeLevel(p)
 
1308
#define IDirectDraw7_GetDeviceIdentifier(p,a,b)      (p)->lpVtbl->GetDeviceIdentifier(p,a,b)
 
1309
#define IDirectDraw7_StartModeTest(p,a,b,c)        (p)->lpVtbl->StartModeTest(p,a,b,c)
 
1310
#define IDirectDraw7_EvaluateMode(p,a,b)           (p)->lpVtbl->EvaluateMode(p,a,b)
 
1311
#else
 
1312
#define IDirectDraw7_QueryInterface(p, a, b)         (p)->QueryInterface(a, b)
 
1313
#define IDirectDraw7_AddRef(p)                       (p)->AddRef()
 
1314
#define IDirectDraw7_Release(p)                      (p)->Release()
 
1315
#define IDirectDraw7_Compact(p)                      (p)->Compact()
 
1316
#define IDirectDraw7_CreateClipper(p, a, b, c)       (p)->CreateClipper(a, b, c)
 
1317
#define IDirectDraw7_CreatePalette(p, a, b, c, d)    (p)->CreatePalette(a, b, c, d)
 
1318
#define IDirectDraw7_CreateSurface(p, a, b, c)       (p)->CreateSurface(a, b, c)
 
1319
#define IDirectDraw7_DuplicateSurface(p, a, b)       (p)->DuplicateSurface(a, b)
 
1320
#define IDirectDraw7_EnumDisplayModes(p, a, b, c, d) (p)->EnumDisplayModes(a, b, c, d)
 
1321
#define IDirectDraw7_EnumSurfaces(p, a, b, c, d)     (p)->EnumSurfaces(a, b, c, d)
 
1322
#define IDirectDraw7_FlipToGDISurface(p)             (p)->FlipToGDISurface()
 
1323
#define IDirectDraw7_GetCaps(p, a, b)                (p)->GetCaps(a, b)
 
1324
#define IDirectDraw7_GetDisplayMode(p, a)            (p)->GetDisplayMode(a)
 
1325
#define IDirectDraw7_GetFourCCCodes(p, a, b)         (p)->GetFourCCCodes(a, b)
 
1326
#define IDirectDraw7_GetGDISurface(p, a)             (p)->GetGDISurface(a)
 
1327
#define IDirectDraw7_GetMonitorFrequency(p, a)       (p)->GetMonitorFrequency(a)
 
1328
#define IDirectDraw7_GetScanLine(p, a)               (p)->GetScanLine(a)
 
1329
#define IDirectDraw7_GetVerticalBlankStatus(p, a)    (p)->GetVerticalBlankStatus(a)
 
1330
#define IDirectDraw7_Initialize(p, a)                (p)->Initialize(a)
 
1331
#define IDirectDraw7_RestoreDisplayMode(p)           (p)->RestoreDisplayMode()
 
1332
#define IDirectDraw7_SetCooperativeLevel(p, a, b)    (p)->SetCooperativeLevel(a, b)
 
1333
#define IDirectDraw7_SetDisplayMode(p, a, b, c, d, e) (p)->SetDisplayMode(a, b, c, d, e)
 
1334
#define IDirectDraw7_WaitForVerticalBlank(p, a, b)   (p)->WaitForVerticalBlank(a, b)
 
1335
#define IDirectDraw7_GetAvailableVidMem(p, a, b, c)  (p)->GetAvailableVidMem(a, b, c)
 
1336
#define IDirectDraw7_GetSurfaceFromDC(p, a, b)       (p)->GetSurfaceFromDC(a, b)
 
1337
#define IDirectDraw7_RestoreAllSurfaces(p)           (p)->RestoreAllSurfaces()
 
1338
#define IDirectDraw7_TestCooperativeLevel(p)         (p)->TestCooperativeLevel()
 
1339
#define IDirectDraw7_GetDeviceIdentifier(p,a,b)      (p)->GetDeviceIdentifier(a,b)
 
1340
#define IDirectDraw7_StartModeTest(p,a,b,c)        (p)->lpVtbl->StartModeTest(a,b,c)
 
1341
#define IDirectDraw7_EvaluateMode(p,a,b)           (p)->lpVtbl->EvaluateMode(a,b)
 
1342
#endif
 
1343
 
 
1344
#endif
 
1345
 
 
1346
 
 
1347
/*
 
1348
 * IDirectDrawPalette
 
1349
 */
 
1350
#if defined( _WIN32 ) && !defined( _NO_COM )
 
1351
#undef INTERFACE
 
1352
#define INTERFACE IDirectDrawPalette
 
1353
DECLARE_INTERFACE_( IDirectDrawPalette, IUnknown )
 
1354
{
 
1355
    /*** IUnknown methods ***/
 
1356
    STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE;
 
1357
    STDMETHOD_(ULONG,AddRef) (THIS)  PURE;
 
1358
    STDMETHOD_(ULONG,Release) (THIS) PURE;
 
1359
    /*** IDirectDrawPalette methods ***/
 
1360
    STDMETHOD(GetCaps)(THIS_ LPDWORD) PURE;
 
1361
    STDMETHOD(GetEntries)(THIS_ DWORD,DWORD,DWORD,LPPALETTEENTRY) PURE;
 
1362
    STDMETHOD(Initialize)(THIS_ LPDIRECTDRAW, DWORD, LPPALETTEENTRY) PURE;
 
1363
    STDMETHOD(SetEntries)(THIS_ DWORD,DWORD,DWORD,LPPALETTEENTRY) PURE;
 
1364
};
 
1365
 
 
1366
#if !defined(__cplusplus) || defined(CINTERFACE)
 
1367
#define IDirectDrawPalette_QueryInterface(p, a, b)      (p)->lpVtbl->QueryInterface(p, a, b)
 
1368
#define IDirectDrawPalette_AddRef(p)                    (p)->lpVtbl->AddRef(p)
 
1369
#define IDirectDrawPalette_Release(p)                   (p)->lpVtbl->Release(p)
 
1370
#define IDirectDrawPalette_GetCaps(p, a)                (p)->lpVtbl->GetCaps(p, a)
 
1371
#define IDirectDrawPalette_GetEntries(p, a, b, c, d)    (p)->lpVtbl->GetEntries(p, a, b, c, d)
 
1372
#define IDirectDrawPalette_Initialize(p, a, b, c)       (p)->lpVtbl->Initialize(p, a, b, c)
 
1373
#define IDirectDrawPalette_SetEntries(p, a, b, c, d)    (p)->lpVtbl->SetEntries(p, a, b, c, d)
 
1374
#else
 
1375
#define IDirectDrawPalette_QueryInterface(p, a, b)      (p)->QueryInterface(a, b)
 
1376
#define IDirectDrawPalette_AddRef(p)                    (p)->AddRef()
 
1377
#define IDirectDrawPalette_Release(p)                   (p)->Release()
 
1378
#define IDirectDrawPalette_GetCaps(p, a)                (p)->GetCaps(a)
 
1379
#define IDirectDrawPalette_GetEntries(p, a, b, c, d)    (p)->GetEntries(a, b, c, d)
 
1380
#define IDirectDrawPalette_Initialize(p, a, b, c)       (p)->Initialize(a, b, c)
 
1381
#define IDirectDrawPalette_SetEntries(p, a, b, c, d)    (p)->SetEntries(a, b, c, d)
 
1382
#endif
 
1383
 
 
1384
#endif
 
1385
 
 
1386
 
 
1387
/*
 
1388
 * IDirectDrawClipper
 
1389
 */
 
1390
#if defined( _WIN32 ) && !defined( _NO_COM )
 
1391
#undef INTERFACE
 
1392
#define INTERFACE IDirectDrawClipper
 
1393
DECLARE_INTERFACE_( IDirectDrawClipper, IUnknown )
 
1394
{
 
1395
    /*** IUnknown methods ***/
 
1396
    STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE;
 
1397
    STDMETHOD_(ULONG,AddRef) (THIS)  PURE;
 
1398
    STDMETHOD_(ULONG,Release) (THIS) PURE;
 
1399
    /*** IDirectDrawClipper methods ***/
 
1400
    STDMETHOD(GetClipList)(THIS_ LPRECT, LPRGNDATA, LPDWORD) PURE;
 
1401
    STDMETHOD(GetHWnd)(THIS_ HWND FAR *) PURE;
 
1402
    STDMETHOD(Initialize)(THIS_ LPDIRECTDRAW, DWORD) PURE;
 
1403
    STDMETHOD(IsClipListChanged)(THIS_ BOOL FAR *) PURE;
 
1404
    STDMETHOD(SetClipList)(THIS_ LPRGNDATA,DWORD) PURE;
 
1405
    STDMETHOD(SetHWnd)(THIS_ DWORD, HWND ) PURE;
 
1406
};
 
1407
 
 
1408
#if !defined(__cplusplus) || defined(CINTERFACE)
 
1409
#define IDirectDrawClipper_QueryInterface(p, a, b)  (p)->lpVtbl->QueryInterface(p, a, b)
 
1410
#define IDirectDrawClipper_AddRef(p)                (p)->lpVtbl->AddRef(p)
 
1411
#define IDirectDrawClipper_Release(p)               (p)->lpVtbl->Release(p)
 
1412
#define IDirectDrawClipper_GetClipList(p, a, b, c)  (p)->lpVtbl->GetClipList(p, a, b, c)
 
1413
#define IDirectDrawClipper_GetHWnd(p, a)            (p)->lpVtbl->GetHWnd(p, a)
 
1414
#define IDirectDrawClipper_Initialize(p, a, b)      (p)->lpVtbl->Initialize(p, a, b)
 
1415
#define IDirectDrawClipper_IsClipListChanged(p, a)  (p)->lpVtbl->IsClipListChanged(p, a)
 
1416
#define IDirectDrawClipper_SetClipList(p, a, b)     (p)->lpVtbl->SetClipList(p, a, b)
 
1417
#define IDirectDrawClipper_SetHWnd(p, a, b)         (p)->lpVtbl->SetHWnd(p, a, b)
 
1418
#else
 
1419
#define IDirectDrawClipper_QueryInterface(p, a, b)  (p)->QueryInterface(a, b)
 
1420
#define IDirectDrawClipper_AddRef(p)                (p)->AddRef()
 
1421
#define IDirectDrawClipper_Release(p)               (p)->Release()
 
1422
#define IDirectDrawClipper_GetClipList(p, a, b, c)  (p)->GetClipList(a, b, c)
 
1423
#define IDirectDrawClipper_GetHWnd(p, a)            (p)->GetHWnd(a)
 
1424
#define IDirectDrawClipper_Initialize(p, a, b)      (p)->Initialize(a, b)
 
1425
#define IDirectDrawClipper_IsClipListChanged(p, a)  (p)->IsClipListChanged(a)
 
1426
#define IDirectDrawClipper_SetClipList(p, a, b)     (p)->SetClipList(a, b)
 
1427
#define IDirectDrawClipper_SetHWnd(p, a, b)         (p)->SetHWnd(a, b)
 
1428
#endif
 
1429
 
 
1430
#endif
 
1431
 
 
1432
/*
 
1433
 * IDirectDrawSurface and related interfaces
 
1434
 */
 
1435
#if defined( _WIN32 ) && !defined( _NO_COM )
 
1436
#undef INTERFACE
 
1437
#define INTERFACE IDirectDrawSurface
 
1438
DECLARE_INTERFACE_( IDirectDrawSurface, IUnknown )
 
1439
{
 
1440
    /*** IUnknown methods ***/
 
1441
    STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE;
 
1442
    STDMETHOD_(ULONG,AddRef) (THIS)  PURE;
 
1443
    STDMETHOD_(ULONG,Release) (THIS) PURE;
 
1444
    /*** IDirectDrawSurface methods ***/
 
1445
    STDMETHOD(AddAttachedSurface)(THIS_ LPDIRECTDRAWSURFACE) PURE;
 
1446
    STDMETHOD(AddOverlayDirtyRect)(THIS_ LPRECT) PURE;
 
1447
    STDMETHOD(Blt)(THIS_ LPRECT,LPDIRECTDRAWSURFACE, LPRECT,DWORD, LPDDBLTFX) PURE;
 
1448
    STDMETHOD(BltBatch)(THIS_ LPDDBLTBATCH, DWORD, DWORD ) PURE;
 
1449
    STDMETHOD(BltFast)(THIS_ DWORD,DWORD,LPDIRECTDRAWSURFACE, LPRECT,DWORD) PURE;
 
1450
    STDMETHOD(DeleteAttachedSurface)(THIS_ DWORD,LPDIRECTDRAWSURFACE) PURE;
 
1451
    STDMETHOD(EnumAttachedSurfaces)(THIS_ LPVOID,LPDDENUMSURFACESCALLBACK) PURE;
 
1452
    STDMETHOD(EnumOverlayZOrders)(THIS_ DWORD,LPVOID,LPDDENUMSURFACESCALLBACK) PURE;
 
1453
    STDMETHOD(Flip)(THIS_ LPDIRECTDRAWSURFACE, DWORD) PURE;
 
1454
    STDMETHOD(GetAttachedSurface)(THIS_ LPDDSCAPS, LPDIRECTDRAWSURFACE FAR *) PURE;
 
1455
    STDMETHOD(GetBltStatus)(THIS_ DWORD) PURE;
 
1456
    STDMETHOD(GetCaps)(THIS_ LPDDSCAPS) PURE;
 
1457
    STDMETHOD(GetClipper)(THIS_ LPDIRECTDRAWCLIPPER FAR*) PURE;
 
1458
    STDMETHOD(GetColorKey)(THIS_ DWORD, LPDDCOLORKEY) PURE;
 
1459
    STDMETHOD(GetDC)(THIS_ HDC FAR *) PURE;
 
1460
    STDMETHOD(GetFlipStatus)(THIS_ DWORD) PURE;
 
1461
    STDMETHOD(GetOverlayPosition)(THIS_ LPLONG, LPLONG ) PURE;
 
1462
    STDMETHOD(GetPalette)(THIS_ LPDIRECTDRAWPALETTE FAR*) PURE;
 
1463
    STDMETHOD(GetPixelFormat)(THIS_ LPDDPIXELFORMAT) PURE;
 
1464
    STDMETHOD(GetSurfaceDesc)(THIS_ LPDDSURFACEDESC) PURE;
 
1465
    STDMETHOD(Initialize)(THIS_ LPDIRECTDRAW, LPDDSURFACEDESC) PURE;
 
1466
    STDMETHOD(IsLost)(THIS) PURE;
 
1467
    STDMETHOD(Lock)(THIS_ LPRECT,LPDDSURFACEDESC,DWORD,HANDLE) PURE;
 
1468
    STDMETHOD(ReleaseDC)(THIS_ HDC) PURE;
 
1469
    STDMETHOD(Restore)(THIS) PURE;
 
1470
    STDMETHOD(SetClipper)(THIS_ LPDIRECTDRAWCLIPPER) PURE;
 
1471
    STDMETHOD(SetColorKey)(THIS_ DWORD, LPDDCOLORKEY) PURE;
 
1472
    STDMETHOD(SetOverlayPosition)(THIS_ LONG, LONG ) PURE;
 
1473
    STDMETHOD(SetPalette)(THIS_ LPDIRECTDRAWPALETTE) PURE;
 
1474
    STDMETHOD(Unlock)(THIS_ LPVOID) PURE;
 
1475
    STDMETHOD(UpdateOverlay)(THIS_ LPRECT, LPDIRECTDRAWSURFACE,LPRECT,DWORD, LPDDOVERLAYFX) PURE;
 
1476
    STDMETHOD(UpdateOverlayDisplay)(THIS_ DWORD) PURE;
 
1477
    STDMETHOD(UpdateOverlayZOrder)(THIS_ DWORD, LPDIRECTDRAWSURFACE) PURE;
 
1478
};
 
1479
 
 
1480
#if !defined(__cplusplus) || defined(CINTERFACE)
 
1481
#define IDirectDrawSurface_QueryInterface(p,a,b)        (p)->lpVtbl->QueryInterface(p,a,b)
 
1482
#define IDirectDrawSurface_AddRef(p)                    (p)->lpVtbl->AddRef(p)
 
1483
#define IDirectDrawSurface_Release(p)                   (p)->lpVtbl->Release(p)
 
1484
#define IDirectDrawSurface_AddAttachedSurface(p,a)      (p)->lpVtbl->AddAttachedSurface(p,a)
 
1485
#define IDirectDrawSurface_AddOverlayDirtyRect(p,a)     (p)->lpVtbl->AddOverlayDirtyRect(p,a)
 
1486
#define IDirectDrawSurface_Blt(p,a,b,c,d,e)             (p)->lpVtbl->Blt(p,a,b,c,d,e)
 
1487
#define IDirectDrawSurface_BltBatch(p,a,b,c)            (p)->lpVtbl->BltBatch(p,a,b,c)
 
1488
#define IDirectDrawSurface_BltFast(p,a,b,c,d,e)         (p)->lpVtbl->BltFast(p,a,b,c,d,e)
 
1489
#define IDirectDrawSurface_DeleteAttachedSurface(p,a,b) (p)->lpVtbl->DeleteAttachedSurface(p,a,b)
 
1490
#define IDirectDrawSurface_EnumAttachedSurfaces(p,a,b)  (p)->lpVtbl->EnumAttachedSurfaces(p,a,b)
 
1491
#define IDirectDrawSurface_EnumOverlayZOrders(p,a,b,c)  (p)->lpVtbl->EnumOverlayZOrders(p,a,b,c)
 
1492
#define IDirectDrawSurface_Flip(p,a,b)                  (p)->lpVtbl->Flip(p,a,b)
 
1493
#define IDirectDrawSurface_GetAttachedSurface(p,a,b)    (p)->lpVtbl->GetAttachedSurface(p,a,b)
 
1494
#define IDirectDrawSurface_GetBltStatus(p,a)            (p)->lpVtbl->GetBltStatus(p,a)
 
1495
#define IDirectDrawSurface_GetCaps(p,b)                 (p)->lpVtbl->GetCaps(p,b)
 
1496
#define IDirectDrawSurface_GetClipper(p,a)              (p)->lpVtbl->GetClipper(p,a)
 
1497
#define IDirectDrawSurface_GetColorKey(p,a,b)           (p)->lpVtbl->GetColorKey(p,a,b)
 
1498
#define IDirectDrawSurface_GetDC(p,a)                   (p)->lpVtbl->GetDC(p,a)
 
1499
#define IDirectDrawSurface_GetFlipStatus(p,a)           (p)->lpVtbl->GetFlipStatus(p,a)
 
1500
#define IDirectDrawSurface_GetOverlayPosition(p,a,b)    (p)->lpVtbl->GetOverlayPosition(p,a,b)
 
1501
#define IDirectDrawSurface_GetPalette(p,a)              (p)->lpVtbl->GetPalette(p,a)
 
1502
#define IDirectDrawSurface_GetPixelFormat(p,a)          (p)->lpVtbl->GetPixelFormat(p,a)
 
1503
#define IDirectDrawSurface_GetSurfaceDesc(p,a)          (p)->lpVtbl->GetSurfaceDesc(p,a)
 
1504
#define IDirectDrawSurface_Initialize(p,a,b)            (p)->lpVtbl->Initialize(p,a,b)
 
1505
#define IDirectDrawSurface_IsLost(p)                    (p)->lpVtbl->IsLost(p)
 
1506
#define IDirectDrawSurface_Lock(p,a,b,c,d)              (p)->lpVtbl->Lock(p,a,b,c,d)
 
1507
#define IDirectDrawSurface_ReleaseDC(p,a)               (p)->lpVtbl->ReleaseDC(p,a)
 
1508
#define IDirectDrawSurface_Restore(p)                   (p)->lpVtbl->Restore(p)
 
1509
#define IDirectDrawSurface_SetClipper(p,a)              (p)->lpVtbl->SetClipper(p,a)
 
1510
#define IDirectDrawSurface_SetColorKey(p,a,b)           (p)->lpVtbl->SetColorKey(p,a,b)
 
1511
#define IDirectDrawSurface_SetOverlayPosition(p,a,b)    (p)->lpVtbl->SetOverlayPosition(p,a,b)
 
1512
#define IDirectDrawSurface_SetPalette(p,a)              (p)->lpVtbl->SetPalette(p,a)
 
1513
#define IDirectDrawSurface_Unlock(p,b)                  (p)->lpVtbl->Unlock(p,b)
 
1514
#define IDirectDrawSurface_UpdateOverlay(p,a,b,c,d,e)   (p)->lpVtbl->UpdateOverlay(p,a,b,c,d,e)
 
1515
#define IDirectDrawSurface_UpdateOverlayDisplay(p,a)    (p)->lpVtbl->UpdateOverlayDisplay(p,a)
 
1516
#define IDirectDrawSurface_UpdateOverlayZOrder(p,a,b)   (p)->lpVtbl->UpdateOverlayZOrder(p,a,b)
 
1517
#else
 
1518
#define IDirectDrawSurface_QueryInterface(p,a,b)        (p)->QueryInterface(a,b)
 
1519
#define IDirectDrawSurface_AddRef(p)                    (p)->AddRef()
 
1520
#define IDirectDrawSurface_Release(p)                   (p)->Release()
 
1521
#define IDirectDrawSurface_AddAttachedSurface(p,a)      (p)->AddAttachedSurface(a)
 
1522
#define IDirectDrawSurface_AddOverlayDirtyRect(p,a)     (p)->AddOverlayDirtyRect(a)
 
1523
#define IDirectDrawSurface_Blt(p,a,b,c,d,e)             (p)->Blt(a,b,c,d,e)
 
1524
#define IDirectDrawSurface_BltBatch(p,a,b,c)            (p)->BltBatch(a,b,c)
 
1525
#define IDirectDrawSurface_BltFast(p,a,b,c,d,e)         (p)->BltFast(a,b,c,d,e)
 
1526
#define IDirectDrawSurface_DeleteAttachedSurface(p,a,b) (p)->DeleteAttachedSurface(a,b)
 
1527
#define IDirectDrawSurface_EnumAttachedSurfaces(p,a,b)  (p)->EnumAttachedSurfaces(a,b)
 
1528
#define IDirectDrawSurface_EnumOverlayZOrders(p,a,b,c)  (p)->EnumOverlayZOrders(a,b,c)
 
1529
#define IDirectDrawSurface_Flip(p,a,b)                  (p)->Flip(a,b)
 
1530
#define IDirectDrawSurface_GetAttachedSurface(p,a,b)    (p)->GetAttachedSurface(a,b)
 
1531
#define IDirectDrawSurface_GetBltStatus(p,a)            (p)->GetBltStatus(a)
 
1532
#define IDirectDrawSurface_GetCaps(p,b)                 (p)->GetCaps(b)
 
1533
#define IDirectDrawSurface_GetClipper(p,a)              (p)->GetClipper(a)
 
1534
#define IDirectDrawSurface_GetColorKey(p,a,b)           (p)->GetColorKey(a,b)
 
1535
#define IDirectDrawSurface_GetDC(p,a)                   (p)->GetDC(a)
 
1536
#define IDirectDrawSurface_GetFlipStatus(p,a)           (p)->GetFlipStatus(a)
 
1537
#define IDirectDrawSurface_GetOverlayPosition(p,a,b)    (p)->GetOverlayPosition(a,b)
 
1538
#define IDirectDrawSurface_GetPalette(p,a)              (p)->GetPalette(a)
 
1539
#define IDirectDrawSurface_GetPixelFormat(p,a)          (p)->GetPixelFormat(a)
 
1540
#define IDirectDrawSurface_GetSurfaceDesc(p,a)          (p)->GetSurfaceDesc(a)
 
1541
#define IDirectDrawSurface_Initialize(p,a,b)            (p)->Initialize(a,b)
 
1542
#define IDirectDrawSurface_IsLost(p)                    (p)->IsLost()
 
1543
#define IDirectDrawSurface_Lock(p,a,b,c,d)              (p)->Lock(a,b,c,d)
 
1544
#define IDirectDrawSurface_ReleaseDC(p,a)               (p)->ReleaseDC(a)
 
1545
#define IDirectDrawSurface_Restore(p)                   (p)->Restore()
 
1546
#define IDirectDrawSurface_SetClipper(p,a)              (p)->SetClipper(a)
 
1547
#define IDirectDrawSurface_SetColorKey(p,a,b)           (p)->SetColorKey(a,b)
 
1548
#define IDirectDrawSurface_SetOverlayPosition(p,a,b)    (p)->SetOverlayPosition(a,b)
 
1549
#define IDirectDrawSurface_SetPalette(p,a)              (p)->SetPalette(a)
 
1550
#define IDirectDrawSurface_Unlock(p,b)                  (p)->Unlock(b)
 
1551
#define IDirectDrawSurface_UpdateOverlay(p,a,b,c,d,e)   (p)->UpdateOverlay(a,b,c,d,e)
 
1552
#define IDirectDrawSurface_UpdateOverlayDisplay(p,a)    (p)->UpdateOverlayDisplay(a)
 
1553
#define IDirectDrawSurface_UpdateOverlayZOrder(p,a,b)   (p)->UpdateOverlayZOrder(a,b)
 
1554
#endif
 
1555
 
 
1556
/*
 
1557
 * IDirectDrawSurface2 and related interfaces
 
1558
 */
 
1559
#undef INTERFACE
 
1560
#define INTERFACE IDirectDrawSurface2
 
1561
DECLARE_INTERFACE_( IDirectDrawSurface2, IUnknown )
 
1562
{
 
1563
    /*** IUnknown methods ***/
 
1564
    STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE;
 
1565
    STDMETHOD_(ULONG,AddRef) (THIS)  PURE;
 
1566
    STDMETHOD_(ULONG,Release) (THIS) PURE;
 
1567
    /*** IDirectDrawSurface methods ***/
 
1568
    STDMETHOD(AddAttachedSurface)(THIS_ LPDIRECTDRAWSURFACE2) PURE;
 
1569
    STDMETHOD(AddOverlayDirtyRect)(THIS_ LPRECT) PURE;
 
1570
    STDMETHOD(Blt)(THIS_ LPRECT,LPDIRECTDRAWSURFACE2, LPRECT,DWORD, LPDDBLTFX) PURE;
 
1571
    STDMETHOD(BltBatch)(THIS_ LPDDBLTBATCH, DWORD, DWORD ) PURE;
 
1572
    STDMETHOD(BltFast)(THIS_ DWORD,DWORD,LPDIRECTDRAWSURFACE2, LPRECT,DWORD) PURE;
 
1573
    STDMETHOD(DeleteAttachedSurface)(THIS_ DWORD,LPDIRECTDRAWSURFACE2) PURE;
 
1574
    STDMETHOD(EnumAttachedSurfaces)(THIS_ LPVOID,LPDDENUMSURFACESCALLBACK) PURE;
 
1575
    STDMETHOD(EnumOverlayZOrders)(THIS_ DWORD,LPVOID,LPDDENUMSURFACESCALLBACK) PURE;
 
1576
    STDMETHOD(Flip)(THIS_ LPDIRECTDRAWSURFACE2, DWORD) PURE;
 
1577
    STDMETHOD(GetAttachedSurface)(THIS_ LPDDSCAPS, LPDIRECTDRAWSURFACE2 FAR *) PURE;
 
1578
    STDMETHOD(GetBltStatus)(THIS_ DWORD) PURE;
 
1579
    STDMETHOD(GetCaps)(THIS_ LPDDSCAPS) PURE;
 
1580
    STDMETHOD(GetClipper)(THIS_ LPDIRECTDRAWCLIPPER FAR*) PURE;
 
1581
    STDMETHOD(GetColorKey)(THIS_ DWORD, LPDDCOLORKEY) PURE;
 
1582
    STDMETHOD(GetDC)(THIS_ HDC FAR *) PURE;
 
1583
    STDMETHOD(GetFlipStatus)(THIS_ DWORD) PURE;
 
1584
    STDMETHOD(GetOverlayPosition)(THIS_ LPLONG, LPLONG ) PURE;
 
1585
    STDMETHOD(GetPalette)(THIS_ LPDIRECTDRAWPALETTE FAR*) PURE;
 
1586
    STDMETHOD(GetPixelFormat)(THIS_ LPDDPIXELFORMAT) PURE;
 
1587
    STDMETHOD(GetSurfaceDesc)(THIS_ LPDDSURFACEDESC) PURE;
 
1588
    STDMETHOD(Initialize)(THIS_ LPDIRECTDRAW, LPDDSURFACEDESC) PURE;
 
1589
    STDMETHOD(IsLost)(THIS) PURE;
 
1590
    STDMETHOD(Lock)(THIS_ LPRECT,LPDDSURFACEDESC,DWORD,HANDLE) PURE;
 
1591
    STDMETHOD(ReleaseDC)(THIS_ HDC) PURE;
 
1592
    STDMETHOD(Restore)(THIS) PURE;
 
1593
    STDMETHOD(SetClipper)(THIS_ LPDIRECTDRAWCLIPPER) PURE;
 
1594
    STDMETHOD(SetColorKey)(THIS_ DWORD, LPDDCOLORKEY) PURE;
 
1595
    STDMETHOD(SetOverlayPosition)(THIS_ LONG, LONG ) PURE;
 
1596
    STDMETHOD(SetPalette)(THIS_ LPDIRECTDRAWPALETTE) PURE;
 
1597
    STDMETHOD(Unlock)(THIS_ LPVOID) PURE;
 
1598
    STDMETHOD(UpdateOverlay)(THIS_ LPRECT, LPDIRECTDRAWSURFACE2,LPRECT,DWORD, LPDDOVERLAYFX) PURE;
 
1599
    STDMETHOD(UpdateOverlayDisplay)(THIS_ DWORD) PURE;
 
1600
    STDMETHOD(UpdateOverlayZOrder)(THIS_ DWORD, LPDIRECTDRAWSURFACE2) PURE;
 
1601
    /*** Added in the v2 interface ***/
 
1602
    STDMETHOD(GetDDInterface)(THIS_ LPVOID FAR *) PURE;
 
1603
    STDMETHOD(PageLock)(THIS_ DWORD) PURE;
 
1604
    STDMETHOD(PageUnlock)(THIS_ DWORD) PURE;
 
1605
};
 
1606
 
 
1607
#if !defined(__cplusplus) || defined(CINTERFACE)
 
1608
#define IDirectDrawSurface2_QueryInterface(p,a,b)        (p)->lpVtbl->QueryInterface(p,a,b)
 
1609
#define IDirectDrawSurface2_AddRef(p)                    (p)->lpVtbl->AddRef(p)
 
1610
#define IDirectDrawSurface2_Release(p)                   (p)->lpVtbl->Release(p)
 
1611
#define IDirectDrawSurface2_AddAttachedSurface(p,a)      (p)->lpVtbl->AddAttachedSurface(p,a)
 
1612
#define IDirectDrawSurface2_AddOverlayDirtyRect(p,a)     (p)->lpVtbl->AddOverlayDirtyRect(p,a)
 
1613
#define IDirectDrawSurface2_Blt(p,a,b,c,d,e)             (p)->lpVtbl->Blt(p,a,b,c,d,e)
 
1614
#define IDirectDrawSurface2_BltBatch(p,a,b,c)            (p)->lpVtbl->BltBatch(p,a,b,c)
 
1615
#define IDirectDrawSurface2_BltFast(p,a,b,c,d,e)         (p)->lpVtbl->BltFast(p,a,b,c,d,e)
 
1616
#define IDirectDrawSurface2_DeleteAttachedSurface(p,a,b) (p)->lpVtbl->DeleteAttachedSurface(p,a,b)
 
1617
#define IDirectDrawSurface2_EnumAttachedSurfaces(p,a,b)  (p)->lpVtbl->EnumAttachedSurfaces(p,a,b)
 
1618
#define IDirectDrawSurface2_EnumOverlayZOrders(p,a,b,c)  (p)->lpVtbl->EnumOverlayZOrders(p,a,b,c)
 
1619
#define IDirectDrawSurface2_Flip(p,a,b)                  (p)->lpVtbl->Flip(p,a,b)
 
1620
#define IDirectDrawSurface2_GetAttachedSurface(p,a,b)    (p)->lpVtbl->GetAttachedSurface(p,a,b)
 
1621
#define IDirectDrawSurface2_GetBltStatus(p,a)            (p)->lpVtbl->GetBltStatus(p,a)
 
1622
#define IDirectDrawSurface2_GetCaps(p,b)                 (p)->lpVtbl->GetCaps(p,b)
 
1623
#define IDirectDrawSurface2_GetClipper(p,a)              (p)->lpVtbl->GetClipper(p,a)
 
1624
#define IDirectDrawSurface2_GetColorKey(p,a,b)           (p)->lpVtbl->GetColorKey(p,a,b)
 
1625
#define IDirectDrawSurface2_GetDC(p,a)                   (p)->lpVtbl->GetDC(p,a)
 
1626
#define IDirectDrawSurface2_GetFlipStatus(p,a)           (p)->lpVtbl->GetFlipStatus(p,a)
 
1627
#define IDirectDrawSurface2_GetOverlayPosition(p,a,b)    (p)->lpVtbl->GetOverlayPosition(p,a,b)
 
1628
#define IDirectDrawSurface2_GetPalette(p,a)              (p)->lpVtbl->GetPalette(p,a)
 
1629
#define IDirectDrawSurface2_GetPixelFormat(p,a)          (p)->lpVtbl->GetPixelFormat(p,a)
 
1630
#define IDirectDrawSurface2_GetSurfaceDesc(p,a)          (p)->lpVtbl->GetSurfaceDesc(p,a)
 
1631
#define IDirectDrawSurface2_Initialize(p,a,b)            (p)->lpVtbl->Initialize(p,a,b)
 
1632
#define IDirectDrawSurface2_IsLost(p)                    (p)->lpVtbl->IsLost(p)
 
1633
#define IDirectDrawSurface2_Lock(p,a,b,c,d)              (p)->lpVtbl->Lock(p,a,b,c,d)
 
1634
#define IDirectDrawSurface2_ReleaseDC(p,a)               (p)->lpVtbl->ReleaseDC(p,a)
 
1635
#define IDirectDrawSurface2_Restore(p)                   (p)->lpVtbl->Restore(p)
 
1636
#define IDirectDrawSurface2_SetClipper(p,a)              (p)->lpVtbl->SetClipper(p,a)
 
1637
#define IDirectDrawSurface2_SetColorKey(p,a,b)           (p)->lpVtbl->SetColorKey(p,a,b)
 
1638
#define IDirectDrawSurface2_SetOverlayPosition(p,a,b)    (p)->lpVtbl->SetOverlayPosition(p,a,b)
 
1639
#define IDirectDrawSurface2_SetPalette(p,a)              (p)->lpVtbl->SetPalette(p,a)
 
1640
#define IDirectDrawSurface2_Unlock(p,b)                  (p)->lpVtbl->Unlock(p,b)
 
1641
#define IDirectDrawSurface2_UpdateOverlay(p,a,b,c,d,e)   (p)->lpVtbl->UpdateOverlay(p,a,b,c,d,e)
 
1642
#define IDirectDrawSurface2_UpdateOverlayDisplay(p,a)    (p)->lpVtbl->UpdateOverlayDisplay(p,a)
 
1643
#define IDirectDrawSurface2_UpdateOverlayZOrder(p,a,b)   (p)->lpVtbl->UpdateOverlayZOrder(p,a,b)
 
1644
#define IDirectDrawSurface2_GetDDInterface(p,a)          (p)->lpVtbl->GetDDInterface(p,a)
 
1645
#define IDirectDrawSurface2_PageLock(p,a)                (p)->lpVtbl->PageLock(p,a)
 
1646
#define IDirectDrawSurface2_PageUnlock(p,a)              (p)->lpVtbl->PageUnlock(p,a)
 
1647
#else
 
1648
#define IDirectDrawSurface2_QueryInterface(p,a,b)        (p)->QueryInterface(a,b)
 
1649
#define IDirectDrawSurface2_AddRef(p)                    (p)->AddRef()
 
1650
#define IDirectDrawSurface2_Release(p)                   (p)->Release()
 
1651
#define IDirectDrawSurface2_AddAttachedSurface(p,a)      (p)->AddAttachedSurface(a)
 
1652
#define IDirectDrawSurface2_AddOverlayDirtyRect(p,a)     (p)->AddOverlayDirtyRect(a)
 
1653
#define IDirectDrawSurface2_Blt(p,a,b,c,d,e)             (p)->Blt(a,b,c,d,e)
 
1654
#define IDirectDrawSurface2_BltBatch(p,a,b,c)            (p)->BltBatch(a,b,c)
 
1655
#define IDirectDrawSurface2_BltFast(p,a,b,c,d,e)         (p)->BltFast(a,b,c,d,e)
 
1656
#define IDirectDrawSurface2_DeleteAttachedSurface(p,a,b) (p)->DeleteAttachedSurface(a,b)
 
1657
#define IDirectDrawSurface2_EnumAttachedSurfaces(p,a,b)  (p)->EnumAttachedSurfaces(a,b)
 
1658
#define IDirectDrawSurface2_EnumOverlayZOrders(p,a,b,c)  (p)->EnumOverlayZOrders(a,b,c)
 
1659
#define IDirectDrawSurface2_Flip(p,a,b)                  (p)->Flip(a,b)
 
1660
#define IDirectDrawSurface2_GetAttachedSurface(p,a,b)    (p)->GetAttachedSurface(a,b)
 
1661
#define IDirectDrawSurface2_GetBltStatus(p,a)            (p)->GetBltStatus(a)
 
1662
#define IDirectDrawSurface2_GetCaps(p,b)                 (p)->GetCaps(b)
 
1663
#define IDirectDrawSurface2_GetClipper(p,a)              (p)->GetClipper(a)
 
1664
#define IDirectDrawSurface2_GetColorKey(p,a,b)           (p)->GetColorKey(a,b)
 
1665
#define IDirectDrawSurface2_GetDC(p,a)                   (p)->GetDC(a)
 
1666
#define IDirectDrawSurface2_GetFlipStatus(p,a)           (p)->GetFlipStatus(a)
 
1667
#define IDirectDrawSurface2_GetOverlayPosition(p,a,b)    (p)->GetOverlayPosition(a,b)
 
1668
#define IDirectDrawSurface2_GetPalette(p,a)              (p)->GetPalette(a)
 
1669
#define IDirectDrawSurface2_GetPixelFormat(p,a)          (p)->GetPixelFormat(a)
 
1670
#define IDirectDrawSurface2_GetSurfaceDesc(p,a)          (p)->GetSurfaceDesc(a)
 
1671
#define IDirectDrawSurface2_Initialize(p,a,b)            (p)->Initialize(a,b)
 
1672
#define IDirectDrawSurface2_IsLost(p)                    (p)->IsLost()
 
1673
#define IDirectDrawSurface2_Lock(p,a,b,c,d)              (p)->Lock(a,b,c,d)
 
1674
#define IDirectDrawSurface2_ReleaseDC(p,a)               (p)->ReleaseDC(a)
 
1675
#define IDirectDrawSurface2_Restore(p)                   (p)->Restore()
 
1676
#define IDirectDrawSurface2_SetClipper(p,a)              (p)->SetClipper(a)
 
1677
#define IDirectDrawSurface2_SetColorKey(p,a,b)           (p)->SetColorKey(a,b)
 
1678
#define IDirectDrawSurface2_SetOverlayPosition(p,a,b)    (p)->SetOverlayPosition(a,b)
 
1679
#define IDirectDrawSurface2_SetPalette(p,a)              (p)->SetPalette(a)
 
1680
#define IDirectDrawSurface2_Unlock(p,b)                  (p)->Unlock(b)
 
1681
#define IDirectDrawSurface2_UpdateOverlay(p,a,b,c,d,e)   (p)->UpdateOverlay(a,b,c,d,e)
 
1682
#define IDirectDrawSurface2_UpdateOverlayDisplay(p,a)    (p)->UpdateOverlayDisplay(a)
 
1683
#define IDirectDrawSurface2_UpdateOverlayZOrder(p,a,b)   (p)->UpdateOverlayZOrder(a,b)
 
1684
#define IDirectDrawSurface2_GetDDInterface(p,a)          (p)->GetDDInterface(a)
 
1685
#define IDirectDrawSurface2_PageLock(p,a)                (p)->PageLock(a)
 
1686
#define IDirectDrawSurface2_PageUnlock(p,a)              (p)->PageUnlock(a)
 
1687
#endif
 
1688
 
 
1689
/*
 
1690
 * IDirectDrawSurface3 and related interfaces
 
1691
 */
 
1692
#undef INTERFACE
 
1693
#define INTERFACE IDirectDrawSurface3
 
1694
DECLARE_INTERFACE_( IDirectDrawSurface3, IUnknown )
 
1695
{
 
1696
    /*** IUnknown methods ***/
 
1697
    STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE;
 
1698
    STDMETHOD_(ULONG,AddRef) (THIS)  PURE;
 
1699
    STDMETHOD_(ULONG,Release) (THIS) PURE;
 
1700
    /*** IDirectDrawSurface methods ***/
 
1701
    STDMETHOD(AddAttachedSurface)(THIS_ LPDIRECTDRAWSURFACE3) PURE;
 
1702
    STDMETHOD(AddOverlayDirtyRect)(THIS_ LPRECT) PURE;
 
1703
    STDMETHOD(Blt)(THIS_ LPRECT,LPDIRECTDRAWSURFACE3, LPRECT,DWORD, LPDDBLTFX) PURE;
 
1704
    STDMETHOD(BltBatch)(THIS_ LPDDBLTBATCH, DWORD, DWORD ) PURE;
 
1705
    STDMETHOD(BltFast)(THIS_ DWORD,DWORD,LPDIRECTDRAWSURFACE3, LPRECT,DWORD) PURE;
 
1706
    STDMETHOD(DeleteAttachedSurface)(THIS_ DWORD,LPDIRECTDRAWSURFACE3) PURE;
 
1707
    STDMETHOD(EnumAttachedSurfaces)(THIS_ LPVOID,LPDDENUMSURFACESCALLBACK) PURE;
 
1708
    STDMETHOD(EnumOverlayZOrders)(THIS_ DWORD,LPVOID,LPDDENUMSURFACESCALLBACK) PURE;
 
1709
    STDMETHOD(Flip)(THIS_ LPDIRECTDRAWSURFACE3, DWORD) PURE;
 
1710
    STDMETHOD(GetAttachedSurface)(THIS_ LPDDSCAPS, LPDIRECTDRAWSURFACE3 FAR *) PURE;
 
1711
    STDMETHOD(GetBltStatus)(THIS_ DWORD) PURE;
 
1712
    STDMETHOD(GetCaps)(THIS_ LPDDSCAPS) PURE;
 
1713
    STDMETHOD(GetClipper)(THIS_ LPDIRECTDRAWCLIPPER FAR*) PURE;
 
1714
    STDMETHOD(GetColorKey)(THIS_ DWORD, LPDDCOLORKEY) PURE;
 
1715
    STDMETHOD(GetDC)(THIS_ HDC FAR *) PURE;
 
1716
    STDMETHOD(GetFlipStatus)(THIS_ DWORD) PURE;
 
1717
    STDMETHOD(GetOverlayPosition)(THIS_ LPLONG, LPLONG ) PURE;
 
1718
    STDMETHOD(GetPalette)(THIS_ LPDIRECTDRAWPALETTE FAR*) PURE;
 
1719
    STDMETHOD(GetPixelFormat)(THIS_ LPDDPIXELFORMAT) PURE;
 
1720
    STDMETHOD(GetSurfaceDesc)(THIS_ LPDDSURFACEDESC) PURE;
 
1721
    STDMETHOD(Initialize)(THIS_ LPDIRECTDRAW, LPDDSURFACEDESC) PURE;
 
1722
    STDMETHOD(IsLost)(THIS) PURE;
 
1723
    STDMETHOD(Lock)(THIS_ LPRECT,LPDDSURFACEDESC,DWORD,HANDLE) PURE;
 
1724
    STDMETHOD(ReleaseDC)(THIS_ HDC) PURE;
 
1725
    STDMETHOD(Restore)(THIS) PURE;
 
1726
    STDMETHOD(SetClipper)(THIS_ LPDIRECTDRAWCLIPPER) PURE;
 
1727
    STDMETHOD(SetColorKey)(THIS_ DWORD, LPDDCOLORKEY) PURE;
 
1728
    STDMETHOD(SetOverlayPosition)(THIS_ LONG, LONG ) PURE;
 
1729
    STDMETHOD(SetPalette)(THIS_ LPDIRECTDRAWPALETTE) PURE;
 
1730
    STDMETHOD(Unlock)(THIS_ LPVOID) PURE;
 
1731
    STDMETHOD(UpdateOverlay)(THIS_ LPRECT, LPDIRECTDRAWSURFACE3,LPRECT,DWORD, LPDDOVERLAYFX) PURE;
 
1732
    STDMETHOD(UpdateOverlayDisplay)(THIS_ DWORD) PURE;
 
1733
    STDMETHOD(UpdateOverlayZOrder)(THIS_ DWORD, LPDIRECTDRAWSURFACE3) PURE;
 
1734
    /*** Added in the v2 interface ***/
 
1735
    STDMETHOD(GetDDInterface)(THIS_ LPVOID FAR *) PURE;
 
1736
    STDMETHOD(PageLock)(THIS_ DWORD) PURE;
 
1737
    STDMETHOD(PageUnlock)(THIS_ DWORD) PURE;
 
1738
    /*** Added in the V3 interface ***/
 
1739
    STDMETHOD(SetSurfaceDesc)(THIS_ LPDDSURFACEDESC, DWORD) PURE;
 
1740
};
 
1741
 
 
1742
#if !defined(__cplusplus) || defined(CINTERFACE)
 
1743
#define IDirectDrawSurface3_QueryInterface(p,a,b)        (p)->lpVtbl->QueryInterface(p,a,b)
 
1744
#define IDirectDrawSurface3_AddRef(p)                    (p)->lpVtbl->AddRef(p)
 
1745
#define IDirectDrawSurface3_Release(p)                   (p)->lpVtbl->Release(p)
 
1746
#define IDirectDrawSurface3_AddAttachedSurface(p,a)      (p)->lpVtbl->AddAttachedSurface(p,a)
 
1747
#define IDirectDrawSurface3_AddOverlayDirtyRect(p,a)     (p)->lpVtbl->AddOverlayDirtyRect(p,a)
 
1748
#define IDirectDrawSurface3_Blt(p,a,b,c,d,e)             (p)->lpVtbl->Blt(p,a,b,c,d,e)
 
1749
#define IDirectDrawSurface3_BltBatch(p,a,b,c)            (p)->lpVtbl->BltBatch(p,a,b,c)
 
1750
#define IDirectDrawSurface3_BltFast(p,a,b,c,d,e)         (p)->lpVtbl->BltFast(p,a,b,c,d,e)
 
1751
#define IDirectDrawSurface3_DeleteAttachedSurface(p,a,b) (p)->lpVtbl->DeleteAttachedSurface(p,a,b)
 
1752
#define IDirectDrawSurface3_EnumAttachedSurfaces(p,a,b)  (p)->lpVtbl->EnumAttachedSurfaces(p,a,b)
 
1753
#define IDirectDrawSurface3_EnumOverlayZOrders(p,a,b,c)  (p)->lpVtbl->EnumOverlayZOrders(p,a,b,c)
 
1754
#define IDirectDrawSurface3_Flip(p,a,b)                  (p)->lpVtbl->Flip(p,a,b)
 
1755
#define IDirectDrawSurface3_GetAttachedSurface(p,a,b)    (p)->lpVtbl->GetAttachedSurface(p,a,b)
 
1756
#define IDirectDrawSurface3_GetBltStatus(p,a)            (p)->lpVtbl->GetBltStatus(p,a)
 
1757
#define IDirectDrawSurface3_GetCaps(p,b)                 (p)->lpVtbl->GetCaps(p,b)
 
1758
#define IDirectDrawSurface3_GetClipper(p,a)              (p)->lpVtbl->GetClipper(p,a)
 
1759
#define IDirectDrawSurface3_GetColorKey(p,a,b)           (p)->lpVtbl->GetColorKey(p,a,b)
 
1760
#define IDirectDrawSurface3_GetDC(p,a)                   (p)->lpVtbl->GetDC(p,a)
 
1761
#define IDirectDrawSurface3_GetFlipStatus(p,a)           (p)->lpVtbl->GetFlipStatus(p,a)
 
1762
#define IDirectDrawSurface3_GetOverlayPosition(p,a,b)    (p)->lpVtbl->GetOverlayPosition(p,a,b)
 
1763
#define IDirectDrawSurface3_GetPalette(p,a)              (p)->lpVtbl->GetPalette(p,a)
 
1764
#define IDirectDrawSurface3_GetPixelFormat(p,a)          (p)->lpVtbl->GetPixelFormat(p,a)
 
1765
#define IDirectDrawSurface3_GetSurfaceDesc(p,a)          (p)->lpVtbl->GetSurfaceDesc(p,a)
 
1766
#define IDirectDrawSurface3_Initialize(p,a,b)            (p)->lpVtbl->Initialize(p,a,b)
 
1767
#define IDirectDrawSurface3_IsLost(p)                    (p)->lpVtbl->IsLost(p)
 
1768
#define IDirectDrawSurface3_Lock(p,a,b,c,d)              (p)->lpVtbl->Lock(p,a,b,c,d)
 
1769
#define IDirectDrawSurface3_ReleaseDC(p,a)               (p)->lpVtbl->ReleaseDC(p,a)
 
1770
#define IDirectDrawSurface3_Restore(p)                   (p)->lpVtbl->Restore(p)
 
1771
#define IDirectDrawSurface3_SetClipper(p,a)              (p)->lpVtbl->SetClipper(p,a)
 
1772
#define IDirectDrawSurface3_SetColorKey(p,a,b)           (p)->lpVtbl->SetColorKey(p,a,b)
 
1773
#define IDirectDrawSurface3_SetOverlayPosition(p,a,b)    (p)->lpVtbl->SetOverlayPosition(p,a,b)
 
1774
#define IDirectDrawSurface3_SetPalette(p,a)              (p)->lpVtbl->SetPalette(p,a)
 
1775
#define IDirectDrawSurface3_Unlock(p,b)                  (p)->lpVtbl->Unlock(p,b)
 
1776
#define IDirectDrawSurface3_UpdateOverlay(p,a,b,c,d,e)   (p)->lpVtbl->UpdateOverlay(p,a,b,c,d,e)
 
1777
#define IDirectDrawSurface3_UpdateOverlayDisplay(p,a)    (p)->lpVtbl->UpdateOverlayDisplay(p,a)
 
1778
#define IDirectDrawSurface3_UpdateOverlayZOrder(p,a,b)   (p)->lpVtbl->UpdateOverlayZOrder(p,a,b)
 
1779
#define IDirectDrawSurface3_GetDDInterface(p,a)          (p)->lpVtbl->GetDDInterface(p,a)
 
1780
#define IDirectDrawSurface3_PageLock(p,a)                (p)->lpVtbl->PageLock(p,a)
 
1781
#define IDirectDrawSurface3_PageUnlock(p,a)              (p)->lpVtbl->PageUnlock(p,a)
 
1782
#define IDirectDrawSurface3_SetSurfaceDesc(p,a,b)        (p)->lpVtbl->SetSurfaceDesc(p,a,b)
 
1783
#else
 
1784
#define IDirectDrawSurface3_QueryInterface(p,a,b)        (p)->QueryInterface(a,b)
 
1785
#define IDirectDrawSurface3_AddRef(p)                    (p)->AddRef()
 
1786
#define IDirectDrawSurface3_Release(p)                   (p)->Release()
 
1787
#define IDirectDrawSurface3_AddAttachedSurface(p,a)      (p)->AddAttachedSurface(a)
 
1788
#define IDirectDrawSurface3_AddOverlayDirtyRect(p,a)     (p)->AddOverlayDirtyRect(a)
 
1789
#define IDirectDrawSurface3_Blt(p,a,b,c,d,e)             (p)->Blt(a,b,c,d,e)
 
1790
#define IDirectDrawSurface3_BltBatch(p,a,b,c)            (p)->BltBatch(a,b,c)
 
1791
#define IDirectDrawSurface3_BltFast(p,a,b,c,d,e)         (p)->BltFast(a,b,c,d,e)
 
1792
#define IDirectDrawSurface3_DeleteAttachedSurface(p,a,b) (p)->DeleteAttachedSurface(a,b)
 
1793
#define IDirectDrawSurface3_EnumAttachedSurfaces(p,a,b)  (p)->EnumAttachedSurfaces(a,b)
 
1794
#define IDirectDrawSurface3_EnumOverlayZOrders(p,a,b,c)  (p)->EnumOverlayZOrders(a,b,c)
 
1795
#define IDirectDrawSurface3_Flip(p,a,b)                  (p)->Flip(a,b)
 
1796
#define IDirectDrawSurface3_GetAttachedSurface(p,a,b)    (p)->GetAttachedSurface(a,b)
 
1797
#define IDirectDrawSurface3_GetBltStatus(p,a)            (p)->GetBltStatus(a)
 
1798
#define IDirectDrawSurface3_GetCaps(p,b)                 (p)->GetCaps(b)
 
1799
#define IDirectDrawSurface3_GetClipper(p,a)              (p)->GetClipper(a)
 
1800
#define IDirectDrawSurface3_GetColorKey(p,a,b)           (p)->GetColorKey(a,b)
 
1801
#define IDirectDrawSurface3_GetDC(p,a)                   (p)->GetDC(a)
 
1802
#define IDirectDrawSurface3_GetFlipStatus(p,a)           (p)->GetFlipStatus(a)
 
1803
#define IDirectDrawSurface3_GetOverlayPosition(p,a,b)    (p)->GetOverlayPosition(a,b)
 
1804
#define IDirectDrawSurface3_GetPalette(p,a)              (p)->GetPalette(a)
 
1805
#define IDirectDrawSurface3_GetPixelFormat(p,a)          (p)->GetPixelFormat(a)
 
1806
#define IDirectDrawSurface3_GetSurfaceDesc(p,a)          (p)->GetSurfaceDesc(a)
 
1807
#define IDirectDrawSurface3_Initialize(p,a,b)            (p)->Initialize(a,b)
 
1808
#define IDirectDrawSurface3_IsLost(p)                    (p)->IsLost()
 
1809
#define IDirectDrawSurface3_Lock(p,a,b,c,d)              (p)->Lock(a,b,c,d)
 
1810
#define IDirectDrawSurface3_ReleaseDC(p,a)               (p)->ReleaseDC(a)
 
1811
#define IDirectDrawSurface3_Restore(p)                   (p)->Restore()
 
1812
#define IDirectDrawSurface3_SetClipper(p,a)              (p)->SetClipper(a)
 
1813
#define IDirectDrawSurface3_SetColorKey(p,a,b)           (p)->SetColorKey(a,b)
 
1814
#define IDirectDrawSurface3_SetOverlayPosition(p,a,b)    (p)->SetOverlayPosition(a,b)
 
1815
#define IDirectDrawSurface3_SetPalette(p,a)              (p)->SetPalette(a)
 
1816
#define IDirectDrawSurface3_Unlock(p,b)                  (p)->Unlock(b)
 
1817
#define IDirectDrawSurface3_UpdateOverlay(p,a,b,c,d,e)   (p)->UpdateOverlay(a,b,c,d,e)
 
1818
#define IDirectDrawSurface3_UpdateOverlayDisplay(p,a)    (p)->UpdateOverlayDisplay(a)
 
1819
#define IDirectDrawSurface3_UpdateOverlayZOrder(p,a,b)   (p)->UpdateOverlayZOrder(a,b)
 
1820
#define IDirectDrawSurface3_GetDDInterface(p,a)          (p)->GetDDInterface(a)
 
1821
#define IDirectDrawSurface3_PageLock(p,a)                (p)->PageLock(a)
 
1822
#define IDirectDrawSurface3_PageUnlock(p,a)              (p)->PageUnlock(a)
 
1823
#define IDirectDrawSurface3_SetSurfaceDesc(p,a,b)        (p)->SetSurfaceDesc(a,b)
 
1824
#endif
 
1825
 
 
1826
/*
 
1827
 * IDirectDrawSurface4 and related interfaces
 
1828
 */
 
1829
#undef INTERFACE
 
1830
#define INTERFACE IDirectDrawSurface4
 
1831
DECLARE_INTERFACE_( IDirectDrawSurface4, IUnknown )
 
1832
{
 
1833
    /*** IUnknown methods ***/
 
1834
    STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE;
 
1835
    STDMETHOD_(ULONG,AddRef) (THIS)  PURE;
 
1836
    STDMETHOD_(ULONG,Release) (THIS) PURE;
 
1837
    /*** IDirectDrawSurface methods ***/
 
1838
    STDMETHOD(AddAttachedSurface)(THIS_ LPDIRECTDRAWSURFACE4) PURE;
 
1839
    STDMETHOD(AddOverlayDirtyRect)(THIS_ LPRECT) PURE;
 
1840
    STDMETHOD(Blt)(THIS_ LPRECT,LPDIRECTDRAWSURFACE4, LPRECT,DWORD, LPDDBLTFX) PURE;
 
1841
    STDMETHOD(BltBatch)(THIS_ LPDDBLTBATCH, DWORD, DWORD ) PURE;
 
1842
    STDMETHOD(BltFast)(THIS_ DWORD,DWORD,LPDIRECTDRAWSURFACE4, LPRECT,DWORD) PURE;
 
1843
    STDMETHOD(DeleteAttachedSurface)(THIS_ DWORD,LPDIRECTDRAWSURFACE4) PURE;
 
1844
    STDMETHOD(EnumAttachedSurfaces)(THIS_ LPVOID,LPDDENUMSURFACESCALLBACK2) PURE;
 
1845
    STDMETHOD(EnumOverlayZOrders)(THIS_ DWORD,LPVOID,LPDDENUMSURFACESCALLBACK2) PURE;
 
1846
    STDMETHOD(Flip)(THIS_ LPDIRECTDRAWSURFACE4, DWORD) PURE;
 
1847
    STDMETHOD(GetAttachedSurface)(THIS_ LPDDSCAPS2, LPDIRECTDRAWSURFACE4 FAR *) PURE;
 
1848
    STDMETHOD(GetBltStatus)(THIS_ DWORD) PURE;
 
1849
    STDMETHOD(GetCaps)(THIS_ LPDDSCAPS2) PURE;
 
1850
    STDMETHOD(GetClipper)(THIS_ LPDIRECTDRAWCLIPPER FAR*) PURE;
 
1851
    STDMETHOD(GetColorKey)(THIS_ DWORD, LPDDCOLORKEY) PURE;
 
1852
    STDMETHOD(GetDC)(THIS_ HDC FAR *) PURE;
 
1853
    STDMETHOD(GetFlipStatus)(THIS_ DWORD) PURE;
 
1854
    STDMETHOD(GetOverlayPosition)(THIS_ LPLONG, LPLONG ) PURE;
 
1855
    STDMETHOD(GetPalette)(THIS_ LPDIRECTDRAWPALETTE FAR*) PURE;
 
1856
    STDMETHOD(GetPixelFormat)(THIS_ LPDDPIXELFORMAT) PURE;
 
1857
    STDMETHOD(GetSurfaceDesc)(THIS_ LPDDSURFACEDESC2) PURE;
 
1858
    STDMETHOD(Initialize)(THIS_ LPDIRECTDRAW, LPDDSURFACEDESC2) PURE;
 
1859
    STDMETHOD(IsLost)(THIS) PURE;
 
1860
    STDMETHOD(Lock)(THIS_ LPRECT,LPDDSURFACEDESC2,DWORD,HANDLE) PURE;
 
1861
    STDMETHOD(ReleaseDC)(THIS_ HDC) PURE;
 
1862
    STDMETHOD(Restore)(THIS) PURE;
 
1863
    STDMETHOD(SetClipper)(THIS_ LPDIRECTDRAWCLIPPER) PURE;
 
1864
    STDMETHOD(SetColorKey)(THIS_ DWORD, LPDDCOLORKEY) PURE;
 
1865
    STDMETHOD(SetOverlayPosition)(THIS_ LONG, LONG ) PURE;
 
1866
    STDMETHOD(SetPalette)(THIS_ LPDIRECTDRAWPALETTE) PURE;
 
1867
    STDMETHOD(Unlock)(THIS_ LPRECT) PURE;
 
1868
    STDMETHOD(UpdateOverlay)(THIS_ LPRECT, LPDIRECTDRAWSURFACE4,LPRECT,DWORD, LPDDOVERLAYFX) PURE;
 
1869
    STDMETHOD(UpdateOverlayDisplay)(THIS_ DWORD) PURE;
 
1870
    STDMETHOD(UpdateOverlayZOrder)(THIS_ DWORD, LPDIRECTDRAWSURFACE4) PURE;
 
1871
    /*** Added in the v2 interface ***/
 
1872
    STDMETHOD(GetDDInterface)(THIS_ LPVOID FAR *) PURE;
 
1873
    STDMETHOD(PageLock)(THIS_ DWORD) PURE;
 
1874
    STDMETHOD(PageUnlock)(THIS_ DWORD) PURE;
 
1875
    /*** Added in the v3 interface ***/
 
1876
    STDMETHOD(SetSurfaceDesc)(THIS_ LPDDSURFACEDESC2, DWORD) PURE;
 
1877
    /*** Added in the v4 interface ***/
 
1878
    STDMETHOD(SetPrivateData)(THIS_ REFGUID, LPVOID, DWORD, DWORD) PURE;
 
1879
    STDMETHOD(GetPrivateData)(THIS_ REFGUID, LPVOID, LPDWORD) PURE;
 
1880
    STDMETHOD(FreePrivateData)(THIS_ REFGUID) PURE;
 
1881
    STDMETHOD(GetUniquenessValue)(THIS_ LPDWORD) PURE;
 
1882
    STDMETHOD(ChangeUniquenessValue)(THIS) PURE;
 
1883
};
 
1884
 
 
1885
#if !defined(__cplusplus) || defined(CINTERFACE)
 
1886
#define IDirectDrawSurface4_QueryInterface(p,a,b)        (p)->lpVtbl->QueryInterface(p,a,b)
 
1887
#define IDirectDrawSurface4_AddRef(p)                    (p)->lpVtbl->AddRef(p)
 
1888
#define IDirectDrawSurface4_Release(p)                   (p)->lpVtbl->Release(p)
 
1889
#define IDirectDrawSurface4_AddAttachedSurface(p,a)      (p)->lpVtbl->AddAttachedSurface(p,a)
 
1890
#define IDirectDrawSurface4_AddOverlayDirtyRect(p,a)     (p)->lpVtbl->AddOverlayDirtyRect(p,a)
 
1891
#define IDirectDrawSurface4_Blt(p,a,b,c,d,e)             (p)->lpVtbl->Blt(p,a,b,c,d,e)
 
1892
#define IDirectDrawSurface4_BltBatch(p,a,b,c)            (p)->lpVtbl->BltBatch(p,a,b,c)
 
1893
#define IDirectDrawSurface4_BltFast(p,a,b,c,d,e)         (p)->lpVtbl->BltFast(p,a,b,c,d,e)
 
1894
#define IDirectDrawSurface4_DeleteAttachedSurface(p,a,b) (p)->lpVtbl->DeleteAttachedSurface(p,a,b)
 
1895
#define IDirectDrawSurface4_EnumAttachedSurfaces(p,a,b)  (p)->lpVtbl->EnumAttachedSurfaces(p,a,b)
 
1896
#define IDirectDrawSurface4_EnumOverlayZOrders(p,a,b,c)  (p)->lpVtbl->EnumOverlayZOrders(p,a,b,c)
 
1897
#define IDirectDrawSurface4_Flip(p,a,b)                  (p)->lpVtbl->Flip(p,a,b)
 
1898
#define IDirectDrawSurface4_GetAttachedSurface(p,a,b)    (p)->lpVtbl->GetAttachedSurface(p,a,b)
 
1899
#define IDirectDrawSurface4_GetBltStatus(p,a)            (p)->lpVtbl->GetBltStatus(p,a)
 
1900
#define IDirectDrawSurface4_GetCaps(p,b)                 (p)->lpVtbl->GetCaps(p,b)
 
1901
#define IDirectDrawSurface4_GetClipper(p,a)              (p)->lpVtbl->GetClipper(p,a)
 
1902
#define IDirectDrawSurface4_GetColorKey(p,a,b)           (p)->lpVtbl->GetColorKey(p,a,b)
 
1903
#define IDirectDrawSurface4_GetDC(p,a)                   (p)->lpVtbl->GetDC(p,a)
 
1904
#define IDirectDrawSurface4_GetFlipStatus(p,a)           (p)->lpVtbl->GetFlipStatus(p,a)
 
1905
#define IDirectDrawSurface4_GetOverlayPosition(p,a,b)    (p)->lpVtbl->GetOverlayPosition(p,a,b)
 
1906
#define IDirectDrawSurface4_GetPalette(p,a)              (p)->lpVtbl->GetPalette(p,a)
 
1907
#define IDirectDrawSurface4_GetPixelFormat(p,a)          (p)->lpVtbl->GetPixelFormat(p,a)
 
1908
#define IDirectDrawSurface4_GetSurfaceDesc(p,a)          (p)->lpVtbl->GetSurfaceDesc(p,a)
 
1909
#define IDirectDrawSurface4_Initialize(p,a,b)            (p)->lpVtbl->Initialize(p,a,b)
 
1910
#define IDirectDrawSurface4_IsLost(p)                    (p)->lpVtbl->IsLost(p)
 
1911
#define IDirectDrawSurface4_Lock(p,a,b,c,d)              (p)->lpVtbl->Lock(p,a,b,c,d)
 
1912
#define IDirectDrawSurface4_ReleaseDC(p,a)               (p)->lpVtbl->ReleaseDC(p,a)
 
1913
#define IDirectDrawSurface4_Restore(p)                   (p)->lpVtbl->Restore(p)
 
1914
#define IDirectDrawSurface4_SetClipper(p,a)              (p)->lpVtbl->SetClipper(p,a)
 
1915
#define IDirectDrawSurface4_SetColorKey(p,a,b)           (p)->lpVtbl->SetColorKey(p,a,b)
 
1916
#define IDirectDrawSurface4_SetOverlayPosition(p,a,b)    (p)->lpVtbl->SetOverlayPosition(p,a,b)
 
1917
#define IDirectDrawSurface4_SetPalette(p,a)              (p)->lpVtbl->SetPalette(p,a)
 
1918
#define IDirectDrawSurface4_Unlock(p,b)                  (p)->lpVtbl->Unlock(p,b)
 
1919
#define IDirectDrawSurface4_UpdateOverlay(p,a,b,c,d,e)   (p)->lpVtbl->UpdateOverlay(p,a,b,c,d,e)
 
1920
#define IDirectDrawSurface4_UpdateOverlayDisplay(p,a)    (p)->lpVtbl->UpdateOverlayDisplay(p,a)
 
1921
#define IDirectDrawSurface4_UpdateOverlayZOrder(p,a,b)   (p)->lpVtbl->UpdateOverlayZOrder(p,a,b)
 
1922
#define IDirectDrawSurface4_GetDDInterface(p,a)          (p)->lpVtbl->GetDDInterface(p,a)
 
1923
#define IDirectDrawSurface4_PageLock(p,a)                (p)->lpVtbl->PageLock(p,a)
 
1924
#define IDirectDrawSurface4_PageUnlock(p,a)              (p)->lpVtbl->PageUnlock(p,a)
 
1925
#define IDirectDrawSurface4_SetSurfaceDesc(p,a,b)        (p)->lpVtbl->SetSurfaceDesc(p,a,b)
 
1926
#define IDirectDrawSurface4_SetPrivateData(p,a,b,c,d)    (p)->lpVtbl->SetPrivateData(p,a,b,c,d)
 
1927
#define IDirectDrawSurface4_GetPrivateData(p,a,b,c)      (p)->lpVtbl->GetPrivateData(p,a,b,c)
 
1928
#define IDirectDrawSurface4_FreePrivateData(p,a)         (p)->lpVtbl->FreePrivateData(p,a)
 
1929
#define IDirectDrawSurface4_GetUniquenessValue(p, a)     (p)->lpVtbl->GetUniquenessValue(p, a)
 
1930
#define IDirectDrawSurface4_ChangeUniquenessValue(p)     (p)->lpVtbl->ChangeUniquenessValue(p)
 
1931
#else
 
1932
#define IDirectDrawSurface4_QueryInterface(p,a,b)        (p)->QueryInterface(a,b)
 
1933
#define IDirectDrawSurface4_AddRef(p)                    (p)->AddRef()
 
1934
#define IDirectDrawSurface4_Release(p)                   (p)->Release()
 
1935
#define IDirectDrawSurface4_AddAttachedSurface(p,a)      (p)->AddAttachedSurface(a)
 
1936
#define IDirectDrawSurface4_AddOverlayDirtyRect(p,a)     (p)->AddOverlayDirtyRect(a)
 
1937
#define IDirectDrawSurface4_Blt(p,a,b,c,d,e)             (p)->Blt(a,b,c,d,e)
 
1938
#define IDirectDrawSurface4_BltBatch(p,a,b,c)            (p)->BltBatch(a,b,c)
 
1939
#define IDirectDrawSurface4_BltFast(p,a,b,c,d,e)         (p)->BltFast(a,b,c,d,e)
 
1940
#define IDirectDrawSurface4_DeleteAttachedSurface(p,a,b) (p)->DeleteAttachedSurface(a,b)
 
1941
#define IDirectDrawSurface4_EnumAttachedSurfaces(p,a,b)  (p)->EnumAttachedSurfaces(a,b)
 
1942
#define IDirectDrawSurface4_EnumOverlayZOrders(p,a,b,c)  (p)->EnumOverlayZOrders(a,b,c)
 
1943
#define IDirectDrawSurface4_Flip(p,a,b)                  (p)->Flip(a,b)
 
1944
#define IDirectDrawSurface4_GetAttachedSurface(p,a,b)    (p)->GetAttachedSurface(a,b)
 
1945
#define IDirectDrawSurface4_GetBltStatus(p,a)            (p)->GetBltStatus(a)
 
1946
#define IDirectDrawSurface4_GetCaps(p,b)                 (p)->GetCaps(b)
 
1947
#define IDirectDrawSurface4_GetClipper(p,a)              (p)->GetClipper(a)
 
1948
#define IDirectDrawSurface4_GetColorKey(p,a,b)           (p)->GetColorKey(a,b)
 
1949
#define IDirectDrawSurface4_GetDC(p,a)                   (p)->GetDC(a)
 
1950
#define IDirectDrawSurface4_GetFlipStatus(p,a)           (p)->GetFlipStatus(a)
 
1951
#define IDirectDrawSurface4_GetOverlayPosition(p,a,b)    (p)->GetOverlayPosition(a,b)
 
1952
#define IDirectDrawSurface4_GetPalette(p,a)              (p)->GetPalette(a)
 
1953
#define IDirectDrawSurface4_GetPixelFormat(p,a)          (p)->GetPixelFormat(a)
 
1954
#define IDirectDrawSurface4_GetSurfaceDesc(p,a)          (p)->GetSurfaceDesc(a)
 
1955
#define IDirectDrawSurface4_Initialize(p,a,b)            (p)->Initialize(a,b)
 
1956
#define IDirectDrawSurface4_IsLost(p)                    (p)->IsLost()
 
1957
#define IDirectDrawSurface4_Lock(p,a,b,c,d)              (p)->Lock(a,b,c,d)
 
1958
#define IDirectDrawSurface4_ReleaseDC(p,a)               (p)->ReleaseDC(a)
 
1959
#define IDirectDrawSurface4_Restore(p)                   (p)->Restore()
 
1960
#define IDirectDrawSurface4_SetClipper(p,a)              (p)->SetClipper(a)
 
1961
#define IDirectDrawSurface4_SetColorKey(p,a,b)           (p)->SetColorKey(a,b)
 
1962
#define IDirectDrawSurface4_SetOverlayPosition(p,a,b)    (p)->SetOverlayPosition(a,b)
 
1963
#define IDirectDrawSurface4_SetPalette(p,a)              (p)->SetPalette(a)
 
1964
#define IDirectDrawSurface4_Unlock(p,b)                  (p)->Unlock(b)
 
1965
#define IDirectDrawSurface4_UpdateOverlay(p,a,b,c,d,e)   (p)->UpdateOverlay(a,b,c,d,e)
 
1966
#define IDirectDrawSurface4_UpdateOverlayDisplay(p,a)    (p)->UpdateOverlayDisplay(a)
 
1967
#define IDirectDrawSurface4_UpdateOverlayZOrder(p,a,b)   (p)->UpdateOverlayZOrder(a,b)
 
1968
#define IDirectDrawSurface4_GetDDInterface(p,a)          (p)->GetDDInterface(a)
 
1969
#define IDirectDrawSurface4_PageLock(p,a)                (p)->PageLock(a)
 
1970
#define IDirectDrawSurface4_PageUnlock(p,a)              (p)->PageUnlock(a)
 
1971
#define IDirectDrawSurface4_SetSurfaceDesc(p,a,b)        (p)->SetSurfaceDesc(a,b)
 
1972
#define IDirectDrawSurface4_SetPrivateData(p,a,b,c,d)    (p)->SetPrivateData(a,b,c,d)
 
1973
#define IDirectDrawSurface4_GetPrivateData(p,a,b,c)      (p)->GetPrivateData(a,b,c)
 
1974
#define IDirectDrawSurface4_FreePrivateData(p,a)         (p)->FreePrivateData(a)
 
1975
#define IDirectDrawSurface4_GetUniquenessValue(p, a)     (p)->GetUniquenessValue(a)
 
1976
#define IDirectDrawSurface4_ChangeUniquenessValue(p)     (p)->ChangeUniquenessValue()
 
1977
#endif
 
1978
 
 
1979
/*
 
1980
 * IDirectDrawSurface7 and related interfaces
 
1981
 */
 
1982
#undef INTERFACE
 
1983
#define INTERFACE IDirectDrawSurface7
 
1984
DECLARE_INTERFACE_( IDirectDrawSurface7, IUnknown )
 
1985
{
 
1986
    /*** IUnknown methods ***/
 
1987
    STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE;
 
1988
    STDMETHOD_(ULONG,AddRef) (THIS)  PURE;
 
1989
    STDMETHOD_(ULONG,Release) (THIS) PURE;
 
1990
    /*** IDirectDrawSurface methods ***/
 
1991
    STDMETHOD(AddAttachedSurface)(THIS_ LPDIRECTDRAWSURFACE7) PURE;
 
1992
    STDMETHOD(AddOverlayDirtyRect)(THIS_ LPRECT) PURE;
 
1993
    STDMETHOD(Blt)(THIS_ LPRECT,LPDIRECTDRAWSURFACE7, LPRECT,DWORD, LPDDBLTFX) PURE;
 
1994
    STDMETHOD(BltBatch)(THIS_ LPDDBLTBATCH, DWORD, DWORD ) PURE;
 
1995
    STDMETHOD(BltFast)(THIS_ DWORD,DWORD,LPDIRECTDRAWSURFACE7, LPRECT,DWORD) PURE;
 
1996
    STDMETHOD(DeleteAttachedSurface)(THIS_ DWORD,LPDIRECTDRAWSURFACE7) PURE;
 
1997
    STDMETHOD(EnumAttachedSurfaces)(THIS_ LPVOID,LPDDENUMSURFACESCALLBACK7) PURE;
 
1998
    STDMETHOD(EnumOverlayZOrders)(THIS_ DWORD,LPVOID,LPDDENUMSURFACESCALLBACK7) PURE;
 
1999
    STDMETHOD(Flip)(THIS_ LPDIRECTDRAWSURFACE7, DWORD) PURE;
 
2000
    STDMETHOD(GetAttachedSurface)(THIS_ LPDDSCAPS2, LPDIRECTDRAWSURFACE7 FAR *) PURE;
 
2001
    STDMETHOD(GetBltStatus)(THIS_ DWORD) PURE;
 
2002
    STDMETHOD(GetCaps)(THIS_ LPDDSCAPS2) PURE;
 
2003
    STDMETHOD(GetClipper)(THIS_ LPDIRECTDRAWCLIPPER FAR*) PURE;
 
2004
    STDMETHOD(GetColorKey)(THIS_ DWORD, LPDDCOLORKEY) PURE;
 
2005
    STDMETHOD(GetDC)(THIS_ HDC FAR *) PURE;
 
2006
    STDMETHOD(GetFlipStatus)(THIS_ DWORD) PURE;
 
2007
    STDMETHOD(GetOverlayPosition)(THIS_ LPLONG, LPLONG ) PURE;
 
2008
    STDMETHOD(GetPalette)(THIS_ LPDIRECTDRAWPALETTE FAR*) PURE;
 
2009
    STDMETHOD(GetPixelFormat)(THIS_ LPDDPIXELFORMAT) PURE;
 
2010
    STDMETHOD(GetSurfaceDesc)(THIS_ LPDDSURFACEDESC2) PURE;
 
2011
    STDMETHOD(Initialize)(THIS_ LPDIRECTDRAW, LPDDSURFACEDESC2) PURE;
 
2012
    STDMETHOD(IsLost)(THIS) PURE;
 
2013
    STDMETHOD(Lock)(THIS_ LPRECT,LPDDSURFACEDESC2,DWORD,HANDLE) PURE;
 
2014
    STDMETHOD(ReleaseDC)(THIS_ HDC) PURE;
 
2015
    STDMETHOD(Restore)(THIS) PURE;
 
2016
    STDMETHOD(SetClipper)(THIS_ LPDIRECTDRAWCLIPPER) PURE;
 
2017
    STDMETHOD(SetColorKey)(THIS_ DWORD, LPDDCOLORKEY) PURE;
 
2018
    STDMETHOD(SetOverlayPosition)(THIS_ LONG, LONG ) PURE;
 
2019
    STDMETHOD(SetPalette)(THIS_ LPDIRECTDRAWPALETTE) PURE;
 
2020
    STDMETHOD(Unlock)(THIS_ LPRECT) PURE;
 
2021
    STDMETHOD(UpdateOverlay)(THIS_ LPRECT, LPDIRECTDRAWSURFACE7,LPRECT,DWORD, LPDDOVERLAYFX) PURE;
 
2022
    STDMETHOD(UpdateOverlayDisplay)(THIS_ DWORD) PURE;
 
2023
    STDMETHOD(UpdateOverlayZOrder)(THIS_ DWORD, LPDIRECTDRAWSURFACE7) PURE;
 
2024
    /*** Added in the v2 interface ***/
 
2025
    STDMETHOD(GetDDInterface)(THIS_ LPVOID FAR *) PURE;
 
2026
    STDMETHOD(PageLock)(THIS_ DWORD) PURE;
 
2027
    STDMETHOD(PageUnlock)(THIS_ DWORD) PURE;
 
2028
    /*** Added in the v3 interface ***/
 
2029
    STDMETHOD(SetSurfaceDesc)(THIS_ LPDDSURFACEDESC2, DWORD) PURE;
 
2030
    /*** Added in the v4 interface ***/
 
2031
    STDMETHOD(SetPrivateData)(THIS_ REFGUID, LPVOID, DWORD, DWORD) PURE;
 
2032
    STDMETHOD(GetPrivateData)(THIS_ REFGUID, LPVOID, LPDWORD) PURE;
 
2033
    STDMETHOD(FreePrivateData)(THIS_ REFGUID) PURE;
 
2034
    STDMETHOD(GetUniquenessValue)(THIS_ LPDWORD) PURE;
 
2035
    STDMETHOD(ChangeUniquenessValue)(THIS) PURE;
 
2036
    /*** Moved Texture7 methods here ***/
 
2037
    STDMETHOD(SetPriority)(THIS_ DWORD) PURE;
 
2038
    STDMETHOD(GetPriority)(THIS_ LPDWORD) PURE;
 
2039
    STDMETHOD(SetLOD)(THIS_ DWORD) PURE;
 
2040
    STDMETHOD(GetLOD)(THIS_ LPDWORD) PURE;
 
2041
};
 
2042
 
 
2043
#if !defined(__cplusplus) || defined(CINTERFACE)
 
2044
#define IDirectDrawSurface7_QueryInterface(p,a,b)        (p)->lpVtbl->QueryInterface(p,a,b)
 
2045
#define IDirectDrawSurface7_AddRef(p)                    (p)->lpVtbl->AddRef(p)
 
2046
#define IDirectDrawSurface7_Release(p)                   (p)->lpVtbl->Release(p)
 
2047
#define IDirectDrawSurface7_AddAttachedSurface(p,a)      (p)->lpVtbl->AddAttachedSurface(p,a)
 
2048
#define IDirectDrawSurface7_AddOverlayDirtyRect(p,a)     (p)->lpVtbl->AddOverlayDirtyRect(p,a)
 
2049
#define IDirectDrawSurface7_Blt(p,a,b,c,d,e)             (p)->lpVtbl->Blt(p,a,b,c,d,e)
 
2050
#define IDirectDrawSurface7_BltBatch(p,a,b,c)            (p)->lpVtbl->BltBatch(p,a,b,c)
 
2051
#define IDirectDrawSurface7_BltFast(p,a,b,c,d,e)         (p)->lpVtbl->BltFast(p,a,b,c,d,e)
 
2052
#define IDirectDrawSurface7_DeleteAttachedSurface(p,a,b) (p)->lpVtbl->DeleteAttachedSurface(p,a,b)
 
2053
#define IDirectDrawSurface7_EnumAttachedSurfaces(p,a,b)  (p)->lpVtbl->EnumAttachedSurfaces(p,a,b)
 
2054
#define IDirectDrawSurface7_EnumOverlayZOrders(p,a,b,c)  (p)->lpVtbl->EnumOverlayZOrders(p,a,b,c)
 
2055
#define IDirectDrawSurface7_Flip(p,a,b)                  (p)->lpVtbl->Flip(p,a,b)
 
2056
#define IDirectDrawSurface7_GetAttachedSurface(p,a,b)    (p)->lpVtbl->GetAttachedSurface(p,a,b)
 
2057
#define IDirectDrawSurface7_GetBltStatus(p,a)            (p)->lpVtbl->GetBltStatus(p,a)
 
2058
#define IDirectDrawSurface7_GetCaps(p,b)                 (p)->lpVtbl->GetCaps(p,b)
 
2059
#define IDirectDrawSurface7_GetClipper(p,a)              (p)->lpVtbl->GetClipper(p,a)
 
2060
#define IDirectDrawSurface7_GetColorKey(p,a,b)           (p)->lpVtbl->GetColorKey(p,a,b)
 
2061
#define IDirectDrawSurface7_GetDC(p,a)                   (p)->lpVtbl->GetDC(p,a)
 
2062
#define IDirectDrawSurface7_GetFlipStatus(p,a)           (p)->lpVtbl->GetFlipStatus(p,a)
 
2063
#define IDirectDrawSurface7_GetOverlayPosition(p,a,b)    (p)->lpVtbl->GetOverlayPosition(p,a,b)
 
2064
#define IDirectDrawSurface7_GetPalette(p,a)              (p)->lpVtbl->GetPalette(p,a)
 
2065
#define IDirectDrawSurface7_GetPixelFormat(p,a)          (p)->lpVtbl->GetPixelFormat(p,a)
 
2066
#define IDirectDrawSurface7_GetSurfaceDesc(p,a)          (p)->lpVtbl->GetSurfaceDesc(p,a)
 
2067
#define IDirectDrawSurface7_Initialize(p,a,b)            (p)->lpVtbl->Initialize(p,a,b)
 
2068
#define IDirectDrawSurface7_IsLost(p)                    (p)->lpVtbl->IsLost(p)
 
2069
#define IDirectDrawSurface7_Lock(p,a,b,c,d)              (p)->lpVtbl->Lock(p,a,b,c,d)
 
2070
#define IDirectDrawSurface7_ReleaseDC(p,a)               (p)->lpVtbl->ReleaseDC(p,a)
 
2071
#define IDirectDrawSurface7_Restore(p)                   (p)->lpVtbl->Restore(p)
 
2072
#define IDirectDrawSurface7_SetClipper(p,a)              (p)->lpVtbl->SetClipper(p,a)
 
2073
#define IDirectDrawSurface7_SetColorKey(p,a,b)           (p)->lpVtbl->SetColorKey(p,a,b)
 
2074
#define IDirectDrawSurface7_SetOverlayPosition(p,a,b)    (p)->lpVtbl->SetOverlayPosition(p,a,b)
 
2075
#define IDirectDrawSurface7_SetPalette(p,a)              (p)->lpVtbl->SetPalette(p,a)
 
2076
#define IDirectDrawSurface7_Unlock(p,b)                  (p)->lpVtbl->Unlock(p,b)
 
2077
#define IDirectDrawSurface7_UpdateOverlay(p,a,b,c,d,e)   (p)->lpVtbl->UpdateOverlay(p,a,b,c,d,e)
 
2078
#define IDirectDrawSurface7_UpdateOverlayDisplay(p,a)    (p)->lpVtbl->UpdateOverlayDisplay(p,a)
 
2079
#define IDirectDrawSurface7_UpdateOverlayZOrder(p,a,b)   (p)->lpVtbl->UpdateOverlayZOrder(p,a,b)
 
2080
#define IDirectDrawSurface7_GetDDInterface(p,a)          (p)->lpVtbl->GetDDInterface(p,a)
 
2081
#define IDirectDrawSurface7_PageLock(p,a)                (p)->lpVtbl->PageLock(p,a)
 
2082
#define IDirectDrawSurface7_PageUnlock(p,a)              (p)->lpVtbl->PageUnlock(p,a)
 
2083
#define IDirectDrawSurface7_SetSurfaceDesc(p,a,b)        (p)->lpVtbl->SetSurfaceDesc(p,a,b)
 
2084
#define IDirectDrawSurface7_SetPrivateData(p,a,b,c,d)    (p)->lpVtbl->SetPrivateData(p,a,b,c,d)
 
2085
#define IDirectDrawSurface7_GetPrivateData(p,a,b,c)      (p)->lpVtbl->GetPrivateData(p,a,b,c)
 
2086
#define IDirectDrawSurface7_FreePrivateData(p,a)         (p)->lpVtbl->FreePrivateData(p,a)
 
2087
#define IDirectDrawSurface7_GetUniquenessValue(p, a)     (p)->lpVtbl->GetUniquenessValue(p, a)
 
2088
#define IDirectDrawSurface7_ChangeUniquenessValue(p)     (p)->lpVtbl->ChangeUniquenessValue(p)
 
2089
#define IDirectDrawSurface7_SetPriority(p,a)             (p)->lpVtbl->SetPriority(p,a)
 
2090
#define IDirectDrawSurface7_GetPriority(p,a)             (p)->lpVtbl->GetPriority(p,a)
 
2091
#define IDirectDrawSurface7_SetLOD(p,a)                  (p)->lpVtbl->SetLOD(p,a)
 
2092
#define IDirectDrawSurface7_GetLOD(p,a)                  (p)->lpVtbl->GetLOD(p,a)
 
2093
#else
 
2094
#define IDirectDrawSurface7_QueryInterface(p,a,b)        (p)->QueryInterface(a,b)
 
2095
#define IDirectDrawSurface7_AddRef(p)                    (p)->AddRef()
 
2096
#define IDirectDrawSurface7_Release(p)                   (p)->Release()
 
2097
#define IDirectDrawSurface7_AddAttachedSurface(p,a)      (p)->AddAttachedSurface(a)
 
2098
#define IDirectDrawSurface7_AddOverlayDirtyRect(p,a)     (p)->AddOverlayDirtyRect(a)
 
2099
#define IDirectDrawSurface7_Blt(p,a,b,c,d,e)             (p)->Blt(a,b,c,d,e)
 
2100
#define IDirectDrawSurface7_BltBatch(p,a,b,c)            (p)->BltBatch(a,b,c)
 
2101
#define IDirectDrawSurface7_BltFast(p,a,b,c,d,e)         (p)->BltFast(a,b,c,d,e)
 
2102
#define IDirectDrawSurface7_DeleteAttachedSurface(p,a,b) (p)->DeleteAttachedSurface(a,b)
 
2103
#define IDirectDrawSurface7_EnumAttachedSurfaces(p,a,b)  (p)->EnumAttachedSurfaces(a,b)
 
2104
#define IDirectDrawSurface7_EnumOverlayZOrders(p,a,b,c)  (p)->EnumOverlayZOrders(a,b,c)
 
2105
#define IDirectDrawSurface7_Flip(p,a,b)                  (p)->Flip(a,b)
 
2106
#define IDirectDrawSurface7_GetAttachedSurface(p,a,b)    (p)->GetAttachedSurface(a,b)
 
2107
#define IDirectDrawSurface7_GetBltStatus(p,a)            (p)->GetBltStatus(a)
 
2108
#define IDirectDrawSurface7_GetCaps(p,b)                 (p)->GetCaps(b)
 
2109
#define IDirectDrawSurface7_GetClipper(p,a)              (p)->GetClipper(a)
 
2110
#define IDirectDrawSurface7_GetColorKey(p,a,b)           (p)->GetColorKey(a,b)
 
2111
#define IDirectDrawSurface7_GetDC(p,a)                   (p)->GetDC(a)
 
2112
#define IDirectDrawSurface7_GetFlipStatus(p,a)           (p)->GetFlipStatus(a)
 
2113
#define IDirectDrawSurface7_GetOverlayPosition(p,a,b)    (p)->GetOverlayPosition(a,b)
 
2114
#define IDirectDrawSurface7_GetPalette(p,a)              (p)->GetPalette(a)
 
2115
#define IDirectDrawSurface7_GetPixelFormat(p,a)          (p)->GetPixelFormat(a)
 
2116
#define IDirectDrawSurface7_GetSurfaceDesc(p,a)          (p)->GetSurfaceDesc(a)
 
2117
#define IDirectDrawSurface7_Initialize(p,a,b)            (p)->Initialize(a,b)
 
2118
#define IDirectDrawSurface7_IsLost(p)                    (p)->IsLost()
 
2119
#define IDirectDrawSurface7_Lock(p,a,b,c,d)              (p)->Lock(a,b,c,d)
 
2120
#define IDirectDrawSurface7_ReleaseDC(p,a)               (p)->ReleaseDC(a)
 
2121
#define IDirectDrawSurface7_Restore(p)                   (p)->Restore()
 
2122
#define IDirectDrawSurface7_SetClipper(p,a)              (p)->SetClipper(a)
 
2123
#define IDirectDrawSurface7_SetColorKey(p,a,b)           (p)->SetColorKey(a,b)
 
2124
#define IDirectDrawSurface7_SetOverlayPosition(p,a,b)    (p)->SetOverlayPosition(a,b)
 
2125
#define IDirectDrawSurface7_SetPalette(p,a)              (p)->SetPalette(a)
 
2126
#define IDirectDrawSurface7_Unlock(p,b)                  (p)->Unlock(b)
 
2127
#define IDirectDrawSurface7_UpdateOverlay(p,a,b,c,d,e)   (p)->UpdateOverlay(a,b,c,d,e)
 
2128
#define IDirectDrawSurface7_UpdateOverlayDisplay(p,a)    (p)->UpdateOverlayDisplay(a)
 
2129
#define IDirectDrawSurface7_UpdateOverlayZOrder(p,a,b)   (p)->UpdateOverlayZOrder(a,b)
 
2130
#define IDirectDrawSurface7_GetDDInterface(p,a)          (p)->GetDDInterface(a)
 
2131
#define IDirectDrawSurface7_PageLock(p,a)                (p)->PageLock(a)
 
2132
#define IDirectDrawSurface7_PageUnlock(p,a)              (p)->PageUnlock(a)
 
2133
#define IDirectDrawSurface7_SetSurfaceDesc(p,a,b)        (p)->SetSurfaceDesc(a,b)
 
2134
#define IDirectDrawSurface7_SetPrivateData(p,a,b,c,d)    (p)->SetPrivateData(a,b,c,d)
 
2135
#define IDirectDrawSurface7_GetPrivateData(p,a,b,c)      (p)->GetPrivateData(a,b,c)
 
2136
#define IDirectDrawSurface7_FreePrivateData(p,a)         (p)->FreePrivateData(a)
 
2137
#define IDirectDrawSurface7_GetUniquenessValue(p, a)     (p)->GetUniquenessValue(a)
 
2138
#define IDirectDrawSurface7_ChangeUniquenessValue(p)     (p)->ChangeUniquenessValue()
 
2139
#define IDirectDrawSurface7_SetPriority(p,a)             (p)->SetPriority(a)
 
2140
#define IDirectDrawSurface7_GetPriority(p,a)             (p)->GetPriority(a)
 
2141
#define IDirectDrawSurface7_SetLOD(p,a)                  (p)->SetLOD(a)
 
2142
#define IDirectDrawSurface7_GetLOD(p,a)                  (p)->GetLOD(a)
 
2143
#endif
 
2144
 
 
2145
 
 
2146
/*
 
2147
 * IDirectDrawColorControl
 
2148
 */
 
2149
#if defined( _WIN32 ) && !defined( _NO_COM )
 
2150
#undef INTERFACE
 
2151
#define INTERFACE IDirectDrawColorControl
 
2152
DECLARE_INTERFACE_( IDirectDrawColorControl, IUnknown )
 
2153
{
 
2154
    /*** IUnknown methods ***/
 
2155
    STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE;
 
2156
    STDMETHOD_(ULONG,AddRef) (THIS)  PURE;
 
2157
    STDMETHOD_(ULONG,Release) (THIS) PURE;
 
2158
    /*** IDirectDrawColorControl methods ***/
 
2159
    STDMETHOD(GetColorControls)(THIS_ LPDDCOLORCONTROL) PURE;
 
2160
    STDMETHOD(SetColorControls)(THIS_ LPDDCOLORCONTROL) PURE;
 
2161
};
 
2162
 
 
2163
#if !defined(__cplusplus) || defined(CINTERFACE)
 
2164
#define IDirectDrawColorControl_QueryInterface(p, a, b)  (p)->lpVtbl->QueryInterface(p, a, b)
 
2165
#define IDirectDrawColorControl_AddRef(p)                (p)->lpVtbl->AddRef(p)
 
2166
#define IDirectDrawColorControl_Release(p)               (p)->lpVtbl->Release(p)
 
2167
#define IDirectDrawColorControl_GetColorControls(p, a)   (p)->lpVtbl->GetColorControls(p, a)
 
2168
#define IDirectDrawColorControl_SetColorControls(p, a)   (p)->lpVtbl->SetColorControls(p, a)
 
2169
#else
 
2170
#define IDirectDrawColorControl_QueryInterface(p, a, b)  (p)->QueryInterface(a, b)
 
2171
#define IDirectDrawColorControl_AddRef(p)                (p)->AddRef()
 
2172
#define IDirectDrawColorControl_Release(p)               (p)->Release()
 
2173
#define IDirectDrawColorControl_GetColorControls(p, a)   (p)->GetColorControls(a)
 
2174
#define IDirectDrawColorControl_SetColorControls(p, a)   (p)->SetColorControls(a)
 
2175
#endif
 
2176
 
 
2177
#endif
 
2178
 
 
2179
 
 
2180
/*
 
2181
 * IDirectDrawGammaControl
 
2182
 */
 
2183
#if defined( _WIN32 ) && !defined( _NO_COM )
 
2184
#undef INTERFACE
 
2185
#define INTERFACE IDirectDrawGammaControl
 
2186
DECLARE_INTERFACE_( IDirectDrawGammaControl, IUnknown )
 
2187
{
 
2188
    /*** IUnknown methods ***/
 
2189
    STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE;
 
2190
    STDMETHOD_(ULONG,AddRef) (THIS)  PURE;
 
2191
    STDMETHOD_(ULONG,Release) (THIS) PURE;
 
2192
    /*** IDirectDrawGammaControl methods ***/
 
2193
    STDMETHOD(GetGammaRamp)(THIS_ DWORD, LPDDGAMMARAMP) PURE;
 
2194
    STDMETHOD(SetGammaRamp)(THIS_ DWORD, LPDDGAMMARAMP) PURE;
 
2195
};
 
2196
 
 
2197
#if !defined(__cplusplus) || defined(CINTERFACE)
 
2198
#define IDirectDrawGammaControl_QueryInterface(p, a, b)  (p)->lpVtbl->QueryInterface(p, a, b)
 
2199
#define IDirectDrawGammaControl_AddRef(p)                (p)->lpVtbl->AddRef(p)
 
2200
#define IDirectDrawGammaControl_Release(p)               (p)->lpVtbl->Release(p)
 
2201
#define IDirectDrawGammaControl_GetGammaRamp(p, a, b)    (p)->lpVtbl->GetGammaRamp(p, a, b)
 
2202
#define IDirectDrawGammaControl_SetGammaRamp(p, a, b)    (p)->lpVtbl->SetGammaRamp(p, a, b)
 
2203
#else
 
2204
#define IDirectDrawGammaControl_QueryInterface(p, a, b)  (p)->QueryInterface(a, b)
 
2205
#define IDirectDrawGammaControl_AddRef(p)                (p)->AddRef()
 
2206
#define IDirectDrawGammaControl_Release(p)               (p)->Release()
 
2207
#define IDirectDrawGammaControl_GetGammaRamp(p, a, b)    (p)->GetGammaRamp(a, b)
 
2208
#define IDirectDrawGammaControl_SetGammaRamp(p, a, b)    (p)->SetGammaRamp(a, b)
 
2209
#endif
 
2210
 
 
2211
#endif
 
2212
 
 
2213
 
 
2214
 
 
2215
#endif
 
2216
 
 
2217
 
 
2218
/*
 
2219
 * DDSURFACEDESC
 
2220
 */
 
2221
typedef struct _DDSURFACEDESC
 
2222
{
 
2223
    DWORD               dwSize;                 // size of the DDSURFACEDESC structure
 
2224
    DWORD               dwFlags;                // determines what fields are valid
 
2225
    DWORD               dwHeight;               // height of surface to be created
 
2226
    DWORD               dwWidth;                // width of input surface
 
2227
    union
 
2228
    {
 
2229
        LONG            lPitch;                 // distance to start of next line (return value only)
 
2230
        DWORD           dwLinearSize;           // Formless late-allocated optimized surface size
 
2231
    } DUMMYUNIONNAMEN(1);
 
2232
    DWORD               dwBackBufferCount;      // number of back buffers requested
 
2233
    union
 
2234
    {
 
2235
        DWORD           dwMipMapCount;          // number of mip-map levels requested
 
2236
        DWORD           dwZBufferBitDepth;      // depth of Z buffer requested
 
2237
        DWORD           dwRefreshRate;          // refresh rate (used when display mode is described)
 
2238
    } DUMMYUNIONNAMEN(2);
 
2239
    DWORD               dwAlphaBitDepth;        // depth of alpha buffer requested
 
2240
    DWORD               dwReserved;             // reserved
 
2241
    LPVOID              lpSurface;              // pointer to the associated surface memory
 
2242
    DDCOLORKEY          ddckCKDestOverlay;      // color key for destination overlay use
 
2243
    DDCOLORKEY          ddckCKDestBlt;          // color key for destination blt use
 
2244
    DDCOLORKEY          ddckCKSrcOverlay;       // color key for source overlay use
 
2245
    DDCOLORKEY          ddckCKSrcBlt;           // color key for source blt use
 
2246
    DDPIXELFORMAT       ddpfPixelFormat;        // pixel format description of the surface
 
2247
    DDSCAPS             ddsCaps;                // direct draw surface capabilities
 
2248
} DDSURFACEDESC;
 
2249
 
 
2250
/*
 
2251
 * DDSURFACEDESC2
 
2252
 */
 
2253
typedef struct _DDSURFACEDESC2
 
2254
{
 
2255
    DWORD               dwSize;                 // size of the DDSURFACEDESC structure
 
2256
    DWORD               dwFlags;                // determines what fields are valid
 
2257
    DWORD               dwHeight;               // height of surface to be created
 
2258
    DWORD               dwWidth;                // width of input surface
 
2259
    union
 
2260
    {
 
2261
        LONG            lPitch;                 // distance to start of next line (return value only)
 
2262
        DWORD           dwLinearSize;           // Formless late-allocated optimized surface size
 
2263
    } DUMMYUNIONNAMEN(1);
 
2264
    union
 
2265
    {
 
2266
        DWORD           dwBackBufferCount;      // number of back buffers requested
 
2267
        DWORD           dwDepth;                // the depth if this is a volume texture 
 
2268
    } DUMMYUNIONNAMEN(5);
 
2269
    union
 
2270
    {
 
2271
        DWORD           dwMipMapCount;          // number of mip-map levels requestde
 
2272
                                                // dwZBufferBitDepth removed, use ddpfPixelFormat one instead
 
2273
        DWORD           dwRefreshRate;          // refresh rate (used when display mode is described)
 
2274
        DWORD           dwSrcVBHandle;          // The source used in VB::Optimize
 
2275
    } DUMMYUNIONNAMEN(2);
 
2276
    DWORD               dwAlphaBitDepth;        // depth of alpha buffer requested
 
2277
    DWORD               dwReserved;             // reserved
 
2278
    LPVOID              lpSurface;              // pointer to the associated surface memory
 
2279
    union
 
2280
    {
 
2281
        DDCOLORKEY      ddckCKDestOverlay;      // color key for destination overlay use
 
2282
        DWORD           dwEmptyFaceColor;       // Physical color for empty cubemap faces
 
2283
    } DUMMYUNIONNAMEN(3);
 
2284
    DDCOLORKEY          ddckCKDestBlt;          // color key for destination blt use
 
2285
    DDCOLORKEY          ddckCKSrcOverlay;       // color key for source overlay use
 
2286
    DDCOLORKEY          ddckCKSrcBlt;           // color key for source blt use
 
2287
    union
 
2288
    {
 
2289
        DDPIXELFORMAT   ddpfPixelFormat;        // pixel format description of the surface
 
2290
        DWORD           dwFVF;                  // vertex format description of vertex buffers
 
2291
    } DUMMYUNIONNAMEN(4);
 
2292
    DDSCAPS2            ddsCaps;                // direct draw surface capabilities
 
2293
    DWORD               dwTextureStage;         // stage in multitexture cascade
 
2294
} DDSURFACEDESC2;
 
2295
 
 
2296
/*
 
2297
 * ddsCaps field is valid.
 
2298
 */
 
2299
#define DDSD_CAPS               0x00000001l     // default
 
2300
 
 
2301
/*
 
2302
 * dwHeight field is valid.
 
2303
 */
 
2304
#define DDSD_HEIGHT             0x00000002l
 
2305
 
 
2306
/*
 
2307
 * dwWidth field is valid.
 
2308
 */
 
2309
#define DDSD_WIDTH              0x00000004l
 
2310
 
 
2311
/*
 
2312
 * lPitch is valid.
 
2313
 */
 
2314
#define DDSD_PITCH              0x00000008l
 
2315
 
 
2316
/*
 
2317
 * dwBackBufferCount is valid.
 
2318
 */
 
2319
#define DDSD_BACKBUFFERCOUNT    0x00000020l
 
2320
 
 
2321
/*
 
2322
 * dwZBufferBitDepth is valid.  (shouldnt be used in DDSURFACEDESC2)
 
2323
 */
 
2324
#define DDSD_ZBUFFERBITDEPTH    0x00000040l
 
2325
 
 
2326
/*
 
2327
 * dwAlphaBitDepth is valid.
 
2328
 */
 
2329
#define DDSD_ALPHABITDEPTH      0x00000080l
 
2330
 
 
2331
 
 
2332
/*
 
2333
 * lpSurface is valid.
 
2334
 */
 
2335
#define DDSD_LPSURFACE          0x00000800l
 
2336
 
 
2337
/*
 
2338
 * ddpfPixelFormat is valid.
 
2339
 */
 
2340
#define DDSD_PIXELFORMAT        0x00001000l
 
2341
 
 
2342
/*
 
2343
 * ddckCKDestOverlay is valid.
 
2344
 */
 
2345
#define DDSD_CKDESTOVERLAY      0x00002000l
 
2346
 
 
2347
/*
 
2348
 * ddckCKDestBlt is valid.
 
2349
 */
 
2350
#define DDSD_CKDESTBLT          0x00004000l
 
2351
 
 
2352
/*
 
2353
 * ddckCKSrcOverlay is valid.
 
2354
 */
 
2355
#define DDSD_CKSRCOVERLAY       0x00008000l
 
2356
 
 
2357
/*
 
2358
 * ddckCKSrcBlt is valid.
 
2359
 */
 
2360
#define DDSD_CKSRCBLT           0x00010000l
 
2361
 
 
2362
/*
 
2363
 * dwMipMapCount is valid.
 
2364
 */
 
2365
#define DDSD_MIPMAPCOUNT        0x00020000l
 
2366
 
 
2367
 /*
 
2368
  * dwRefreshRate is valid
 
2369
  */
 
2370
#define DDSD_REFRESHRATE        0x00040000l
 
2371
 
 
2372
/*
 
2373
 * dwLinearSize is valid
 
2374
 */
 
2375
#define DDSD_LINEARSIZE         0x00080000l
 
2376
 
 
2377
/*
 
2378
 * dwTextureStage is valid
 
2379
 */
 
2380
#define DDSD_TEXTURESTAGE       0x00100000l
 
2381
/*
 
2382
 * dwFVF is valid
 
2383
 */
 
2384
#define DDSD_FVF                0x00200000l
 
2385
/*
 
2386
 * dwSrcVBHandle is valid
 
2387
 */
 
2388
#define DDSD_SRCVBHANDLE        0x00400000l
 
2389
 
 
2390
/*
 
2391
 * dwDepth is valid
 
2392
 */
 
2393
#define DDSD_DEPTH              0x00800000l
 
2394
 
 
2395
/*
 
2396
 * All input fields are valid.
 
2397
 */
 
2398
#define DDSD_ALL                0x00fff9eel
 
2399
 
 
2400
/*
 
2401
 * DDOPTSURFACEDESC
 
2402
 */
 
2403
typedef struct _DDOPTSURFACEDESC
 
2404
{
 
2405
    DWORD       dwSize;             // size of the DDOPTSURFACEDESC structure
 
2406
    DWORD       dwFlags;            // determines what fields are valid
 
2407
    DDSCAPS2    ddSCaps;            // Common caps like: Memory type
 
2408
    DDOSCAPS    ddOSCaps;           // Common caps like: Memory type
 
2409
    GUID        guid;               // Compression technique GUID
 
2410
    DWORD       dwCompressionRatio; // Compression ratio
 
2411
} DDOPTSURFACEDESC;
 
2412
 
 
2413
/*
 
2414
 * guid field is valid.
 
2415
 */
 
2416
#define DDOSD_GUID                  0x00000001l
 
2417
 
 
2418
/*
 
2419
 * dwCompressionRatio field is valid.
 
2420
 */
 
2421
#define DDOSD_COMPRESSION_RATIO     0x00000002l
 
2422
 
 
2423
/*
 
2424
 * ddSCaps field is valid.
 
2425
 */
 
2426
#define DDOSD_SCAPS                 0x00000004l
 
2427
 
 
2428
/*
 
2429
 * ddOSCaps field is valid.
 
2430
 */
 
2431
#define DDOSD_OSCAPS                0x00000008l
 
2432
 
 
2433
/*
 
2434
 * All input fields are valid.
 
2435
 */
 
2436
#define DDOSD_ALL                   0x0000000fl
 
2437
 
 
2438
/*
 
2439
 * The surface's optimized pixelformat is compressed
 
2440
 */
 
2441
#define DDOSDCAPS_OPTCOMPRESSED                 0x00000001l
 
2442
 
 
2443
/*
 
2444
 * The surface's optimized pixelformat is reordered
 
2445
 */
 
2446
#define DDOSDCAPS_OPTREORDERED                  0x00000002l
 
2447
 
 
2448
/*
 
2449
 * The opt surface is a monolithic mipmap
 
2450
 */
 
2451
#define DDOSDCAPS_MONOLITHICMIPMAP              0x00000004l
 
2452
 
 
2453
/*
 
2454
 * The valid Surf caps:
 
2455
 * #define DDSCAPS_SYSTEMMEMORY                 0x00000800l
 
2456
 * #define DDSCAPS_VIDEOMEMORY          0x00004000l
 
2457
 * #define DDSCAPS_LOCALVIDMEM          0x10000000l
 
2458
 * #define DDSCAPS_NONLOCALVIDMEM       0x20000000l
 
2459
 */
 
2460
#define DDOSDCAPS_VALIDSCAPS            0x30004800l
 
2461
 
 
2462
/*
 
2463
 * The valid OptSurf caps
 
2464
 */
 
2465
#define DDOSDCAPS_VALIDOSCAPS           0x00000007l
 
2466
 
 
2467
 
 
2468
/*
 
2469
 * DDCOLORCONTROL
 
2470
 */
 
2471
typedef struct _DDCOLORCONTROL
 
2472
{
 
2473
    DWORD               dwSize;
 
2474
    DWORD               dwFlags;
 
2475
    LONG                lBrightness;
 
2476
    LONG                lContrast;
 
2477
    LONG                lHue;
 
2478
    LONG                lSaturation;
 
2479
    LONG                lSharpness;
 
2480
    LONG                lGamma;
 
2481
    LONG                lColorEnable;
 
2482
    DWORD               dwReserved1;
 
2483
} DDCOLORCONTROL;
 
2484
 
 
2485
 
 
2486
/*
 
2487
 * lBrightness field is valid.
 
2488
 */
 
2489
#define DDCOLOR_BRIGHTNESS              0x00000001l
 
2490
 
 
2491
/*
 
2492
 * lContrast field is valid.
 
2493
 */
 
2494
#define DDCOLOR_CONTRAST                0x00000002l
 
2495
 
 
2496
/*
 
2497
 * lHue field is valid.
 
2498
 */
 
2499
#define DDCOLOR_HUE                     0x00000004l
 
2500
 
 
2501
/*
 
2502
 * lSaturation field is valid.
 
2503
 */
 
2504
#define DDCOLOR_SATURATION              0x00000008l
 
2505
 
 
2506
/*
 
2507
 * lSharpness field is valid.
 
2508
 */
 
2509
#define DDCOLOR_SHARPNESS               0x00000010l
 
2510
 
 
2511
/*
 
2512
 * lGamma field is valid.
 
2513
 */
 
2514
#define DDCOLOR_GAMMA                   0x00000020l
 
2515
 
 
2516
/*
 
2517
 * lColorEnable field is valid.
 
2518
 */
 
2519
#define DDCOLOR_COLORENABLE             0x00000040l
 
2520
 
 
2521
 
 
2522
 
 
2523
/*============================================================================
 
2524
 *
 
2525
 * Direct Draw Capability Flags
 
2526
 *
 
2527
 * These flags are used to describe the capabilities of a given Surface.
 
2528
 * All flags are bit flags.
 
2529
 *
 
2530
 *==========================================================================*/
 
2531
 
 
2532
/****************************************************************************
 
2533
 *
 
2534
 * DIRECTDRAWSURFACE CAPABILITY FLAGS
 
2535
 *
 
2536
 ****************************************************************************/
 
2537
 
 
2538
/*
 
2539
 * This bit is reserved. It should not be specified.
 
2540
 */
 
2541
#define DDSCAPS_RESERVED1                       0x00000001l
 
2542
 
 
2543
/*
 
2544
 * Indicates that this surface contains alpha-only information.
 
2545
 * (To determine if a surface is RGBA/YUVA, the pixel format must be
 
2546
 * interrogated.)
 
2547
 */
 
2548
#define DDSCAPS_ALPHA                           0x00000002l
 
2549
 
 
2550
/*
 
2551
 * Indicates that this surface is a backbuffer.  It is generally
 
2552
 * set by CreateSurface when the DDSCAPS_FLIP capability bit is set.
 
2553
 * It indicates that this surface is THE back buffer of a surface
 
2554
 * flipping structure.  DirectDraw supports N surfaces in a
 
2555
 * surface flipping structure.  Only the surface that immediately
 
2556
 * precedeces the DDSCAPS_FRONTBUFFER has this capability bit set.
 
2557
 * The other surfaces are identified as back buffers by the presence
 
2558
 * of the DDSCAPS_FLIP capability, their attachment order, and the
 
2559
 * absence of the DDSCAPS_FRONTBUFFER and DDSCAPS_BACKBUFFER
 
2560
 * capabilities.  The bit is sent to CreateSurface when a standalone
 
2561
 * back buffer is being created.  This surface could be attached to
 
2562
 * a front buffer and/or back buffers to form a flipping surface
 
2563
 * structure after the CreateSurface call.  See AddAttachments for
 
2564
 * a detailed description of the behaviors in this case.
 
2565
 */
 
2566
#define DDSCAPS_BACKBUFFER                      0x00000004l
 
2567
 
 
2568
/*
 
2569
 * Indicates a complex surface structure is being described.  A
 
2570
 * complex surface structure results in the creation of more than
 
2571
 * one surface.  The additional surfaces are attached to the root
 
2572
 * surface.  The complex structure can only be destroyed by
 
2573
 * destroying the root.
 
2574
 */
 
2575
#define DDSCAPS_COMPLEX                         0x00000008l
 
2576
 
 
2577
/*
 
2578
 * Indicates that this surface is a part of a surface flipping structure.
 
2579
 * When it is passed to CreateSurface the DDSCAPS_FRONTBUFFER and
 
2580
 * DDSCAP_BACKBUFFER bits are not set.  They are set by CreateSurface
 
2581
 * on the resulting creations.  The dwBackBufferCount field in the
 
2582
 * DDSURFACEDESC structure must be set to at least 1 in order for
 
2583
 * the CreateSurface call to succeed.  The DDSCAPS_COMPLEX capability
 
2584
 * must always be set with creating multiple surfaces through CreateSurface.
 
2585
 */
 
2586
#define DDSCAPS_FLIP                            0x00000010l
 
2587
 
 
2588
/*
 
2589
 * Indicates that this surface is THE front buffer of a surface flipping
 
2590
 * structure.  It is generally set by CreateSurface when the DDSCAPS_FLIP
 
2591
 * capability bit is set.
 
2592
 * If this capability is sent to CreateSurface then a standalonw front buffer
 
2593
 * is created.  This surface will not have the DDSCAPS_FLIP capability.
 
2594
 * It can be attached to other back buffers to form a flipping structure.
 
2595
 * See AddAttachments for a detailed description of the behaviors in this
 
2596
 * case.
 
2597
 */
 
2598
#define DDSCAPS_FRONTBUFFER                     0x00000020l
 
2599
 
 
2600
/*
 
2601
 * Indicates that this surface is any offscreen surface that is not an overlay,
 
2602
 * texture, zbuffer, front buffer, back buffer, or alpha surface.  It is used
 
2603
 * to identify plain vanilla surfaces.
 
2604
 */
 
2605
#define DDSCAPS_OFFSCREENPLAIN                  0x00000040l
 
2606
 
 
2607
/*
 
2608
 * Indicates that this surface is an overlay.  It may or may not be directly visible
 
2609
 * depending on whether or not it is currently being overlayed onto the primary
 
2610
 * surface.  DDSCAPS_VISIBLE can be used to determine whether or not it is being
 
2611
 * overlayed at the moment.
 
2612
 */
 
2613
#define DDSCAPS_OVERLAY                         0x00000080l
 
2614
 
 
2615
/*
 
2616
 * Indicates that unique DirectDrawPalette objects can be created and
 
2617
 * attached to this surface.
 
2618
 */
 
2619
#define DDSCAPS_PALETTE                         0x00000100l
 
2620
 
 
2621
/*
 
2622
 * Indicates that this surface is the primary surface.  The primary
 
2623
 * surface represents what the user is seeing at the moment.
 
2624
 */
 
2625
#define DDSCAPS_PRIMARYSURFACE                  0x00000200l
 
2626
 
 
2627
 
 
2628
/*
 
2629
 * This flag used to be DDSCAPS_PRIMARYSURFACELEFT, which is now
 
2630
 * obsolete.
 
2631
 */
 
2632
#define DDSCAPS_RESERVED3               0x00000400l
 
2633
#define DDSCAPS_PRIMARYSURFACELEFT              0x00000000l
 
2634
 
 
2635
/*
 
2636
 * Indicates that this surface memory was allocated in system memory
 
2637
 */
 
2638
#define DDSCAPS_SYSTEMMEMORY                    0x00000800l
 
2639
 
 
2640
/*
 
2641
 * Indicates that this surface can be used as a 3D texture.  It does not
 
2642
 * indicate whether or not the surface is being used for that purpose.
 
2643
 */
 
2644
#define DDSCAPS_TEXTURE                         0x00001000l
 
2645
 
 
2646
/*
 
2647
 * Indicates that a surface may be a destination for 3D rendering.  This
 
2648
 * bit must be set in order to query for a Direct3D Device Interface
 
2649
 * from this surface.
 
2650
 */
 
2651
#define DDSCAPS_3DDEVICE                        0x00002000l
 
2652
 
 
2653
/*
 
2654
 * Indicates that this surface exists in video memory.
 
2655
 */
 
2656
#define DDSCAPS_VIDEOMEMORY                     0x00004000l
 
2657
 
 
2658
/*
 
2659
 * Indicates that changes made to this surface are immediately visible.
 
2660
 * It is always set for the primary surface and is set for overlays while
 
2661
 * they are being overlayed and texture maps while they are being textured.
 
2662
 */
 
2663
#define DDSCAPS_VISIBLE                         0x00008000l
 
2664
 
 
2665
/*
 
2666
 * Indicates that only writes are permitted to the surface.  Read accesses
 
2667
 * from the surface may or may not generate a protection fault, but the
 
2668
 * results of a read from this surface will not be meaningful.  READ ONLY.
 
2669
 */
 
2670
#define DDSCAPS_WRITEONLY                       0x00010000l
 
2671
 
 
2672
/*
 
2673
 * Indicates that this surface is a z buffer. A z buffer does not contain
 
2674
 * displayable information.  Instead it contains bit depth information that is
 
2675
 * used to determine which pixels are visible and which are obscured.
 
2676
 */
 
2677
#define DDSCAPS_ZBUFFER                         0x00020000l
 
2678
 
 
2679
/*
 
2680
 * Indicates surface will have a DC associated long term
 
2681
 */
 
2682
#define DDSCAPS_OWNDC                           0x00040000l
 
2683
 
 
2684
/*
 
2685
 * Indicates surface should be able to receive live video
 
2686
 */
 
2687
#define DDSCAPS_LIVEVIDEO                       0x00080000l
 
2688
 
 
2689
/*
 
2690
 * Indicates surface should be able to have a stream decompressed
 
2691
 * to it by the hardware.
 
2692
 */
 
2693
#define DDSCAPS_HWCODEC                         0x00100000l
 
2694
 
 
2695
/*
 
2696
 * Surface is a ModeX surface.
 
2697
 *
 
2698
 */
 
2699
#define DDSCAPS_MODEX                           0x00200000l
 
2700
 
 
2701
/*
 
2702
 * Indicates surface is one level of a mip-map. This surface will
 
2703
 * be attached to other DDSCAPS_MIPMAP surfaces to form the mip-map.
 
2704
 * This can be done explicitly, by creating a number of surfaces and
 
2705
 * attaching them with AddAttachedSurface or by implicitly by CreateSurface.
 
2706
 * If this bit is set then DDSCAPS_TEXTURE must also be set.
 
2707
 */
 
2708
#define DDSCAPS_MIPMAP                          0x00400000l
 
2709
 
 
2710
/*
 
2711
 * This bit is reserved. It should not be specified.
 
2712
 */
 
2713
#define DDSCAPS_RESERVED2                       0x00800000l
 
2714
 
 
2715
 
 
2716
/*
 
2717
 * Indicates that memory for the surface is not allocated until the surface
 
2718
 * is loaded (via the Direct3D texture Load() function).
 
2719
 */
 
2720
#define DDSCAPS_ALLOCONLOAD                     0x04000000l
 
2721
 
 
2722
/*
 
2723
 * Indicates that the surface will recieve data from a video port.
 
2724
 */
 
2725
#define DDSCAPS_VIDEOPORT                       0x08000000l
 
2726
 
 
2727
/*
 
2728
 * Indicates that a video memory surface is resident in true, local video
 
2729
 * memory rather than non-local video memory. If this flag is specified then
 
2730
 * so must DDSCAPS_VIDEOMEMORY. This flag is mutually exclusive with
 
2731
 * DDSCAPS_NONLOCALVIDMEM.
 
2732
 */
 
2733
#define DDSCAPS_LOCALVIDMEM                     0x10000000l
 
2734
 
 
2735
/*
 
2736
 * Indicates that a video memory surface is resident in non-local video
 
2737
 * memory rather than true, local video memory. If this flag is specified
 
2738
 * then so must DDSCAPS_VIDEOMEMORY. This flag is mutually exclusive with
 
2739
 * DDSCAPS_LOCALVIDMEM.
 
2740
 */
 
2741
#define DDSCAPS_NONLOCALVIDMEM                  0x20000000l
 
2742
 
 
2743
/*
 
2744
 * Indicates that this surface is a standard VGA mode surface, and not a
 
2745
 * ModeX surface. (This flag will never be set in combination with the
 
2746
 * DDSCAPS_MODEX flag).
 
2747
 */
 
2748
#define DDSCAPS_STANDARDVGAMODE                 0x40000000l
 
2749
 
 
2750
/*
 
2751
 * Indicates that this surface will be an optimized surface. This flag is
 
2752
 * currently only valid in conjunction with the DDSCAPS_TEXTURE flag. The surface
 
2753
 * will be created without any underlying video memory until loaded.
 
2754
 */
 
2755
#define DDSCAPS_OPTIMIZED                       0x80000000l
 
2756
 
 
2757
 
 
2758
 
 
2759
/*
 
2760
 * This bit is reserved
 
2761
 */
 
2762
#define DDSCAPS2_RESERVED4                      0x00000002L
 
2763
#define DDSCAPS2_HARDWAREDEINTERLACE            0x00000000L
 
2764
 
 
2765
/*
 
2766
 * Indicates to the driver that this surface will be locked very frequently
 
2767
 * (for procedural textures, dynamic lightmaps, etc). Surfaces with this cap
 
2768
 * set must also have DDSCAPS_TEXTURE. This cap cannot be used with
 
2769
 * DDSCAPS2_HINTSTATIC and DDSCAPS2_OPAQUE.
 
2770
 */
 
2771
#define DDSCAPS2_HINTDYNAMIC                    0x00000004L
 
2772
 
 
2773
/*
 
2774
 * Indicates to the driver that this surface can be re-ordered/retiled on
 
2775
 * load. This operation will not change the size of the texture. It is
 
2776
 * relatively fast and symmetrical, since the application may lock these
 
2777
 * bits (although it will take a performance hit when doing so). Surfaces
 
2778
 * with this cap set must also have DDSCAPS_TEXTURE. This cap cannot be
 
2779
 * used with DDSCAPS2_HINTDYNAMIC and DDSCAPS2_OPAQUE.
 
2780
 */
 
2781
#define DDSCAPS2_HINTSTATIC                     0x00000008L
 
2782
 
 
2783
/*
 
2784
 * Indicates that the client would like this texture surface to be managed by the
 
2785
 * DirectDraw/Direct3D runtime. Surfaces with this cap set must also have
 
2786
 * DDSCAPS_TEXTURE set.
 
2787
 */
 
2788
#define DDSCAPS2_TEXTUREMANAGE                  0x00000010L
 
2789
 
 
2790
/*
 
2791
 * These bits are reserved for internal use */
 
2792
#define DDSCAPS2_RESERVED1                      0x00000020L
 
2793
#define DDSCAPS2_RESERVED2                      0x00000040L
 
2794
 
 
2795
/*
 
2796
 * Indicates to the driver that this surface will never be locked again.
 
2797
 * The driver is free to optimize this surface via retiling and actual compression.
 
2798
 * All calls to Lock() or Blts from this surface will fail. Surfaces with this
 
2799
 * cap set must also have DDSCAPS_TEXTURE. This cap cannot be used with
 
2800
 * DDSCAPS2_HINTDYNAMIC and DDSCAPS2_HINTSTATIC.
 
2801
 */
 
2802
#define DDSCAPS2_OPAQUE                         0x00000080L
 
2803
 
 
2804
/*
 
2805
 * Applications should set this bit at CreateSurface time to indicate that they
 
2806
 * intend to use antialiasing. Only valid if DDSCAPS_3DDEVICE is also set.
 
2807
 */
 
2808
#define DDSCAPS2_HINTANTIALIASING               0x00000100L
 
2809
 
 
2810
 
 
2811
/*
 
2812
 * This flag is used at CreateSurface time to indicate that this set of
 
2813
 * surfaces is a cubic environment map
 
2814
 */
 
2815
#define DDSCAPS2_CUBEMAP                        0x00000200L
 
2816
 
 
2817
/*
 
2818
 * These flags preform two functions:
 
2819
 * - At CreateSurface time, they define which of the six cube faces are
 
2820
 *   required by the application.
 
2821
 * - After creation, each face in the cubemap will have exactly one of these
 
2822
 *   bits set.
 
2823
 */
 
2824
#define DDSCAPS2_CUBEMAP_POSITIVEX              0x00000400L
 
2825
#define DDSCAPS2_CUBEMAP_NEGATIVEX              0x00000800L
 
2826
#define DDSCAPS2_CUBEMAP_POSITIVEY              0x00001000L
 
2827
#define DDSCAPS2_CUBEMAP_NEGATIVEY              0x00002000L
 
2828
#define DDSCAPS2_CUBEMAP_POSITIVEZ              0x00004000L
 
2829
#define DDSCAPS2_CUBEMAP_NEGATIVEZ              0x00008000L
 
2830
 
 
2831
/*
 
2832
 * This macro may be used to specify all faces of a cube map at CreateSurface time
 
2833
 */
 
2834
#define DDSCAPS2_CUBEMAP_ALLFACES ( DDSCAPS2_CUBEMAP_POSITIVEX |\
 
2835
                                    DDSCAPS2_CUBEMAP_NEGATIVEX |\
 
2836
                                    DDSCAPS2_CUBEMAP_POSITIVEY |\
 
2837
                                    DDSCAPS2_CUBEMAP_NEGATIVEY |\
 
2838
                                    DDSCAPS2_CUBEMAP_POSITIVEZ |\
 
2839
                                    DDSCAPS2_CUBEMAP_NEGATIVEZ )
 
2840
 
 
2841
 
 
2842
/*
 
2843
 * This flag is an additional flag which is present on mipmap sublevels from DX7 onwards
 
2844
 * It enables easier use of GetAttachedSurface rather than EnumAttachedSurfaces for surface
 
2845
 * constructs such as Cube Maps, wherein there are more than one mipmap surface attached
 
2846
 * to the root surface.
 
2847
 * This caps bit is ignored by CreateSurface
 
2848
 */
 
2849
#define DDSCAPS2_MIPMAPSUBLEVEL                 0x00010000L
 
2850
 
 
2851
/* This flag indicates that the texture should be managed by D3D only */
 
2852
#define DDSCAPS2_D3DTEXTUREMANAGE               0x00020000L
 
2853
 
 
2854
/* This flag indicates that the managed surface can be safely lost */
 
2855
#define DDSCAPS2_DONOTPERSIST                   0x00040000L
 
2856
 
 
2857
/* indicates that this surface is part of a stereo flipping chain */
 
2858
#define DDSCAPS2_STEREOSURFACELEFT              0x00080000L
 
2859
 
 
2860
 
 
2861
/*
 
2862
 * Indicates that the surface is a volume.
 
2863
 * Can be combined with DDSCAPS_MIPMAP to indicate a multi-level volume
 
2864
 */
 
2865
#define DDSCAPS2_VOLUME                         0x00200000L
 
2866
 
 
2867
/*
 
2868
 * Indicates that the surface may be locked multiple times by the application.
 
2869
 * This cap cannot be used with DDSCAPS2_OPAQUE.
 
2870
 */
 
2871
#define DDSCAPS2_NOTUSERLOCKABLE                0x00400000L
 
2872
 
 
2873
/*
 
2874
 * Indicates that the vertex buffer data can be used to render points and
 
2875
 * point sprites.
 
2876
 */
 
2877
#define DDSCAPS2_POINTS                         0x00800000L
 
2878
 
 
2879
/*
 
2880
 * Indicates that the vertex buffer data can be used to render rt pactches.
 
2881
 */
 
2882
#define DDSCAPS2_RTPATCHES                      0x01000000L
 
2883
 
 
2884
/*
 
2885
 * Indicates that the vertex buffer data can be used to render n patches.
 
2886
 */
 
2887
#define DDSCAPS2_NPATCHES                       0x02000000L
 
2888
 
 
2889
/*
 
2890
 * This bit is reserved for internal use 
 
2891
 */
 
2892
#define DDSCAPS2_RESERVED3                      0x04000000L
 
2893
 
 
2894
 
 
2895
/*
 
2896
 * Indicates that the contents of the backbuffer do not have to be preserved
 
2897
 * the contents of the backbuffer after they are presented.
 
2898
 */
 
2899
#define DDSCAPS2_DISCARDBACKBUFFER              0x10000000L
 
2900
 
 
2901
/*
 
2902
 * This is a mask that indicates the set of bits that may be set
 
2903
 * at createsurface time to indicate number of samples per pixel
 
2904
 * when multisampling
 
2905
 */
 
2906
#define DDSCAPS3_MULTISAMPLE_MASK               0x0000001FL
 
2907
 
 
2908
 
 
2909
 /****************************************************************************
 
2910
 *
 
2911
 * DIRECTDRAW DRIVER CAPABILITY FLAGS
 
2912
 *
 
2913
 ****************************************************************************/
 
2914
 
 
2915
/*
 
2916
 * Display hardware has 3D acceleration.
 
2917
 */
 
2918
#define DDCAPS_3D                       0x00000001l
 
2919
 
 
2920
/*
 
2921
 * Indicates that DirectDraw will support only dest rectangles that are aligned
 
2922
 * on DIRECTDRAWCAPS.dwAlignBoundaryDest boundaries of the surface, respectively.
 
2923
 * READ ONLY.
 
2924
 */
 
2925
#define DDCAPS_ALIGNBOUNDARYDEST        0x00000002l
 
2926
 
 
2927
/*
 
2928
 * Indicates that DirectDraw will support only source rectangles  whose sizes in
 
2929
 * BYTEs are DIRECTDRAWCAPS.dwAlignSizeDest multiples, respectively.  READ ONLY.
 
2930
 */
 
2931
#define DDCAPS_ALIGNSIZEDEST            0x00000004l
 
2932
/*
 
2933
 * Indicates that DirectDraw will support only source rectangles that are aligned
 
2934
 * on DIRECTDRAWCAPS.dwAlignBoundarySrc boundaries of the surface, respectively.
 
2935
 * READ ONLY.
 
2936
 */
 
2937
#define DDCAPS_ALIGNBOUNDARYSRC         0x00000008l
 
2938
 
 
2939
/*
 
2940
 * Indicates that DirectDraw will support only source rectangles  whose sizes in
 
2941
 * BYTEs are DIRECTDRAWCAPS.dwAlignSizeSrc multiples, respectively.  READ ONLY.
 
2942
 */
 
2943
#define DDCAPS_ALIGNSIZESRC             0x00000010l
 
2944
 
 
2945
/*
 
2946
 * Indicates that DirectDraw will create video memory surfaces that have a stride
 
2947
 * alignment equal to DIRECTDRAWCAPS.dwAlignStride.  READ ONLY.
 
2948
 */
 
2949
#define DDCAPS_ALIGNSTRIDE              0x00000020l
 
2950
 
 
2951
/*
 
2952
 * Display hardware is capable of blt operations.
 
2953
 */
 
2954
#define DDCAPS_BLT                      0x00000040l
 
2955
 
 
2956
/*
 
2957
 * Display hardware is capable of asynchronous blt operations.
 
2958
 */
 
2959
#define DDCAPS_BLTQUEUE                 0x00000080l
 
2960
 
 
2961
/*
 
2962
 * Display hardware is capable of color space conversions during the blt operation.
 
2963
 */
 
2964
#define DDCAPS_BLTFOURCC                0x00000100l
 
2965
 
 
2966
/*
 
2967
 * Display hardware is capable of stretching during blt operations.
 
2968
 */
 
2969
#define DDCAPS_BLTSTRETCH               0x00000200l
 
2970
 
 
2971
/*
 
2972
 * Display hardware is shared with GDI.
 
2973
 */
 
2974
#define DDCAPS_GDI                      0x00000400l
 
2975
 
 
2976
/*
 
2977
 * Display hardware can overlay.
 
2978
 */
 
2979
#define DDCAPS_OVERLAY                  0x00000800l
 
2980
 
 
2981
/*
 
2982
 * Set if display hardware supports overlays but can not clip them.
 
2983
 */
 
2984
#define DDCAPS_OVERLAYCANTCLIP          0x00001000l
 
2985
 
 
2986
/*
 
2987
 * Indicates that overlay hardware is capable of color space conversions during
 
2988
 * the overlay operation.
 
2989
 */
 
2990
#define DDCAPS_OVERLAYFOURCC            0x00002000l
 
2991
 
 
2992
/*
 
2993
 * Indicates that stretching can be done by the overlay hardware.
 
2994
 */
 
2995
#define DDCAPS_OVERLAYSTRETCH           0x00004000l
 
2996
 
 
2997
/*
 
2998
 * Indicates that unique DirectDrawPalettes can be created for DirectDrawSurfaces
 
2999
 * other than the primary surface.
 
3000
 */
 
3001
#define DDCAPS_PALETTE                  0x00008000l
 
3002
 
 
3003
/*
 
3004
 * Indicates that palette changes can be syncd with the veritcal refresh.
 
3005
 */
 
3006
#define DDCAPS_PALETTEVSYNC             0x00010000l
 
3007
 
 
3008
/*
 
3009
 * Display hardware can return the current scan line.
 
3010
 */
 
3011
#define DDCAPS_READSCANLINE             0x00020000l
 
3012
 
 
3013
 
 
3014
/*
 
3015
 * This flag used to bo DDCAPS_STEREOVIEW, which is now obsolete
 
3016
 */
 
3017
#define DDCAPS_RESERVED1                0x00040000l
 
3018
 
 
3019
/*
 
3020
 * Display hardware is capable of generating a vertical blank interrupt.
 
3021
 */
 
3022
#define DDCAPS_VBI                      0x00080000l
 
3023
 
 
3024
/*
 
3025
 * Supports the use of z buffers with blt operations.
 
3026
 */
 
3027
#define DDCAPS_ZBLTS                    0x00100000l
 
3028
 
 
3029
/*
 
3030
 * Supports Z Ordering of overlays.
 
3031
 */
 
3032
#define DDCAPS_ZOVERLAYS                0x00200000l
 
3033
 
 
3034
/*
 
3035
 * Supports color key
 
3036
 */
 
3037
#define DDCAPS_COLORKEY                 0x00400000l
 
3038
 
 
3039
/*
 
3040
 * Supports alpha surfaces
 
3041
 */
 
3042
#define DDCAPS_ALPHA                    0x00800000l
 
3043
 
 
3044
/*
 
3045
 * colorkey is hardware assisted(DDCAPS_COLORKEY will also be set)
 
3046
 */
 
3047
#define DDCAPS_COLORKEYHWASSIST         0x01000000l
 
3048
 
 
3049
/*
 
3050
 * no hardware support at all
 
3051
 */
 
3052
#define DDCAPS_NOHARDWARE               0x02000000l
 
3053
 
 
3054
/*
 
3055
 * Display hardware is capable of color fill with bltter
 
3056
 */
 
3057
#define DDCAPS_BLTCOLORFILL             0x04000000l
 
3058
 
 
3059
/*
 
3060
 * Display hardware is bank switched, and potentially very slow at
 
3061
 * random access to VRAM.
 
3062
 */
 
3063
#define DDCAPS_BANKSWITCHED             0x08000000l
 
3064
 
 
3065
/*
 
3066
 * Display hardware is capable of depth filling Z-buffers with bltter
 
3067
 */
 
3068
#define DDCAPS_BLTDEPTHFILL             0x10000000l
 
3069
 
 
3070
/*
 
3071
 * Display hardware is capable of clipping while bltting.
 
3072
 */
 
3073
#define DDCAPS_CANCLIP                  0x20000000l
 
3074
 
 
3075
/*
 
3076
 * Display hardware is capable of clipping while stretch bltting.
 
3077
 */
 
3078
#define DDCAPS_CANCLIPSTRETCHED         0x40000000l
 
3079
 
 
3080
/*
 
3081
 * Display hardware is capable of bltting to or from system memory
 
3082
 */
 
3083
#define DDCAPS_CANBLTSYSMEM             0x80000000l
 
3084
 
 
3085
 
 
3086
 /****************************************************************************
 
3087
 *
 
3088
 * MORE DIRECTDRAW DRIVER CAPABILITY FLAGS (dwCaps2)
 
3089
 *
 
3090
 ****************************************************************************/
 
3091
 
 
3092
/*
 
3093
 * Display hardware is certified
 
3094
 */
 
3095
#define DDCAPS2_CERTIFIED              0x00000001l
 
3096
 
 
3097
/*
 
3098
 * Driver cannot interleave 2D operations (lock and blt) to surfaces with
 
3099
 * Direct3D rendering operations between calls to BeginScene() and EndScene()
 
3100
 */
 
3101
#define DDCAPS2_NO2DDURING3DSCENE       0x00000002l
 
3102
 
 
3103
/*
 
3104
 * Display hardware contains a video port
 
3105
 */
 
3106
#define DDCAPS2_VIDEOPORT               0x00000004l
 
3107
 
 
3108
/*
 
3109
 * The overlay can be automatically flipped according to the video port
 
3110
 * VSYNCs, providing automatic doubled buffered display of video port
 
3111
 * data using an overlay
 
3112
 */
 
3113
#define DDCAPS2_AUTOFLIPOVERLAY         0x00000008l
 
3114
 
 
3115
/*
 
3116
 * Overlay can display each field of interlaced data individually while
 
3117
 * it is interleaved in memory without causing jittery artifacts.
 
3118
 */
 
3119
#define DDCAPS2_CANBOBINTERLEAVED       0x00000010l
 
3120
 
 
3121
/*
 
3122
 * Overlay can display each field of interlaced data individually while
 
3123
 * it is not interleaved in memory without causing jittery artifacts.
 
3124
 */
 
3125
#define DDCAPS2_CANBOBNONINTERLEAVED    0x00000020l
 
3126
 
 
3127
/*
 
3128
 * The overlay surface contains color controls (brightness, sharpness, etc.)
 
3129
 */
 
3130
#define DDCAPS2_COLORCONTROLOVERLAY     0x00000040l
 
3131
 
 
3132
/*
 
3133
 * The primary surface contains color controls (gamma, etc.)
 
3134
 */
 
3135
#define DDCAPS2_COLORCONTROLPRIMARY     0x00000080l
 
3136
 
 
3137
/*
 
3138
 * RGBZ -> RGB supported for 16:16 RGB:Z
 
3139
 */
 
3140
#define DDCAPS2_CANDROPZ16BIT           0x00000100l
 
3141
 
 
3142
/*
 
3143
 * Driver supports non-local video memory.
 
3144
 */
 
3145
#define DDCAPS2_NONLOCALVIDMEM          0x00000200l
 
3146
 
 
3147
/*
 
3148
 * Dirver supports non-local video memory but has different capabilities for
 
3149
 * non-local video memory surfaces. If this bit is set then so must
 
3150
 * DDCAPS2_NONLOCALVIDMEM.
 
3151
 */
 
3152
#define DDCAPS2_NONLOCALVIDMEMCAPS      0x00000400l
 
3153
 
 
3154
/*
 
3155
 * Driver neither requires nor prefers surfaces to be pagelocked when performing
 
3156
 * blts involving system memory surfaces
 
3157
 */
 
3158
#define DDCAPS2_NOPAGELOCKREQUIRED      0x00000800l
 
3159
 
 
3160
/*
 
3161
 * Driver can create surfaces which are wider than the primary surface
 
3162
 */
 
3163
#define DDCAPS2_WIDESURFACES            0x00001000l
 
3164
 
 
3165
/*
 
3166
 * Driver supports bob without using a video port by handling the
 
3167
 * DDFLIP_ODD and DDFLIP_EVEN flags specified in Flip.
 
3168
 */
 
3169
#define DDCAPS2_CANFLIPODDEVEN          0x00002000l
 
3170
 
 
3171
/*
 
3172
 * Driver supports bob using hardware
 
3173
 */
 
3174
#define DDCAPS2_CANBOBHARDWARE          0x00004000l
 
3175
 
 
3176
/*
 
3177
 * Driver supports bltting any FOURCC surface to another surface of the same FOURCC
 
3178
 */
 
3179
#define DDCAPS2_COPYFOURCC              0x00008000l
 
3180
 
 
3181
 
 
3182
/*
 
3183
 * Driver supports loadable gamma ramps for the primary surface
 
3184
 */
 
3185
#define DDCAPS2_PRIMARYGAMMA            0x00020000l
 
3186
 
 
3187
/*
 
3188
 * Driver can render in windowed mode.
 
3189
 */
 
3190
#define DDCAPS2_CANRENDERWINDOWED       0x00080000l
 
3191
 
 
3192
/*
 
3193
 * A calibrator is available to adjust the gamma ramp according to the
 
3194
 * physical display properties so that the result will be identical on
 
3195
 * all calibrated systems.
 
3196
 */
 
3197
#define DDCAPS2_CANCALIBRATEGAMMA       0x00100000l
 
3198
 
 
3199
/*
 
3200
 * Indicates that the driver will respond to DDFLIP_INTERVALn flags
 
3201
 */
 
3202
#define DDCAPS2_FLIPINTERVAL            0x00200000l
 
3203
 
 
3204
/*
 
3205
 * Indicates that the driver will respond to DDFLIP_NOVSYNC
 
3206
 */
 
3207
#define DDCAPS2_FLIPNOVSYNC             0x00400000l
 
3208
 
 
3209
/*
 
3210
 * Driver supports management of video memory, if this flag is ON,
 
3211
 * driver manages the texture if requested with DDSCAPS2_TEXTUREMANAGE on
 
3212
 * DirectX manages the texture if this flag is OFF and surface has DDSCAPS2_TEXTUREMANAGE on
 
3213
 */
 
3214
#define DDCAPS2_CANMANAGETEXTURE        0x00800000l
 
3215
 
 
3216
/*
 
3217
 * The Direct3D texture manager uses this cap to decide whether to put managed
 
3218
 * surfaces in non-local video memory. If the cap is set, the texture manager will
 
3219
 * put managed surfaces in non-local vidmem. Drivers that cannot texture from
 
3220
 * local vidmem SHOULD NOT set this cap.
 
3221
 */
 
3222
#define DDCAPS2_TEXMANINNONLOCALVIDMEM  0x01000000l
 
3223
 
 
3224
/*
 
3225
 * Indicates that the driver supports DX7 type of stereo in at least one mode (which may
 
3226
 * not necessarily be the current mode). Applications should use IDirectDraw7 (or higher)
 
3227
 * ::EnumDisplayModes and check the DDSURFACEDESC.ddsCaps.dwCaps2 field for the presence of
 
3228
 * DDSCAPS2_STEREOSURFACELEFT to check if a particular mode supports stereo. The application
 
3229
 * can also use IDirectDraw7(or higher)::GetDisplayMode to check the current mode.
 
3230
 */
 
3231
#define DDCAPS2_STEREO                  0x02000000L
 
3232
 
 
3233
/*
 
3234
 * This caps bit is intended for internal DirectDraw use.
 
3235
 * -It is only valid if DDCAPS2_NONLOCALVIDMEMCAPS is set.
 
3236
 * -If this bit is set, then DDCAPS_CANBLTSYSMEM MUST be set by the driver (and
 
3237
 *  all the assoicated system memory blt caps must be correct).
 
3238
 * -It implies that the system->video blt caps in DDCAPS also apply to system to
 
3239
 *  nonlocal blts. I.e. the dwSVBCaps, dwSVBCKeyCaps, dwSVBFXCaps and dwSVBRops
 
3240
 *  members of DDCAPS (DDCORECAPS) are filled in correctly.
 
3241
 * -Any blt from system to nonlocal memory that matches these caps bits will
 
3242
 *  be passed to the driver.
 
3243
 *
 
3244
 * NOTE: This is intended to enable the driver itself to do efficient reordering
 
3245
 * of textures. This is NOT meant to imply that hardware can write into AGP memory.
 
3246
 * This operation is not currently supported.
 
3247
 */
 
3248
#define DDCAPS2_SYSTONONLOCAL_AS_SYSTOLOCAL   0x04000000L
 
3249
 
 
3250
/*
 
3251
 * Indicates that the driver can support PUREHAL.
 
3252
 */
 
3253
#define DDCAPS2_PUREHAL                       0x08000000L
 
3254
 
 
3255
 
 
3256
/****************************************************************************
 
3257
 *
 
3258
 * DIRECTDRAW FX ALPHA CAPABILITY FLAGS
 
3259
 *
 
3260
 ****************************************************************************/
 
3261
 
 
3262
/*
 
3263
 * Supports alpha blending around the edge of a source color keyed surface.
 
3264
 * For Blt.
 
3265
 */
 
3266
#define DDFXALPHACAPS_BLTALPHAEDGEBLEND         0x00000001l
 
3267
 
 
3268
/*
 
3269
 * Supports alpha information in the pixel format.  The bit depth of alpha
 
3270
 * information in the pixel format can be 1,2,4, or 8.  The alpha value becomes
 
3271
 * more opaque as the alpha value increases.  (0 is transparent.)
 
3272
 * For Blt.
 
3273
 */
 
3274
#define DDFXALPHACAPS_BLTALPHAPIXELS            0x00000002l
 
3275
 
 
3276
/*
 
3277
 * Supports alpha information in the pixel format.  The bit depth of alpha
 
3278
 * information in the pixel format can be 1,2,4, or 8.  The alpha value
 
3279
 * becomes more transparent as the alpha value increases.  (0 is opaque.)
 
3280
 * This flag can only be set if DDCAPS_ALPHA is set.
 
3281
 * For Blt.
 
3282
 */
 
3283
#define DDFXALPHACAPS_BLTALPHAPIXELSNEG         0x00000004l
 
3284
 
 
3285
/*
 
3286
 * Supports alpha only surfaces.  The bit depth of an alpha only surface can be
 
3287
 * 1,2,4, or 8.  The alpha value becomes more opaque as the alpha value increases.
 
3288
 * (0 is transparent.)
 
3289
 * For Blt.
 
3290
 */
 
3291
#define DDFXALPHACAPS_BLTALPHASURFACES          0x00000008l
 
3292
 
 
3293
/*
 
3294
 * The depth of the alpha channel data can range can be 1,2,4, or 8.
 
3295
 * The NEG suffix indicates that this alpha channel becomes more transparent
 
3296
 * as the alpha value increases. (0 is opaque.)  This flag can only be set if
 
3297
 * DDCAPS_ALPHA is set.
 
3298
 * For Blt.
 
3299
 */
 
3300
#define DDFXALPHACAPS_BLTALPHASURFACESNEG       0x00000010l
 
3301
 
 
3302
/*
 
3303
 * Supports alpha blending around the edge of a source color keyed surface.
 
3304
 * For Overlays.
 
3305
 */
 
3306
#define DDFXALPHACAPS_OVERLAYALPHAEDGEBLEND     0x00000020l
 
3307
 
 
3308
/*
 
3309
 * Supports alpha information in the pixel format.  The bit depth of alpha
 
3310
 * information in the pixel format can be 1,2,4, or 8.  The alpha value becomes
 
3311
 * more opaque as the alpha value increases.  (0 is transparent.)
 
3312
 * For Overlays.
 
3313
 */
 
3314
#define DDFXALPHACAPS_OVERLAYALPHAPIXELS        0x00000040l
 
3315
 
 
3316
/*
 
3317
 * Supports alpha information in the pixel format.  The bit depth of alpha
 
3318
 * information in the pixel format can be 1,2,4, or 8.  The alpha value
 
3319
 * becomes more transparent as the alpha value increases.  (0 is opaque.)
 
3320
 * This flag can only be set if DDCAPS_ALPHA is set.
 
3321
 * For Overlays.
 
3322
 */
 
3323
#define DDFXALPHACAPS_OVERLAYALPHAPIXELSNEG     0x00000080l
 
3324
 
 
3325
/*
 
3326
 * Supports alpha only surfaces.  The bit depth of an alpha only surface can be
 
3327
 * 1,2,4, or 8.  The alpha value becomes more opaque as the alpha value increases.
 
3328
 * (0 is transparent.)
 
3329
 * For Overlays.
 
3330
 */
 
3331
#define DDFXALPHACAPS_OVERLAYALPHASURFACES      0x00000100l
 
3332
 
 
3333
/*
 
3334
 * The depth of the alpha channel data can range can be 1,2,4, or 8.
 
3335
 * The NEG suffix indicates that this alpha channel becomes more transparent
 
3336
 * as the alpha value increases. (0 is opaque.)  This flag can only be set if
 
3337
 * DDCAPS_ALPHA is set.
 
3338
 * For Overlays.
 
3339
 */
 
3340
#define DDFXALPHACAPS_OVERLAYALPHASURFACESNEG   0x00000200l
 
3341
 
 
3342
#if DIRECTDRAW_VERSION < 0x0600
 
3343
#endif  //DIRECTDRAW_VERSION
 
3344
 
 
3345
 
 
3346
/****************************************************************************
 
3347
 *
 
3348
 * DIRECTDRAW FX CAPABILITY FLAGS
 
3349
 *
 
3350
 ****************************************************************************/
 
3351
 
 
3352
/*
 
3353
 * Uses arithmetic operations to stretch and shrink surfaces during blt
 
3354
 * rather than pixel doubling techniques.  Along the Y axis.
 
3355
 */
 
3356
#define DDFXCAPS_BLTARITHSTRETCHY       0x00000020l
 
3357
 
 
3358
/*
 
3359
 * Uses arithmetic operations to stretch during blt
 
3360
 * rather than pixel doubling techniques.  Along the Y axis. Only
 
3361
 * works for x1, x2, etc.
 
3362
 */
 
3363
#define DDFXCAPS_BLTARITHSTRETCHYN      0x00000010l
 
3364
 
 
3365
/*
 
3366
 * Supports mirroring left to right in blt.
 
3367
 */
 
3368
#define DDFXCAPS_BLTMIRRORLEFTRIGHT     0x00000040l
 
3369
 
 
3370
/*
 
3371
 * Supports mirroring top to bottom in blt.
 
3372
 */
 
3373
#define DDFXCAPS_BLTMIRRORUPDOWN        0x00000080l
 
3374
 
 
3375
/*
 
3376
 * Supports arbitrary rotation for blts.
 
3377
 */
 
3378
#define DDFXCAPS_BLTROTATION            0x00000100l
 
3379
 
 
3380
/*
 
3381
 * Supports 90 degree rotations for blts.
 
3382
 */
 
3383
#define DDFXCAPS_BLTROTATION90          0x00000200l
 
3384
 
 
3385
/*
 
3386
 * DirectDraw supports arbitrary shrinking of a surface along the
 
3387
 * x axis (horizontal direction) for blts.
 
3388
 */
 
3389
#define DDFXCAPS_BLTSHRINKX             0x00000400l
 
3390
 
 
3391
/*
 
3392
 * DirectDraw supports integer shrinking (1x,2x,) of a surface
 
3393
 * along the x axis (horizontal direction) for blts.
 
3394
 */
 
3395
#define DDFXCAPS_BLTSHRINKXN            0x00000800l
 
3396
 
 
3397
/*
 
3398
 * DirectDraw supports arbitrary shrinking of a surface along the
 
3399
 * y axis (horizontal direction) for blts.
 
3400
 */
 
3401
#define DDFXCAPS_BLTSHRINKY             0x00001000l
 
3402
 
 
3403
/*
 
3404
 * DirectDraw supports integer shrinking (1x,2x,) of a surface
 
3405
 * along the y axis (vertical direction) for blts.
 
3406
 */
 
3407
#define DDFXCAPS_BLTSHRINKYN            0x00002000l
 
3408
 
 
3409
/*
 
3410
 * DirectDraw supports arbitrary stretching of a surface along the
 
3411
 * x axis (horizontal direction) for blts.
 
3412
 */
 
3413
#define DDFXCAPS_BLTSTRETCHX            0x00004000l
 
3414
 
 
3415
/*
 
3416
 * DirectDraw supports integer stretching (1x,2x,) of a surface
 
3417
 * along the x axis (horizontal direction) for blts.
 
3418
 */
 
3419
#define DDFXCAPS_BLTSTRETCHXN           0x00008000l
 
3420
 
 
3421
/*
 
3422
 * DirectDraw supports arbitrary stretching of a surface along the
 
3423
 * y axis (horizontal direction) for blts.
 
3424
 */
 
3425
#define DDFXCAPS_BLTSTRETCHY            0x00010000l
 
3426
 
 
3427
/*
 
3428
 * DirectDraw supports integer stretching (1x,2x,) of a surface
 
3429
 * along the y axis (vertical direction) for blts.
 
3430
 */
 
3431
#define DDFXCAPS_BLTSTRETCHYN           0x00020000l
 
3432
 
 
3433
/*
 
3434
 * Uses arithmetic operations to stretch and shrink surfaces during
 
3435
 * overlay rather than pixel doubling techniques.  Along the Y axis
 
3436
 * for overlays.
 
3437
 */
 
3438
#define DDFXCAPS_OVERLAYARITHSTRETCHY   0x00040000l
 
3439
 
 
3440
/*
 
3441
 * Uses arithmetic operations to stretch surfaces during
 
3442
 * overlay rather than pixel doubling techniques.  Along the Y axis
 
3443
 * for overlays. Only works for x1, x2, etc.
 
3444
 */
 
3445
#define DDFXCAPS_OVERLAYARITHSTRETCHYN  0x00000008l
 
3446
 
 
3447
/*
 
3448
 * DirectDraw supports arbitrary shrinking of a surface along the
 
3449
 * x axis (horizontal direction) for overlays.
 
3450
 */
 
3451
#define DDFXCAPS_OVERLAYSHRINKX         0x00080000l
 
3452
 
 
3453
/*
 
3454
 * DirectDraw supports integer shrinking (1x,2x,) of a surface
 
3455
 * along the x axis (horizontal direction) for overlays.
 
3456
 */
 
3457
#define DDFXCAPS_OVERLAYSHRINKXN        0x00100000l
 
3458
 
 
3459
/*
 
3460
 * DirectDraw supports arbitrary shrinking of a surface along the
 
3461
 * y axis (horizontal direction) for overlays.
 
3462
 */
 
3463
#define DDFXCAPS_OVERLAYSHRINKY         0x00200000l
 
3464
 
 
3465
/*
 
3466
 * D