Mercurial > might-and-magic-trilogy

comparison lib/legacy_dx/ddraw.h @ 0:8b8875f5b359

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Initial commit
author Nomad
date Fri, 05 Oct 2012 16:07:14 +0200
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:8b8875f5b359
1 /*==========================================================================;
2 *
3 * Copyright (C) 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 * Indicates that all surfaces in this creation chain should be given an alpha channel.
2903 * This flag will be set on primary surface chains that may have no explicit pixel format
2904 * (and thus take on the format of the current display mode).
2905 * The driver should infer that all these surfaces have a format having an alpha channel.
2906 * (e.g. assume D3DFMT_A8R8G8B8 if the display mode is x888.)
2907 */
2908 #define DDSCAPS2_ENABLEALPHACHANNEL 0x20000000L
2909
2910 /*
2911 * Indicates that all surfaces in this creation chain is extended primary surface format.
2912 * This flag will be set on extended primary surface chains that always have explicit pixel
2913 * format and the pixel format is typically GDI (Graphics Device Interface) couldn't handle,
2914 * thus only used with fullscreen application. (e.g. D3DFMT_A2R10G10B10 format)
2915 */
2916 #define DDSCAPS2_EXTENDEDFORMATPRIMARY 0x40000000L
2917
2918 /*
2919 * Indicates that all surfaces in this creation chain is additional primary surface.
2920 * This flag will be set on primary surface chains which must present on the adapter
2921 * id provided on dwCaps4. Typically this will be used to create secondary primary surface
2922 * on DualView display adapter.
2923 */
2924 #define DDSCAPS2_ADDITIONALPRIMARY 0x80000000L
2925
2926 /*
2927 * This is a mask that indicates the set of bits that may be set
2928 * at createsurface time to indicate number of samples per pixel
2929 * when multisampling
2930 */
2931 #define DDSCAPS3_MULTISAMPLE_MASK 0x0000001FL
2932
2933 /*
2934 * This is a mask that indicates the set of bits that may be set
2935 * at createsurface time to indicate the quality level of rendering
2936 * for the current number of samples per pixel
2937 */
2938 #define DDSCAPS3_MULTISAMPLE_QUALITY_MASK 0x000000E0L
2939 #define DDSCAPS3_MULTISAMPLE_QUALITY_SHIFT 5
2940
2941 /*
2942 * This bit is reserved for internal use
2943 */
2944 #define DDSCAPS3_RESERVED1 0x00000100L
2945
2946 /*
2947 * This bit is reserved for internal use
2948 */
2949 #define DDSCAPS3_RESERVED2 0x00000200L
2950
2951 /*
2952 * This indicates whether this surface has light-weight miplevels
2953 */
2954 #define DDSCAPS3_LIGHTWEIGHTMIPMAP 0x00000400L
2955
2956 /*
2957 * This indicates that the mipsublevels for this surface are auto-generated
2958 */
2959 #define DDSCAPS3_AUTOGENMIPMAP 0x00000800L
2960
2961 /*
2962 * This indicates that the mipsublevels for this surface are auto-generated
2963 */
2964 #define DDSCAPS3_DMAP 0x00001000L
2965
2966
2967 /****************************************************************************
2968 *
2969 * DIRECTDRAW DRIVER CAPABILITY FLAGS
2970 *
2971 ****************************************************************************/
2972
2973 /*
2974 * Display hardware has 3D acceleration.
2975 */
2976 #define DDCAPS_3D 0x00000001l
2977
2978 /*
2979 * Indicates that DirectDraw will support only dest rectangles that are aligned
2980 * on DIRECTDRAWCAPS.dwAlignBoundaryDest boundaries of the surface, respectively.
2981 * READ ONLY.
2982 */
2983 #define DDCAPS_ALIGNBOUNDARYDEST 0x00000002l
2984
2985 /*
2986 * Indicates that DirectDraw will support only source rectangles whose sizes in
2987 * BYTEs are DIRECTDRAWCAPS.dwAlignSizeDest multiples, respectively. READ ONLY.
2988 */
2989 #define DDCAPS_ALIGNSIZEDEST 0x00000004l
2990 /*
2991 * Indicates that DirectDraw will support only source rectangles that are aligned
2992 * on DIRECTDRAWCAPS.dwAlignBoundarySrc boundaries of the surface, respectively.
2993 * READ ONLY.
2994 */
2995 #define DDCAPS_ALIGNBOUNDARYSRC 0x00000008l
2996
2997 /*
2998 * Indicates that DirectDraw will support only source rectangles whose sizes in
2999 * BYTEs are DIRECTDRAWCAPS.dwAlignSizeSrc multiples, respectively. READ ONLY.
3000 */
3001 #define DDCAPS_ALIGNSIZESRC 0x00000010l
3002
3003 /*
3004 * Indicates that DirectDraw will create video memory surfaces that have a stride
3005 * alignment equal to DIRECTDRAWCAPS.dwAlignStride. READ ONLY.
3006 */
3007 #define DDCAPS_ALIGNSTRIDE 0x00000020l
3008
3009 /*
3010 * Display hardware is capable of blt operations.
3011 */
3012 #define DDCAPS_BLT 0x00000040l
3013
3014 /*
3015 * Display hardware is capable of asynchronous blt operations.
3016 */
3017 #define DDCAPS_BLTQUEUE 0x00000080l
3018
3019 /*
3020 * Display hardware is capable of color space conversions during the blt operation.
3021 */
3022 #define DDCAPS_BLTFOURCC 0x00000100l
3023
3024 /*
3025 * Display hardware is capable of stretching during blt operations.
3026 */
3027 #define DDCAPS_BLTSTRETCH 0x00000200l
3028
3029 /*
3030 * Display hardware is shared with GDI.
3031 */
3032 #define DDCAPS_GDI 0x00000400l
3033
3034 /*
3035 * Display hardware can overlay.
3036 */
3037 #define DDCAPS_OVERLAY 0x00000800l
3038
3039 /*
3040 * Set if display hardware supports overlays but can not clip them.
3041 */
3042 #define DDCAPS_OVERLAYCANTCLIP 0x00001000l
3043
3044 /*
3045 * Indicates that overlay hardware is capable of color space conversions during
3046 * the overlay operation.
3047 */
3048 #define DDCAPS_OVERLAYFOURCC 0x00002000l
3049
3050 /*
3051 * Indicates that stretching can be done by the overlay hardware.
3052 */
3053 #define DDCAPS_OVERLAYSTRETCH 0x00004000l
3054
3055 /*
3056 * Indicates that unique DirectDrawPalettes can be created for DirectDrawSurfaces
3057 * other than the primary surface.
3058 */
3059 #define DDCAPS_PALETTE 0x00008000l
3060
3061 /*
3062 * Indicates that palette changes can be syncd with the veritcal refresh.
3063 */
3064 #define DDCAPS_PALETTEVSYNC 0x00010000l
3065
3066 /*
3067 * Display hardware can return the current scan line.
3068 */
3069 #define DDCAPS_READSCANLINE 0x00020000l
3070
3071
3072 /*
3073 * This flag used to bo DDCAPS_STEREOVIEW, which is now obsolete
3074 */
3075 #define DDCAPS_RESERVED1 0x00040000l
3076
3077 /*
3078 * Display hardware is capable of generating a vertical blank interrupt.
3079 */
3080 #define DDCAPS_VBI 0x00080000l
3081
3082 /*
3083 * Supports the use of z buffers with blt operations.
3084 */
3085 #define DDCAPS_ZBLTS 0x00100000l
3086
3087 /*
3088 * Supports Z Ordering of overlays.
3089 */
3090 #define DDCAPS_ZOVERLAYS 0x00200000l
3091
3092 /*
3093 * Supports color key
3094 */
3095 #define DDCAPS_COLORKEY 0x00400000l
3096
3097 /*
3098 * Supports alpha surfaces
3099 */
3100 #define DDCAPS_ALPHA 0x00800000l
3101
3102 /*
3103 * colorkey is hardware assisted(DDCAPS_COLORKEY will also be set)
3104 */
3105 #define DDCAPS_COLORKEYHWASSIST 0x01000000l
3106
3107 /*
3108 * no hardware support at all
3109 */
3110 #define DDCAPS_NOHARDWARE 0x02000000l
3111
3112 /*
3113 * Display hardware is capable of color fill with bltter
3114 */
3115 #define DDCAPS_BLTCOLORFILL 0x04000000l
3116
3117 /*
3118 * Display hardware is bank switched, and potentially very slow at
3119 * random access to VRAM.
3120 */
3121 #define DDCAPS_BANKSWITCHED 0x08000000l
3122
3123 /*
3124 * Display hardware is capable of depth filling Z-buffers with bltter
3125 */
3126 #define DDCAPS_BLTDEPTHFILL 0x10000000l
3127
3128 /*
3129 * Display hardware is capable of clipping while bltting.
3130 */
3131 #define DDCAPS_CANCLIP 0x20000000l
3132
3133 /*
3134 * Display hardware is capable of clipping while stretch bltting.
3135 */
3136 #define DDCAPS_CANCLIPSTRETCHED 0x40000000l
3137
3138 /*
3139 * Display hardware is capable of bltting to or from system memory
3140 */
3141 #define DDCAPS_CANBLTSYSMEM 0x80000000l
3142
3143
3144 /****************************************************************************
3145 *
3146 * MORE DIRECTDRAW DRIVER CAPABILITY FLAGS (dwCaps2)
3147 *
3148 ****************************************************************************/
3149
3150 /*
3151 * Display hardware is certified
3152 */
3153 #define DDCAPS2_CERTIFIED 0x00000001l
3154
3155 /*
3156 * Driver cannot interleave 2D operations (lock and blt) to surfaces with
3157 * Direct3D rendering operations between calls to BeginScene() and EndScene()
3158 */
3159 #define DDCAPS2_NO2DDURING3DSCENE 0x00000002l
3160
3161 /*
3162 * Display hardware contains a video port
3163 */
3164 #define DDCAPS2_VIDEOPORT 0x00000004l
3165
3166 /*
3167 * The overlay can be automatically flipped according to the video port
3168 * VSYNCs, providing automatic doubled buffered display of video port
3169 * data using an overlay
3170 */
3171 #define DDCAPS2_AUTOFLIPOVERLAY 0x00000008l
3172
3173 /*
3174 * Overlay can display each field of interlaced data individually while
3175 * it is interleaved in memory without causing jittery artifacts.
3176 */
3177 #define DDCAPS2_CANBOBINTERLEAVED 0x00000010l
3178
3179 /*
3180 * Overlay can display each field of interlaced data individually while
3181 * it is not interleaved in memory without causing jittery artifacts.
3182 */
3183 #define DDCAPS2_CANBOBNONINTERLEAVED 0x00000020l
3184
3185 /*
3186 * The overlay surface contains color controls (brightness, sharpness, etc.)
3187 */
3188 #define DDCAPS2_COLORCONTROLOVERLAY 0x00000040l
3189
3190 /*
3191 * The primary surface contains color controls (gamma, etc.)
3192 */
3193 #define DDCAPS2_COLORCONTROLPRIMARY 0x00000080l
3194
3195 /*
3196 * RGBZ -> RGB supported for 16:16 RGB:Z
3197 */
3198 #define DDCAPS2_CANDROPZ16BIT 0x00000100l
3199
3200 /*
3201 * Driver supports non-local video memory.
3202 */
3203 #define DDCAPS2_NONLOCALVIDMEM 0x00000200l
3204
3205 /*
3206 * Dirver supports non-local video memory but has different capabilities for
3207 * non-local video memory surfaces. If this bit is set then so must
3208 * DDCAPS2_NONLOCALVIDMEM.
3209 */
3210 #define DDCAPS2_NONLOCALVIDMEMCAPS 0x00000400l
3211
3212 /*
3213 * Driver neither requires nor prefers surfaces to be pagelocked when performing
3214 * blts involving system memory surfaces
3215 */
3216 #define DDCAPS2_NOPAGELOCKREQUIRED 0x00000800l
3217
3218 /*
3219 * Driver can create surfaces which are wider than the primary surface
3220 */
3221 #define DDCAPS2_WIDESURFACES 0x00001000l
3222
3223 /*
3224 * Driver supports bob without using a video port by handling the
3225 * DDFLIP_ODD and DDFLIP_EVEN flags specified in Flip.
3226 */
3227 #define DDCAPS2_CANFLIPODDEVEN 0x00002000l
3228
3229 /*
3230 * Driver supports bob using hardware
3231 */
3232 #define DDCAPS2_CANBOBHARDWARE 0x00004000l
3233
3234 /*
3235 * Driver supports bltting any FOURCC surface to another surface of the same FOURCC
3236 */
3237 #define DDCAPS2_COPYFOURCC 0x00008000l
3238
3239
3240 /*
3241 * Driver supports loadable gamma ramps for the primary surface
3242 */
3243 #define DDCAPS2_PRIMARYGAMMA 0x00020000l
3244
3245 /*
3246 * Driver can render in windowed mode.
3247 */
3248 #define DDCAPS2_CANRENDERWINDOWED 0x00080000l
3249
3250 /*
3251 * A calibrator is available to adjust the gamma ramp according to the
3252 * physical display properties so that the result will be identical on
3253 * all calibrated systems.
3254 */
3255 #define DDCAPS2_CANCALIBRATEGAMMA 0x00100000l
3256
3257 /*
3258 * Indicates that the driver will respond to DDFLIP_INTERVALn flags
3259 */
3260 #define DDCAPS2_FLIPINTERVAL 0x00200000l
3261
3262 /*
3263 * Indicates that the driver will respond to DDFLIP_NOVSYNC
3264 */
3265 #define DDCAPS2_FLIPNOVSYNC 0x00400000l
3266
3267 /*
3268 * Driver supports management of video memory, if this flag is ON,
3269 * driver manages the texture if requested with DDSCAPS2_TEXTUREMANAGE on
3270 * DirectX manages the texture if this flag is OFF and surface has DDSCAPS2_TEXTUREMANAGE on
3271 */
3272 #define DDCAPS2_CANMANAGETEXTURE 0x00800000l
3273
3274 /*
3275 * The Direct3D texture manager uses this cap to decide whether to put managed
3276 * surfaces in non-local video memory. If the cap is set, the texture manager will
3277 * put managed surfaces in non-local vidmem. Drivers that cannot texture from
3278 * local vidmem SHOULD NOT set this cap.
3279 */
3280 #define DDCAPS2_TEXMANINNONLOCALVIDMEM 0x01000000l
3281
3282 /*
3283 * Indicates that the driver supports DX7 type of stereo in at least one mode (which may
3284 * not necessarily be the current mode). Applications should use IDirectDraw7 (or higher)
3285 * ::EnumDisplayModes and check the DDSURFACEDESC.ddsCaps.dwCaps2 field for the presence of
3286 * DDSCAPS2_STEREOSURFACELEFT to check if a particular mode supports stereo. The application
3287 * can also use IDirectDraw7(or higher)::GetDisplayMode to check the current mode.
3288 */
3289 #define DDCAPS2_STEREO 0x02000000L
3290
3291 /*
3292 * This caps bit is intended for internal DirectDraw use.
3293 * -It is only valid if DDCAPS2_NONLOCALVIDMEMCAPS is set.
3294 * -If this bit is set, then DDCAPS_CANBLTSYSMEM MUST be set by the driver (and
3295 * all the assoicated system memory blt caps must be correct).
3296 * -It implies that the system->video blt caps in DDCAPS also apply to system to
3297 * nonlocal blts. I.e. the dwSVBCaps, dwSVBCKeyCaps, dwSVBFXCaps and dwSVBRops
3298 * members of DDCAPS (DDCORECAPS) are filled in correctly.
3299 * -Any blt from system to nonlocal memory that matches these caps bits will
3300 * be passed to the driver.
3301 *
3302 * NOTE: This is intended to enable the driver itself to do efficient reordering
3303 * of textures. This is NOT meant to imply that hardware can write into AGP memory.
3304 * This operation is not currently supported.
3305 */
3306 #define DDCAPS2_SYSTONONLOCAL_AS_SYSTOLOCAL 0x04000000L
3307
3308 /*
3309 * was DDCAPS2_PUREHAL
3310 */
3311 #define DDCAPS2_RESERVED1 0x08000000L
3312
3313 /*
3314 * Driver supports management of video memory, if this flag is ON,
3315 * driver manages the resource if requested with DDSCAPS2_TEXTUREMANAGE on
3316 * DirectX manages the resource if this flag is OFF and surface has DDSCAPS2_TEXTUREMANAGE on
3317 */
3318 #define DDCAPS2_CANMANAGERESOURCE 0x10000000L
3319
3320 /*
3321 * Driver supports dynamic textures. This will allow the application to set
3322 * D3DUSAGE_DYNAMIC (DDSCAPS2_HINTDYNAMIC for drivers) at texture create time.
3323 * Video memory dynamic textures WILL be lockable by applications. It is
3324 * expected that these locks will be very efficient (which implies that the
3325 * driver should always maintain a linear copy, a pointer to which can be
3326 * quickly handed out to the application).
3327 */
3328 #define DDCAPS2_DYNAMICTEXTURES 0x20000000L
3329
3330 /*
3331 * Driver supports auto-generation of mipmaps.
3332 */
3333 #define DDCAPS2_CANAUTOGENMIPMAP 0x40000000L
3334
3335
3336 /****************************************************************************
3337 *
3338 * DIRECTDRAW FX ALPHA CAPABILITY FLAGS
3339 *
3340 ****************************************************************************/
3341
3342 /*
3343 * Supports alpha blending around the edge of a source color keyed surface.
3344 * For Blt.
3345 */
3346 #define DDFXALPHACAPS_BLTALPHAEDGEBLEND 0x00000001l
3347
3348 /*
3349 * Supports alpha information in the pixel format. The bit depth of alpha
3350 * information in the pixel format can be 1,2,4, or 8. The alpha value becomes
3351 * more opaque as the alpha value increases. (0 is transparent.)
3352 * For Blt.
3353 */
3354 #define DDFXALPHACAPS_BLTALPHAPIXELS 0x00000002l
3355
3356 /*
3357 * Supports alpha information in the pixel format. The bit depth of alpha
3358 * information in the pixel format can be 1,2,4, or 8. The alpha value
3359 * becomes more transparent as the alpha value increases. (0 is opaque.)
3360 * This flag can only be set if DDCAPS_ALPHA is set.
3361 * For Blt.
3362 */
3363 #define DDFXALPHACAPS_BLTALPHAPIXELSNEG 0x00000004l
3364
3365 /*
3366 * Supports alpha only surfaces. The bit depth of an alpha only surface can be
3367 * 1,2,4, or 8. The alpha value becomes more opaque as the alpha value increases.
3368 * (0 is transparent.)
3369 * For Blt.
3370 */
3371 #define DDFXALPHACAPS_BLTALPHASURFACES 0x00000008l
3372
3373 /*
3374 * The depth of the alpha channel data can range can be 1,2,4, or 8.
3375 * The NEG suffix indicates that this alpha channel becomes more transparent
3376 * as the alpha value increases. (0 is opaque.) This flag can only be set if
3377 * DDCAPS_ALPHA is set.
3378 * For Blt.
3379 */
3380 #define DDFXALPHACAPS_BLTALPHASURFACESNEG 0x00000010l
3381
3382 /*
3383 * Supports alpha blending around the edge of a source color keyed surface.
3384 * For Overlays.
3385 */
3386 #define DDFXALPHACAPS_OVERLAYALPHAEDGEBLEND 0x00000020l
3387
3388 /*
3389 * Supports alpha information in the pixel format. The bit depth of alpha
3390 * information in the pixel format can be 1,2,4, or 8. The alpha value becomes
3391 * more opaque as the alpha value increases. (0 is transparent.)
3392 * For Overlays.
3393 */
3394 #define DDFXALPHACAPS_OVERLAYALPHAPIXELS 0x00000040l
3395
3396 /*
3397 * Supports alpha information in the pixel format. The bit depth of alpha
3398 * information in the pixel format can be 1,2,4, or 8. The alpha value
3399 * becomes more transparent as the alpha value increases. (0 is opaque.)
3400 * This flag can only be set if DDCAPS_ALPHA is set.
3401 * For Overlays.
3402 */
3403 #define DDFXALPHACAPS_OVERLAYALPHAPIXELSNEG 0x00000080l
3404
3405 /*
3406 * Supports alpha only surfaces. The bit depth of an alpha only surface can be
3407 * 1,2,4, or 8. The alpha value becomes more opaque as the alpha value increases.
3408 * (0 is transparent.)
3409 * For Overlays.
3410 */
3411 #define DDFXALPHACAPS_OVERLAYALPHASURFACES 0x00000100l
3412
3413 /*
3414 * The depth of the alpha channel data can range can be 1,2,4, or 8.
3415 * The NEG suffix indicates that this alpha channel becomes more transparent
3416 * as the alpha value increases. (0 is opaque.) This flag can only be set if
3417 * DDCAPS_ALPHA is set.
3418 * For Overlays.
3419 */
3420 #define DDFXALPHACAPS_OVERLAYALPHASURFACESNEG 0x00000200l
3421
3422 #if DIRECTDRAW_VERSION < 0x0600
3423 #endif //DIRECTDRAW_VERSION
3424
3425
3426 /****************************************************************************
3427 *
3428 * DIRECTDRAW FX CAPABILITY FLAGS
3429 *
3430 ****************************************************************************/
3431
3432 /*
3433 * Uses arithmetic operations to stretch and shrink surfaces during blt
3434 * rather than pixel doubling techniques. Along the Y axis.
3435 */
3436 #define DDFXCAPS_BLTARITHSTRETCHY 0x00000020l
3437
3438 /*
3439 * Uses arithmetic operations to stretch during blt
3440 * rather than pixel doubling techniques. Along the Y axis. Only
3441 * works for x1, x2, etc.
3442 */
3443 #define DDFXCAPS_BLTARITHSTRETCHYN 0x00000010l
3444
3445 /*
3446 * Supports mirroring left to right in blt.
3447 */
3448 #define DDFXCAPS_BLTMIRRORLEFTRIGHT 0x00000040l
3449
3450 /*
3451 * Supports mirroring top to bottom in blt.
3452 */
3453 #define DDFXCAPS_BLTMIRRORUPDOWN 0x00000080l
3454
3455 /*
3456 * Supports arbitrary rotation for blts.
3457 */
3458 #define DDFXCAPS_BLTROTATION 0x00000100l
3459
3460 /*
3461 * Supports 90 degree rotations for blts.
3462 */
3463 #define DDFXCAPS_BLTROTATION90 0x00000200l
3464
3465 /*
3466 * DirectDraw supports arbitrary shrinking of a surface along the
3467 * x axis (horizontal direction) for blts.
3468 */
3469 #define DDFXCAPS_BLTSHRINKX 0x00000400l
3470
3471 /*
3472 * DirectDraw supports integer shrinking (1x,2x,) of a surface
3473 * along the x axis (horizontal direction) for blts.
3474 */
3475 #define DDFXCAPS_BLTSHRINKXN 0x00000800l
3476
3477 /*
3478 * DirectDraw supports arbitrary shrinking of a surface along the
3479 * y axis (horizontal direction) for blts.
3480 */
3481 #define DDFXCAPS_BLTSHRINKY 0x00001000l
3482
3483 /*
3484 * DirectDraw supports integer shrinking (1x,2x,) of a surface
3485 * along the y axis (vertical direction) for blts.
3486 */
3487 #define DDFXCAPS_BLTSHRINKYN 0x00002000l
3488
3489 /*
3490 * DirectDraw supports arbitrary stretching of a surface along the
3491 * x axis (horizontal direction) for blts.
3492 */
3493 #define DDFXCAPS_BLTSTRETCHX 0x00004000l
3494
3495 /*
3496 * DirectDraw supports integer stretching (1x,2x,) of a surface
3497 * along the x axis (horizontal direction) for blts.
3498 */
3499 #define DDFXCAPS_BLTSTRETCHXN 0x00008000l
3500
3501 /*
3502 * DirectDraw supports arbitrary stretching of a surface along the
3503 * y axis (horizontal direction) for blts.
3504 */
3505 #define DDFXCAPS_BLTSTRETCHY 0x00010000l
3506
3507 /*
3508 * DirectDraw supports integer stretching (1x,2x,) of a surface
3509 * along the y axis (vertical direction) for blts.
3510 */
3511 #define DDFXCAPS_BLTSTRETCHYN 0x00020000l
3512
3513 /*
3514 * Uses arithmetic operations to stretch and shrink surfaces during
3515 * overlay rather than pixel doubling techniques. Along the Y axis
3516 * for overlays.
3517 */
3518 #define DDFXCAPS_OVERLAYARITHSTRETCHY 0x00040000l
3519
3520 /*
3521 * Uses arithmetic operations to stretch surfaces during
3522 * overlay rather than pixel doubling techniques. Along the Y axis
3523 * for overlays. Only works for x1, x2, etc.
3524 */
3525 #define DDFXCAPS_OVERLAYARITHSTRETCHYN 0x00000008l
3526
3527 /*
3528 * DirectDraw supports arbitrary shrinking of a surface along the
3529 * x axis (horizontal direction) for overlays.
3530 */
3531 #define DDFXCAPS_OVERLAYSHRINKX 0x00080000l
3532
3533 /*
3534 * DirectDraw supports integer shrinking (1x,2x,) of a surface
3535 * along the x axis (horizontal direction) for overlays.
3536 */
3537 #define DDFXCAPS_OVERLAYSHRINKXN 0x00100000l
3538
3539 /*
3540 * DirectDraw supports arbitrary shrinking of a surface along the
3541 * y axis (horizontal direction) for overlays.
3542 */
3543 #define DDFXCAPS_OVERLAYSHRINKY 0x00200000l
3544
3545 /*
3546 * DirectDraw supports integer shrinking (1x,2x,) of a surface
3547 * along the y axis (vertical direction) for overlays.
3548 */
3549 #define DDFXCAPS_OVERLAYSHRINKYN 0x00400000l
3550
3551 /*
3552 * DirectDraw supports arbitrary stretching of a surface along the
3553 * x axis (horizontal direction) for overlays.
3554 */
3555 #define DDFXCAPS_OVERLAYSTRETCHX 0x00800000l
3556
3557 /*
3558 * DirectDraw supports integer stretching (1x,2x,) of a surface
3559 * along the x axis (horizontal direction) for overlays.
3560 */
3561 #define DDFXCAPS_OVERLAYSTRETCHXN 0x01000000l
3562
3563 /*
3564 * DirectDraw supports arbitrary stretching of a surface along the
3565 * y axis (horizontal direction) for overlays.
3566 */
3567 #define DDFXCAPS_OVERLAYSTRETCHY 0x02000000l
3568
3569 /*
3570 * DirectDraw supports integer stretching (1x,2x,) of a surface
3571 * along the y axis (vertical direction) for overlays.
3572 */
3573 #define DDFXCAPS_OVERLAYSTRETCHYN 0x04000000l
3574
3575 /*
3576 * DirectDraw supports mirroring of overlays across the vertical axis
3577 */
3578 #define DDFXCAPS_OVERLAYMIRRORLEFTRIGHT 0x08000000l
3579
3580 /*
3581 * DirectDraw supports mirroring of overlays across the horizontal axis
3582 */
3583 #define DDFXCAPS_OVERLAYMIRRORUPDOWN 0x10000000l
3584
3585 /*
3586 * DirectDraw supports deinterlacing of overlay surfaces
3587 */
3588 #define DDFXCAPS_OVERLAYDEINTERLACE 0x20000000l
3589
3590 /*
3591 * Driver can do alpha blending for blits.
3592 */
3593 #define DDFXCAPS_BLTALPHA 0x00000001l
3594
3595
3596 /*
3597 * Driver can do surface-reconstruction filtering for warped blits.
3598 */
3599 #define DDFXCAPS_BLTFILTER DDFXCAPS_BLTARITHSTRETCHY
3600
3601 /*
3602 * Driver can do alpha blending for overlays.
3603 */
3604 #define DDFXCAPS_OVERLAYALPHA 0x00000004l
3605
3606
3607 /*
3608 * Driver can do surface-reconstruction filtering for warped overlays.
3609 */
3610 #define DDFXCAPS_OVERLAYFILTER DDFXCAPS_OVERLAYARITHSTRETCHY
3611
3612 /****************************************************************************
3613 *
3614 * DIRECTDRAW STEREO VIEW CAPABILITIES
3615 *
3616 ****************************************************************************/
3617
3618 /*
3619 * This flag used to be DDSVCAPS_ENIGMA, which is now obsolete
3620 */
3621
3622 #define DDSVCAPS_RESERVED1 0x00000001l
3623
3624 /*
3625 * This flag used to be DDSVCAPS_FLICKER, which is now obsolete
3626 */
3627 #define DDSVCAPS_RESERVED2 0x00000002l
3628
3629 /*
3630 * This flag used to be DDSVCAPS_REDBLUE, which is now obsolete
3631 */
3632 #define DDSVCAPS_RESERVED3 0x00000004l
3633
3634 /*
3635 * This flag used to be DDSVCAPS_SPLIT, which is now obsolete
3636 */
3637 #define DDSVCAPS_RESERVED4 0x00000008l
3638
3639 /*
3640 * The stereo view is accomplished with switching technology
3641 */
3642
3643 #define DDSVCAPS_STEREOSEQUENTIAL 0x00000010L
3644
3645
3646
3647 /****************************************************************************
3648 *
3649 * DIRECTDRAWPALETTE CAPABILITIES
3650 *
3651 ****************************************************************************/
3652
3653 /*
3654 * Index is 4 bits. There are sixteen color entries in the palette table.
3655 */
3656 #define DDPCAPS_4BIT 0x00000001l
3657
3658 /*
3659 * Index is onto a 8 bit color index. This field is only valid with the
3660 * DDPCAPS_1BIT, DDPCAPS_2BIT or DDPCAPS_4BIT capability and the target
3661 * surface is in 8bpp. Each color entry is one byte long and is an index
3662 * into destination surface's 8bpp palette.
3663 */
3664 #define DDPCAPS_8BITENTRIES 0x00000002l
3665
3666 /*
3667 * Index is 8 bits. There are 256 color entries in the palette table.
3668 */
3669 #define DDPCAPS_8BIT 0x00000004l
3670
3671 /*
3672 * Indicates that this DIRECTDRAWPALETTE should use the palette color array
3673 * passed into the lpDDColorArray parameter to initialize the DIRECTDRAWPALETTE
3674 * object.
3675 * This flag is obsolete. DirectDraw always initializes the color array from
3676 * the lpDDColorArray parameter. The definition remains for source-level
3677 * compatibility.
3678 */
3679 #define DDPCAPS_INITIALIZE 0x00000000l
3680
3681 /*
3682 * This palette is the one attached to the primary surface. Changing this
3683 * table has immediate effect on the display unless DDPSETPAL_VSYNC is specified
3684 * and supported.
3685 */
3686 #define DDPCAPS_PRIMARYSURFACE 0x00000010l
3687
3688 /*
3689 * This palette is the one attached to the primary surface left. Changing
3690 * this table has immediate effect on the display for the left eye unless
3691 * DDPSETPAL_VSYNC is specified and supported.
3692 */
3693 #define DDPCAPS_PRIMARYSURFACELEFT 0x00000020l
3694
3695 /*
3696 * This palette can have all 256 entries defined
3697 */
3698 #define DDPCAPS_ALLOW256 0x00000040l
3699
3700 /*
3701 * This palette can have modifications to it synced with the monitors
3702 * refresh rate.
3703 */
3704 #define DDPCAPS_VSYNC 0x00000080l
3705
3706 /*
3707 * Index is 1 bit. There are two color entries in the palette table.
3708 */
3709 #define DDPCAPS_1BIT 0x00000100l
3710
3711 /*
3712 * Index is 2 bit. There are four color entries in the palette table.
3713 */
3714 #define DDPCAPS_2BIT 0x00000200l
3715
3716 /*
3717 * The peFlags member of PALETTEENTRY denotes an 8 bit alpha value
3718 */
3719 #define DDPCAPS_ALPHA 0x00000400l
3720
3721
3722 /****************************************************************************
3723 *
3724 * DIRECTDRAWPALETTE SETENTRY CONSTANTS
3725 *
3726 ****************************************************************************/
3727
3728
3729 /****************************************************************************
3730 *
3731 * DIRECTDRAWPALETTE GETENTRY CONSTANTS
3732 *
3733 ****************************************************************************/
3734
3735 /* 0 is the only legal value */
3736
3737 /****************************************************************************
3738 *
3739 * DIRECTDRAWSURFACE SETPRIVATEDATA CONSTANTS
3740 *
3741 ****************************************************************************/
3742
3743 /*
3744 * The passed pointer is an IUnknown ptr. The cbData argument to SetPrivateData
3745 * must be set to sizeof(IUnknown*). DirectDraw will call AddRef through this
3746 * pointer and Release when the private data is destroyed. This includes when
3747 * the surface or palette is destroyed before such priovate data is destroyed.
3748 */
3749 #define DDSPD_IUNKNOWNPOINTER 0x00000001L
3750
3751 /*
3752 * Private data is only valid for the current state of the object,
3753 * as determined by the uniqueness value.
3754 */
3755 #define DDSPD_VOLATILE 0x00000002L
3756
3757
3758 /****************************************************************************
3759 *
3760 * DIRECTDRAWSURFACE SETPALETTE CONSTANTS
3761 *
3762 ****************************************************************************/
3763
3764
3765 /****************************************************************************
3766 *
3767 * DIRECTDRAW BITDEPTH CONSTANTS
3768 *
3769 * NOTE: These are only used to indicate supported bit depths. These
3770 * are flags only, they are not to be used as an actual bit depth. The
3771 * absolute numbers 1, 2, 4, 8, 16, 24 and 32 are used to indicate actual
3772 * bit depths in a surface or for changing the display mode.
3773 *
3774 ****************************************************************************/
3775
3776 /*
3777 * 1 bit per pixel.
3778 */
3779 #define DDBD_1 0x00004000l
3780
3781 /*
3782 * 2 bits per pixel.
3783 */
3784 #define DDBD_2 0x00002000l
3785
3786 /*
3787 * 4 bits per pixel.
3788 */
3789 #define DDBD_4 0x00001000l
3790
3791 /*
3792 * 8 bits per pixel.
3793 */
3794 #define DDBD_8 0x00000800l
3795
3796 /*
3797 * 16 bits per pixel.
3798 */
3799 #define DDBD_16 0x00000400l
3800
3801 /*
3802 * 24 bits per pixel.
3803 */
3804 #define DDBD_24 0X00000200l
3805
3806 /*
3807 * 32 bits per pixel.
3808 */
3809 #define DDBD_32 0x00000100l
3810
3811 /****************************************************************************
3812 *
3813 * DIRECTDRAWSURFACE SET/GET COLOR KEY FLAGS
3814 *
3815 ****************************************************************************/
3816
3817 /*
3818 * Set if the structure contains a color space. Not set if the structure
3819 * contains a single color key.
3820 */
3821 #define DDCKEY_COLORSPACE 0x00000001l
3822
3823 /*
3824 * Set if the structure specifies a color key or color space which is to be
3825 * used as a destination color key for blt operations.
3826 */
3827 #define DDCKEY_DESTBLT 0x00000002l
3828
3829 /*
3830 * Set if the structure specifies a color key or color space which is to be
3831 * used as a destination color key for overlay operations.
3832 */
3833 #define DDCKEY_DESTOVERLAY 0x00000004l
3834
3835 /*
3836 * Set if the structure specifies a color key or color space which is to be
3837 * used as a source color key for blt operations.
3838 */
3839 #define DDCKEY_SRCBLT 0x00000008l
3840
3841 /*
3842 * Set if the structure specifies a color key or color space which is to be
3843 * used as a source color key for overlay operations.
3844 */
3845 #define DDCKEY_SRCOVERLAY 0x00000010l
3846
3847
3848 /****************************************************************************
3849 *
3850 * DIRECTDRAW COLOR KEY CAPABILITY FLAGS
3851 *
3852 ****************************************************************************/
3853
3854 /*
3855 * Supports transparent blting using a color key to identify the replaceable
3856 * bits of the destination surface for RGB colors.
3857 */
3858 #define DDCKEYCAPS_DESTBLT 0x00000001l
3859
3860 /*
3861 * Supports transparent blting using a color space to identify the replaceable
3862 * bits of the destination surface for RGB colors.
3863 */
3864 #define DDCKEYCAPS_DESTBLTCLRSPACE 0x00000002l
3865
3866 /*
3867 * Supports transparent blting using a color space to identify the replaceable
3868 * bits of the destination surface for YUV colors.
3869 */
3870 #define DDCKEYCAPS_DESTBLTCLRSPACEYUV 0x00000004l
3871
3872 /*
3873 * Supports transparent blting using a color key to identify the replaceable
3874 * bits of the destination surface for YUV colors.
3875 */
3876 #define DDCKEYCAPS_DESTBLTYUV 0x00000008l
3877
3878 /*
3879 * Supports overlaying using colorkeying of the replaceable bits of the surface
3880 * being overlayed for RGB colors.
3881 */
3882 #define DDCKEYCAPS_DESTOVERLAY 0x00000010l
3883
3884 /*
3885 * Supports a color space as the color key for the destination for RGB colors.
3886 */
3887 #define DDCKEYCAPS_DESTOVERLAYCLRSPACE 0x00000020l
3888
3889 /*
3890 * Supports a color space as the color key for the destination for YUV colors.
3891 */
3892 #define DDCKEYCAPS_DESTOVERLAYCLRSPACEYUV 0x00000040l
3893
3894 /*
3895 * Supports only one active destination color key value for visible overlay
3896 * surfaces.
3897 */
3898 #define DDCKEYCAPS_DESTOVERLAYONEACTIVE 0x00000080l
3899
3900 /*
3901 * Supports overlaying using colorkeying of the replaceable bits of the
3902 * surface being overlayed for YUV colors.
3903 */
3904 #define DDCKEYCAPS_DESTOVERLAYYUV 0x00000100l
3905
3906 /*
3907 * Supports transparent blting using the color key for the source with
3908 * this surface for RGB colors.
3909 */
3910 #define DDCKEYCAPS_SRCBLT 0x00000200l
3911
3912 /*
3913 * Supports transparent blting using a color space for the source with
3914 * this surface for RGB colors.
3915 */
3916 #define DDCKEYCAPS_SRCBLTCLRSPACE 0x00000400l
3917
3918 /*
3919 * Supports transparent blting using a color space for the source with
3920 * this surface for YUV colors.
3921 */
3922 #define DDCKEYCAPS_SRCBLTCLRSPACEYUV 0x00000800l
3923
3924 /*
3925 * Supports transparent blting using the color key for the source with
3926 * this surface for YUV colors.
3927 */
3928 #define DDCKEYCAPS_SRCBLTYUV 0x00001000l
3929
3930 /*
3931 * Supports overlays using the color key for the source with this
3932 * overlay surface for RGB colors.
3933 */
3934 #define DDCKEYCAPS_SRCOVERLAY 0x00002000l
3935
3936 /*
3937 * Supports overlays using a color space as the source color key for
3938 * the overlay surface for RGB colors.
3939 */
3940 #define DDCKEYCAPS_SRCOVERLAYCLRSPACE 0x00004000l
3941
3942 /*
3943 * Supports overlays using a color space as the source color key for
3944 * the overlay surface for YUV colors.
3945 */
3946 #define DDCKEYCAPS_SRCOVERLAYCLRSPACEYUV 0x00008000l
3947
3948 /*
3949 * Supports only one active source color key value for visible
3950 * overlay surfaces.
3951 */
3952 #define DDCKEYCAPS_SRCOVERLAYONEACTIVE 0x00010000l
3953
3954 /*
3955 * Supports overlays using the color key for the source with this
3956 * overlay surface for YUV colors.
3957 */
3958 #define DDCKEYCAPS_SRCOVERLAYYUV 0x00020000l
3959
3960 /*
3961 * there are no bandwidth trade-offs for using colorkey with an overlay
3962 */
3963 #define DDCKEYCAPS_NOCOSTOVERLAY 0x00040000l
3964
3965
3966 /****************************************************************************
3967 *
3968 * DIRECTDRAW PIXELFORMAT FLAGS
3969 *
3970 ****************************************************************************/
3971
3972 /*
3973 * The surface has alpha channel information in the pixel format.
3974 */
3975 #define DDPF_ALPHAPIXELS 0x00000001l
3976
3977 /*
3978 * The pixel format contains alpha only information
3979 */
3980 #define DDPF_ALPHA 0x00000002l
3981
3982 /*
3983 * The FourCC code is valid.
3984 */
3985 #define DDPF_FOURCC 0x00000004l
3986
3987 /*
3988 * The surface is 4-bit color indexed.
3989 */
3990 #define DDPF_PALETTEINDEXED4 0x00000008l
3991
3992 /*
3993 * The surface is indexed into a palette which stores indices
3994 * into the destination surface's 8-bit palette.
3995 */
3996 #define DDPF_PALETTEINDEXEDTO8 0x00000010l
3997
3998 /*
3999 * The surface is 8-bit color indexed.
4000 */
4001 #define DDPF_PALETTEINDEXED8 0x00000020l
4002
4003 /*
4004 * The RGB data in the pixel format structure is valid.
4005 */
4006 #define DDPF_RGB 0x00000040l
4007
4008 /*
4009 * The surface will accept pixel data in the format specified
4010 * and compress it during the write.
4011 */
4012 #define DDPF_COMPRESSED 0x00000080l
4013
4014 /*
4015 * The surface will accept RGB data and translate it during
4016 * the write to YUV data. The format of the data to be written
4017 * will be contained in the pixel format structure. The DDPF_RGB
4018 * flag will be set.
4019 */
4020 #define DDPF_RGBTOYUV 0x00000100l
4021
4022 /*
4023 * pixel format is YUV - YUV data in pixel format struct is valid
4024 */
4025 #define DDPF_YUV 0x00000200l
4026
4027 /*
4028 * pixel format is a z buffer only surface
4029 */
4030 #define DDPF_ZBUFFER 0x00000400l
4031
4032 /*
4033 * The surface is 1-bit color indexed.
4034 */
4035 #define DDPF_PALETTEINDEXED1 0x00000800l
4036
4037 /*
4038 * The surface is 2-bit color indexed.
4039 */
4040 #define DDPF_PALETTEINDEXED2 0x00001000l
4041
4042 /*
4043 * The surface contains Z information in the pixels
4044 */
4045 #define DDPF_ZPIXELS 0x00002000l
4046
4047 /*
4048 * The surface contains stencil information along with Z
4049 */
4050 #define DDPF_STENCILBUFFER 0x00004000l
4051
4052 /*
4053 * Premultiplied alpha format -- the color components have been
4054 * premultiplied by the alpha component.
4055 */
4056 #define DDPF_ALPHAPREMULT 0x00008000l
4057
4058
4059 /*
4060 * Luminance data in the pixel format is valid.
4061 * Use this flag for luminance-only or luminance+alpha surfaces,
4062 * the bit depth is then ddpf.dwLuminanceBitCount.
4063 */
4064 #define DDPF_LUMINANCE 0x00020000l
4065
4066 /*
4067 * Luminance data in the pixel format is valid.
4068 * Use this flag when hanging luminance off bumpmap surfaces,
4069 * the bit mask for the luminance portion of the pixel is then
4070 * ddpf.dwBumpLuminanceBitMask
4071 */
4072 #define DDPF_BUMPLUMINANCE 0x00040000l
4073
4074 /*
4075 * Bump map dUdV data in the pixel format is valid.
4076 */
4077 #define DDPF_BUMPDUDV 0x00080000l
4078
4079
4080 /*===========================================================================
4081 *
4082 *
4083 * DIRECTDRAW CALLBACK FLAGS
4084 *
4085 *
4086 *==========================================================================*/
4087
4088 /****************************************************************************
4089 *
4090 * DIRECTDRAW ENUMSURFACES FLAGS
4091 *
4092 ****************************************************************************/
4093
4094 /*
4095 * Enumerate all of the surfaces that meet the search criterion.
4096 */
4097 #define DDENUMSURFACES_ALL 0x00000001l
4098
4099 /*
4100 * A search hit is a surface that matches the surface description.
4101 */
4102 #define DDENUMSURFACES_MATCH 0x00000002l
4103
4104 /*
4105 * A search hit is a surface that does not match the surface description.
4106 */
4107 #define DDENUMSURFACES_NOMATCH 0x00000004l
4108
4109 /*
4110 * Enumerate the first surface that can be created which meets the search criterion.
4111 */
4112 #define DDENUMSURFACES_CANBECREATED 0x00000008l
4113
4114 /*
4115 * Enumerate the surfaces that already exist that meet the search criterion.
4116 */
4117 #define DDENUMSURFACES_DOESEXIST 0x00000010l
4118
4119
4120 /****************************************************************************
4121 *
4122 * DIRECTDRAW SETDISPLAYMODE FLAGS
4123 *
4124 ****************************************************************************/
4125
4126 /*
4127 * The desired mode is a standard VGA mode
4128 */
4129 #define DDSDM_STANDARDVGAMODE 0x00000001l
4130
4131
4132 /****************************************************************************
4133 *
4134 * DIRECTDRAW ENUMDISPLAYMODES FLAGS
4135 *
4136 ****************************************************************************/
4137
4138 /*
4139 * Enumerate Modes with different refresh rates. EnumDisplayModes guarantees
4140 * that a particular mode will be enumerated only once. This flag specifies whether
4141 * the refresh rate is taken into account when determining if a mode is unique.
4142 */
4143 #define DDEDM_REFRESHRATES 0x00000001l
4144
4145 /*
4146 * Enumerate VGA modes. Specify this flag if you wish to enumerate supported VGA
4147 * modes such as mode 0x13 in addition to the usual ModeX modes (which are always
4148 * enumerated if the application has previously called SetCooperativeLevel with the
4149 * DDSCL_ALLOWMODEX flag set).
4150 */
4151 #define DDEDM_STANDARDVGAMODES 0x00000002L
4152
4153
4154 /****************************************************************************
4155 *
4156 * DIRECTDRAW SETCOOPERATIVELEVEL FLAGS
4157 *
4158 ****************************************************************************/
4159
4160 /*
4161 * Exclusive mode owner will be responsible for the entire primary surface.
4162 * GDI can be ignored. used with DD
4163 */
4164 #define DDSCL_FULLSCREEN 0x00000001l
4165
4166 /*
4167 * allow CTRL_ALT_DEL to work while in fullscreen exclusive mode
4168 */
4169 #define DDSCL_ALLOWREBOOT 0x00000002l
4170
4171 /*
4172 * prevents DDRAW from modifying the application window.
4173 * prevents DDRAW from minimize/restore the application window on activation.
4174 */
4175 #define DDSCL_NOWINDOWCHANGES 0x00000004l
4176
4177 /*
4178 * app wants to work as a regular Windows application
4179 */
4180 #define DDSCL_NORMAL 0x00000008l
4181
4182 /*
4183 * app wants exclusive access
4184 */
4185 #define DDSCL_EXCLUSIVE 0x00000010l
4186
4187
4188 /*
4189 * app can deal with non-windows display modes
4190 */
4191 #define DDSCL_ALLOWMODEX 0x00000040l
4192
4193 /*
4194 * this window will receive the focus messages
4195 */
4196 #define DDSCL_SETFOCUSWINDOW 0x00000080l
4197
4198 /*
4199 * this window is associated with the DDRAW object and will
4200 * cover the screen in fullscreen mode
4201 */
4202 #define DDSCL_SETDEVICEWINDOW 0x00000100l
4203
4204 /*
4205 * app wants DDRAW to create a window to be associated with the
4206 * DDRAW object
4207 */
4208 #define DDSCL_CREATEDEVICEWINDOW 0x00000200l
4209
4210 /*
4211 * App explicitly asks DDRAW/D3D to be multithread safe. This makes D3D
4212 * take the global crtisec more frequently.
4213 */
4214 #define DDSCL_MULTITHREADED 0x00000400l
4215
4216 /*
4217 * App specifies that it would like to keep the FPU set up for optimal Direct3D
4218 * performance (single precision and exceptions disabled) so Direct3D
4219 * does not need to explicitly set the FPU each time. This is assumed by
4220 * default in DirectX 7. See also DDSCL_FPUPRESERVE
4221 */
4222 #define DDSCL_FPUSETUP 0x00000800l
4223
4224 /*
4225 * App specifies that it needs either double precision FPU or FPU exceptions
4226 * enabled. This makes Direct3D explicitly set the FPU state eah time it is
4227 * called. Setting the flag will reduce Direct3D performance. The flag is
4228 * assumed by default in DirectX 6 and earlier. See also DDSCL_FPUSETUP
4229 */
4230 #define DDSCL_FPUPRESERVE 0x00001000l
4231
4232
4233 /****************************************************************************
4234 *
4235 * DIRECTDRAW BLT FLAGS
4236 *
4237 ****************************************************************************/
4238
4239 /*
4240 * Use the alpha information in the pixel format or the alpha channel surface
4241 * attached to the destination surface as the alpha channel for this blt.
4242 */
4243 #define DDBLT_ALPHADEST 0x00000001l
4244
4245 /*
4246 * Use the dwConstAlphaDest field in the DDBLTFX structure as the alpha channel
4247 * for the destination surface for this blt.
4248 */
4249 #define DDBLT_ALPHADESTCONSTOVERRIDE 0x00000002l
4250
4251 /*
4252 * The NEG suffix indicates that the destination surface becomes more
4253 * transparent as the alpha value increases. (0 is opaque)
4254 */
4255 #define DDBLT_ALPHADESTNEG 0x00000004l
4256
4257 /*
4258 * Use the lpDDSAlphaDest field in the DDBLTFX structure as the alpha
4259 * channel for the destination for this blt.
4260 */
4261 #define DDBLT_ALPHADESTSURFACEOVERRIDE 0x00000008l
4262
4263 /*
4264 * Use the dwAlphaEdgeBlend field in the DDBLTFX structure as the alpha channel
4265 * for the edges of the image that border the color key colors.
4266 */
4267 #define DDBLT_ALPHAEDGEBLEND 0x00000010l
4268
4269 /*
4270 * Use the alpha information in the pixel format or the alpha channel surface
4271 * attached to the source surface as the alpha channel for this blt.
4272 */
4273 #define DDBLT_ALPHASRC 0x00000020l
4274
4275 /*
4276 * Use the dwConstAlphaSrc field in the DDBLTFX structure as the alpha channel
4277 * for the source for this blt.
4278 */
4279 #define DDBLT_ALPHASRCCONSTOVERRIDE 0x00000040l
4280
4281 /*
4282 * The NEG suffix indicates that the source surface becomes more transparent
4283 * as the alpha value increases. (0 is opaque)
4284 */
4285 #define DDBLT_ALPHASRCNEG 0x00000080l
4286
4287 /*
4288 * Use the lpDDSAlphaSrc field in the DDBLTFX structure as the alpha channel
4289 * for the source for this blt.
4290 */
4291 #define DDBLT_ALPHASRCSURFACEOVERRIDE 0x00000100l
4292
4293 /*
4294 * Do this blt asynchronously through the FIFO in the order received. If
4295 * there is no room in the hardware FIFO fail the call.
4296 */
4297 #define DDBLT_ASYNC 0x00000200l
4298
4299 /*
4300 * Uses the dwFillColor field in the DDBLTFX structure as the RGB color
4301 * to fill the destination rectangle on the destination surface with.
4302 */
4303 #define DDBLT_COLORFILL 0x00000400l
4304
4305 /*
4306 * Uses the dwDDFX field in the DDBLTFX structure to specify the effects
4307 * to use for the blt.
4308 */
4309 #define DDBLT_DDFX 0x00000800l
4310
4311 /*
4312 * Uses the dwDDROPS field in the DDBLTFX structure to specify the ROPS
4313 * that are not part of the Win32 API.
4314 */
4315 #define DDBLT_DDROPS 0x00001000l
4316
4317 /*
4318 * Use the color key associated with the destination surface.
4319 */
4320 #define DDBLT_KEYDEST 0x00002000l
4321
4322 /*
4323 * Use the dckDestColorkey field in the DDBLTFX structure as the color key
4324 * for the destination surface.
4325 */
4326 #define DDBLT_KEYDESTOVERRIDE 0x00004000l
4327
4328 /*
4329 * Use the color key associated with the source surface.
4330 */
4331 #define DDBLT_KEYSRC 0x00008000l
4332
4333 /*
4334 * Use the dckSrcColorkey field in the DDBLTFX structure as the color key
4335 * for the source surface.
4336 */
4337 #define DDBLT_KEYSRCOVERRIDE 0x00010000l
4338
4339 /*
4340 * Use the dwROP field in the DDBLTFX structure for the raster operation
4341 * for this blt. These ROPs are the same as the ones defined in the Win32 API.
4342 */
4343 #define DDBLT_ROP 0x00020000l
4344
4345 /*
4346 * Use the dwRotationAngle field in the DDBLTFX structure as the angle
4347 * (specified in 1/100th of a degree) to rotate the surface.
4348 */
4349 #define DDBLT_ROTATIONANGLE 0x00040000l
4350
4351 /*
4352 * Z-buffered blt using the z-buffers attached to the source and destination
4353 * surfaces and the dwZBufferOpCode field in the DDBLTFX structure as the
4354 * z-buffer opcode.
4355 */
4356 #define DDBLT_ZBUFFER 0x00080000l
4357
4358 /*
4359 * Z-buffered blt using the dwConstDest Zfield and the dwZBufferOpCode field
4360 * in the DDBLTFX structure as the z-buffer and z-buffer opcode respectively
4361 * for the destination.
4362 */
4363 #define DDBLT_ZBUFFERDESTCONSTOVERRIDE 0x00100000l
4364
4365 /*
4366 * Z-buffered blt using the lpDDSDestZBuffer field and the dwZBufferOpCode
4367 * field in the DDBLTFX structure as the z-buffer and z-buffer opcode
4368 * respectively for the destination.
4369 */
4370 #define DDBLT_ZBUFFERDESTOVERRIDE 0x00200000l
4371
4372 /*
4373 * Z-buffered blt using the dwConstSrcZ field and the dwZBufferOpCode field
4374 * in the DDBLTFX structure as the z-buffer and z-buffer opcode respectively
4375 * for the source.
4376 */
4377 #define DDBLT_ZBUFFERSRCCONSTOVERRIDE 0x00400000l
4378
4379 /*
4380 * Z-buffered blt using the lpDDSSrcZBuffer field and the dwZBufferOpCode
4381 * field in the DDBLTFX structure as the z-buffer and z-buffer opcode
4382 * respectively for the source.
4383 */
4384 #define DDBLT_ZBUFFERSRCOVERRIDE 0x00800000l
4385
4386 /*
4387 * wait until the device is ready to handle the blt
4388 * this will cause blt to not return DDERR_WASSTILLDRAWING
4389 */
4390 #define DDBLT_WAIT 0x01000000l
4391
4392 /*
4393 * Uses the dwFillDepth field in the DDBLTFX structure as the depth value
4394 * to fill the destination rectangle on the destination Z-buffer surface
4395 * with.
4396 */
4397 #define DDBLT_DEPTHFILL 0x02000000l
4398
4399
4400 /*
4401 * Return immediately (with DDERR_WASSTILLDRAWING) if the device is not
4402 * ready to schedule the blt at the time Blt() is called.
4403 */
4404 #define DDBLT_DONOTWAIT 0x08000000l
4405
4406 /*
4407 * These flags indicate a presentation blt (i.e. a blt
4408 * that moves surface contents from an offscreen back buffer to the primary
4409 * surface). The driver is not allowed to "queue" more than three such blts.
4410 * The "end" of the presentation blt is indicated, since the
4411 * blt may be clipped, in which case the runtime will call the driver with
4412 * several blts. All blts (even if not clipped) are tagged with DDBLT_PRESENTATION
4413 * and the last (even if not clipped) additionally with DDBLT_LAST_PRESENTATION.
4414 * Thus the true rule is that the driver must not schedule a DDBLT_PRESENTATION
4415 * blt if there are 3 or more DDBLT_PRESENTLAST blts in the hardware pipe.
4416 * If there are such blts in the pipe, the driver should return DDERR_WASSTILLDRAWING
4417 * until the oldest queued DDBLT_LAST_PRESENTATION blts has been retired (i.e. the
4418 * pixels have been actually written to the primary surface). Once the oldest blt
4419 * has been retired, the driver is free to schedule the current blt.
4420 * The goal is to provide a mechanism whereby the device's hardware queue never
4421 * gets more than 3 frames ahead of the frames being generated by the application.
4422 * When excessive queueing occurs, applications become unusable because the application
4423 * visibly lags user input, and such problems make windowed interactive applications impossible.
4424 * Some drivers may not have sufficient knowledge of their hardware's FIFO to know
4425 * when a certain blt has been retired. Such drivers should code cautiously, and
4426 * simply not allow any frames to be queued at all. DDBLT_LAST_PRESENTATION should cause
4427 * such drivers to return DDERR_WASSTILLDRAWING until the accelerator is completely
4428 * finished- exactly as if the application had called Lock on the source surface
4429 * before calling Blt.
4430 * In other words, the driver is allowed and encouraged to
4431 * generate as much latency as it can, but never more than 3 frames worth.
4432 * Implementation detail: Drivers should count blts against the SOURCE surface, not
4433 * against the primary surface. This enables multiple parallel windowed application
4434 * to function more optimally.
4435 * This flag is passed only to DX8 or higher drivers.
4436 *
4437 * APPLICATIONS DO NOT SET THESE FLAGS. THEY ARE SET BY THE DIRECTDRAW RUNTIME.
4438 *
4439 */
4440 #define DDBLT_PRESENTATION 0x10000000l
4441 #define DDBLT_LAST_PRESENTATION 0x20000000l
4442
4443 /*
4444 * If DDBLT_EXTENDED_FLAGS is set, then the driver should re-interpret
4445 * other flags according to the definitions that follow.
4446 * For example, bit 0 (0x00000001L) means DDBLT_ALPHADEST, unless
4447 * DDBLT_EXTENDED_FLAGS is also set, in which case bit 0 means
4448 * DDBLT_EXTENDED_LINEAR_CONTENT.
4449 * Only DirectX9 and higher drivers will be given extended blt flags.
4450 * Only flags explicitly mentioned here should be re-interpreted.
4451 * All other flags retain their original meanings.
4452 *
4453 * List of re-interpreted flags:
4454 *
4455 * Bit Hex value New meaning old meaning
4456 * ---------------------------------------------------------------
4457 * 2 0x00000004 DDBLT_EXTENDED_LINEAR_CONTENT DDBLT_ALPHADESTNEG
4458 * 4 0x00000010 DDBLT_EXTENDED_PRESENTATION_STRETCHFACTOR DDBLT_ALPHAEDGEBLEND
4459 *
4460 *
4461 * NOTE: APPLICATIONS SHOULD NOT SET THIS FLAG. THIS FLAG IS INTENDED
4462 * FOR USE BY THE DIRECT3D RUNTIME.
4463 */
4464 #define DDBLT_EXTENDED_FLAGS 0x40000000l
4465
4466 /*
4467 * EXTENDED FLAG. SEE DEFINITION OF DDBLT_EXTENDED_FLAGS.
4468 * This flag indidcates that the source surface contains content in a
4469 * linear color space. The driver may perform gamma correction to the
4470 * desktop color space (i.e. sRGB, gamma 2.2) as part of this blt.
4471 * If the device can perform such a conversion as part of the copy,
4472 * the driver should also set D3DCAPS3_LINEAR_TO_SRGB_PRESENTATION
4473 *
4474 * NOTE: APPLICATIONS SHOULD NOT SET THIS FLAG. THIS FLAG IS INTENDED
4475 * FOR USE BY THE DIRECT3D RUNTIME. Use IDirect3DSwapChain9::Present
4476 * and specify D3DPRESENT_LINEAR_CONTENT in order to use this functionality.
4477 */
4478 #define DDBLT_EXTENDED_LINEAR_CONTENT 0x00000004l
4479
4480
4481 /****************************************************************************
4482 *
4483 * BLTFAST FLAGS
4484 *
4485 ****************************************************************************/
4486
4487 #define DDBLTFAST_NOCOLORKEY 0x00000000
4488 #define DDBLTFAST_SRCCOLORKEY 0x00000001
4489 #define DDBLTFAST_DESTCOLORKEY 0x00000002
4490 #define DDBLTFAST_WAIT 0x00000010
4491 #define DDBLTFAST_DONOTWAIT 0x00000020
4492
4493 /****************************************************************************
4494 *
4495 * FLIP FLAGS
4496 *
4497 ****************************************************************************/
4498
4499 #define DDFLIP_WAIT 0x00000001L
4500
4501 /*
4502 * Indicates that the target surface contains the even field of video data.
4503 * This flag is only valid with an overlay surface.
4504 */
4505 #define DDFLIP_EVEN 0x00000002L
4506
4507 /*
4508 * Indicates that the target surface contains the odd field of video data.
4509 * This flag is only valid with an overlay surface.
4510 */
4511 #define DDFLIP_ODD 0x00000004L
4512
4513 /*
4514 * Causes DirectDraw to perform the physical flip immediately and return
4515 * to the application. Typically, what was the front buffer but is now the back
4516 * buffer will still be visible (depending on timing) until the next vertical
4517 * retrace. Subsequent operations involving the two flipped surfaces will
4518 * not check to see if the physical flip has finished (i.e. will not return
4519 * DDERR_WASSTILLDRAWING for that reason (but may for other reasons)).
4520 * This allows an application to perform Flips at a higher frequency than the
4521 * monitor refresh rate, but may introduce visible artifacts.
4522 * Only effective if DDCAPS2_FLIPNOVSYNC is set. If that bit is not set,
4523 * DDFLIP_NOVSYNC has no effect.
4524 */
4525 #define DDFLIP_NOVSYNC 0x00000008L
4526
4527
4528 /*
4529 * Flip Interval Flags. These flags indicate how many vertical retraces to wait between
4530 * each flip. The default is one. DirectDraw will return DDERR_WASSTILLDRAWING for each
4531 * surface involved in the flip until the specified number of vertical retraces has
4532 * ocurred. Only effective if DDCAPS2_FLIPINTERVAL is set. If that bit is not set,
4533 * DDFLIP_INTERVALn has no effect.
4534 */
4535
4536 /*
4537 * DirectDraw will flip on every other vertical sync
4538 */
4539 #define DDFLIP_INTERVAL2 0x02000000L
4540
4541
4542 /*
4543 * DirectDraw will flip on every third vertical sync
4544 */
4545 #define DDFLIP_INTERVAL3 0x03000000L
4546
4547
4548 /*
4549 * DirectDraw will flip on every fourth vertical sync
4550 */
4551 #define DDFLIP_INTERVAL4 0x04000000L
4552
4553 /*
4554 * DirectDraw will flip and display a main stereo surface
4555 */
4556 #define DDFLIP_STEREO 0x00000010L
4557
4558 /*
4559 * On IDirectDrawSurface7 and higher interfaces, the default is DDFLIP_WAIT. If you wish
4560 * to override the default and use time when the accelerator is busy (as denoted by
4561 * the DDERR_WASSTILLDRAWING return code) then use DDFLIP_DONOTWAIT.
4562 */
4563 #define DDFLIP_DONOTWAIT 0x00000020L
4564
4565
4566 /****************************************************************************
4567 *
4568 * DIRECTDRAW SURFACE OVERLAY FLAGS
4569 *
4570 ****************************************************************************/
4571
4572 /*
4573 * Use the alpha information in the pixel format or the alpha channel surface
4574 * attached to the destination surface as the alpha channel for the
4575 * destination overlay.
4576 */
4577 #define DDOVER_ALPHADEST 0x00000001l
4578
4579 /*
4580 * Use the dwConstAlphaDest field in the DDOVERLAYFX structure as the
4581 * destination alpha channel for this overlay.
4582 */
4583 #define DDOVER_ALPHADESTCONSTOVERRIDE 0x00000002l
4584
4585 /*
4586 * The NEG suffix indicates that the destination surface becomes more
4587 * transparent as the alpha value increases.
4588 */
4589 #define DDOVER_ALPHADESTNEG 0x00000004l
4590
4591 /*
4592 * Use the lpDDSAlphaDest field in the DDOVERLAYFX structure as the alpha
4593 * channel destination for this overlay.
4594 */
4595 #define DDOVER_ALPHADESTSURFACEOVERRIDE 0x00000008l
4596
4597 /*
4598 * Use the dwAlphaEdgeBlend field in the DDOVERLAYFX structure as the alpha
4599 * channel for the edges of the image that border the color key colors.
4600 */
4601 #define DDOVER_ALPHAEDGEBLEND 0x00000010l
4602
4603 /*
4604 * Use the alpha information in the pixel format or the alpha channel surface
4605 * attached to the source surface as the source alpha channel for this overlay.
4606 */
4607 #define DDOVER_ALPHASRC 0x00000020l
4608
4609 /*
4610 * Use the dwConstAlphaSrc field in the DDOVERLAYFX structure as the source
4611 * alpha channel for this overlay.
4612 */
4613 #define DDOVER_ALPHASRCCONSTOVERRIDE 0x00000040l
4614
4615 /*
4616 * The NEG suffix indicates that the source surface becomes more transparent
4617 * as the alpha value increases.
4618 */
4619 #define DDOVER_ALPHASRCNEG 0x00000080l
4620
4621 /*
4622 * Use the lpDDSAlphaSrc field in the DDOVERLAYFX structure as the alpha channel
4623 * source for this overlay.
4624 */
4625 #define DDOVER_ALPHASRCSURFACEOVERRIDE 0x00000100l
4626
4627 /*
4628 * Turn this overlay off.
4629 */
4630 #define DDOVER_HIDE 0x00000200l
4631
4632 /*
4633 * Use the color key associated with the destination surface.
4634 */
4635 #define DDOVER_KEYDEST 0x00000400l
4636
4637 /*
4638 * Use the dckDestColorkey field in the DDOVERLAYFX structure as the color key
4639 * for the destination surface
4640 */
4641 #define DDOVER_KEYDESTOVERRIDE 0x00000800l
4642
4643 /*
4644 * Use the color key associated with the source surface.
4645 */
4646 #define DDOVER_KEYSRC 0x00001000l
4647
4648 /*
4649 * Use the dckSrcColorkey field in the DDOVERLAYFX structure as the color key
4650 * for the source surface.
4651 */
4652 #define DDOVER_KEYSRCOVERRIDE 0x00002000l
4653
4654 /*
4655 * Turn this overlay on.
4656 */
4657 #define DDOVER_SHOW 0x00004000l
4658
4659 /*
4660 * Add a dirty rect to an emulated overlayed surface.
4661 */
4662 #define DDOVER_ADDDIRTYRECT 0x00008000l
4663
4664 /*
4665 * Redraw all dirty rects on an emulated overlayed surface.
4666 */
4667 #define DDOVER_REFRESHDIRTYRECTS 0x00010000l
4668
4669 /*
4670 * Redraw the entire surface on an emulated overlayed surface.
4671 */
4672 #define DDOVER_REFRESHALL 0x00020000l
4673
4674
4675 /*
4676 * Use the overlay FX flags to define special overlay FX
4677 */
4678 #define DDOVER_DDFX 0x00080000l
4679
4680 /*
4681 * Autoflip the overlay when ever the video port autoflips
4682 */
4683 #define DDOVER_AUTOFLIP 0x00100000l
4684
4685 /*
4686 * Display each field of video port data individually without
4687 * causing any jittery artifacts
4688 */
4689 #define DDOVER_BOB 0x00200000l
4690
4691 /*
4692 * Indicates that bob/weave decisions should not be overridden by other
4693 * interfaces.
4694 */
4695 #define DDOVER_OVERRIDEBOBWEAVE 0x00400000l
4696
4697 /*
4698 * Indicates that the surface memory is composed of interleaved fields.
4699 */
4700 #define DDOVER_INTERLEAVED 0x00800000l
4701
4702 /*
4703 * Indicates that bob will be performed using hardware rather than
4704 * software or emulated.
4705 */
4706 #define DDOVER_BOBHARDWARE 0x01000000l
4707
4708 /*
4709 * Indicates that overlay FX structure contains valid ARGB scaling factors.
4710 */
4711 #define DDOVER_ARGBSCALEFACTORS 0x02000000l
4712
4713 /*
4714 * Indicates that ARGB scaling factors can be degraded to fit driver capabilities.
4715 */
4716 #define DDOVER_DEGRADEARGBSCALING 0x04000000l
4717
4718
4719 /****************************************************************************
4720 *
4721 * DIRECTDRAWSURFACE LOCK FLAGS
4722 *
4723 ****************************************************************************/
4724
4725 /*
4726 * The default. Set to indicate that Lock should return a valid memory pointer
4727 * to the top of the specified rectangle. If no rectangle is specified then a
4728 * pointer to the top of the surface is returned.
4729 */
4730 #define DDLOCK_SURFACEMEMORYPTR 0x00000000L // default
4731
4732 /*
4733 * Set to indicate that Lock should wait until it can obtain a valid memory
4734 * pointer before returning. If this bit is set, Lock will never return
4735 * DDERR_WASSTILLDRAWING.
4736 */
4737 #define DDLOCK_WAIT 0x00000001L
4738
4739 /*
4740 * Set if an event handle is being passed to Lock. Lock will trigger the event
4741 * when it can return the surface memory pointer requested.
4742 */
4743 #define DDLOCK_EVENT 0x00000002L
4744
4745 /*
4746 * Indicates that the surface being locked will only be read from.
4747 */
4748 #define DDLOCK_READONLY 0x00000010L
4749
4750 /*
4751 * Indicates that the surface being locked will only be written to
4752 */
4753 #define DDLOCK_WRITEONLY 0x00000020L
4754
4755
4756 /*
4757 * Indicates that a system wide lock should not be taken when this surface
4758 * is locked. This has several advantages (cursor responsiveness, ability
4759 * to call more Windows functions, easier debugging) when locking video
4760 * memory surfaces. However, an application specifying this flag must
4761 * comply with a number of conditions documented in the help file.
4762 * Furthermore, this flag cannot be specified when locking the primary.
4763 */
4764 #define DDLOCK_NOSYSLOCK 0x00000800L
4765
4766 /*
4767 * Used only with Direct3D Vertex Buffer Locks. Indicates that no vertices
4768 * that were referred to in Draw*PrimtiveVB calls since the start of the
4769 * frame (or the last lock without this flag) will be modified during the
4770 * lock. This can be useful when one is only appending data to the vertex
4771 * buffer
4772 */
4773 #define DDLOCK_NOOVERWRITE 0x00001000L
4774
4775 /*
4776 * Indicates that no assumptions will be made about the contents of the
4777 * surface or vertex buffer during this lock.
4778 * This enables two things:
4779 * - Direct3D or the driver may provide an alternative memory
4780 * area as the vertex buffer. This is useful when one plans to clear the
4781 * contents of the vertex buffer and fill in new data.
4782 * - Drivers sometimes store surface data in a re-ordered format.
4783 * When the application locks the surface, the driver is forced to un-re-order
4784 * the surface data before allowing the application to see the surface contents.
4785 * This flag is a hint to the driver that it can skip the un-re-ordering process
4786 * since the application plans to overwrite every single pixel in the surface
4787 * or locked rectangle (and so erase any un-re-ordered pixels anyway).
4788 * Applications should always set this flag when they intend to overwrite the entire
4789 * surface or locked rectangle.
4790 */
4791 #define DDLOCK_DISCARDCONTENTS 0x00002000L
4792 /*
4793 * DDLOCK_OKTOSWAP is an older, less informative name for DDLOCK_DISCARDCONTENTS
4794 */
4795 #define DDLOCK_OKTOSWAP 0x00002000L
4796
4797 /*
4798 * On IDirectDrawSurface7 and higher interfaces, the default is DDLOCK_WAIT. If you wish
4799 * to override the default and use time when the accelerator is busy (as denoted by
4800 * the DDERR_WASSTILLDRAWING return code) then use DDLOCK_DONOTWAIT.
4801 */
4802 #define DDLOCK_DONOTWAIT 0x00004000L
4803
4804 /*
4805 * This indicates volume texture lock with front and back specified.
4806 */
4807 #define DDLOCK_HASVOLUMETEXTUREBOXRECT 0x00008000L
4808
4809 /*
4810 * This indicates that the driver should not update dirty rect information for this lock.
4811 */
4812 #define DDLOCK_NODIRTYUPDATE 0x00010000L
4813
4814
4815 /****************************************************************************
4816 *
4817 * DIRECTDRAWSURFACE PAGELOCK FLAGS
4818 *
4819 ****************************************************************************/
4820
4821 /*
4822 * No flags defined at present
4823 */
4824
4825
4826 /****************************************************************************
4827 *
4828 * DIRECTDRAWSURFACE PAGEUNLOCK FLAGS
4829 *
4830 ****************************************************************************/
4831
4832 /*
4833 * No flags defined at present
4834 */
4835
4836
4837 /****************************************************************************
4838 *
4839 * DIRECTDRAWSURFACE BLT FX FLAGS
4840 *
4841 ****************************************************************************/
4842
4843 /*
4844 * If stretching, use arithmetic stretching along the Y axis for this blt.
4845 */
4846 #define DDBLTFX_ARITHSTRETCHY 0x00000001l
4847
4848 /*
4849 * Do this blt mirroring the surface left to right. Spin the
4850 * surface around its y-axis.
4851 */
4852 #define DDBLTFX_MIRRORLEFTRIGHT 0x00000002l
4853
4854 /*
4855 * Do this blt mirroring the surface up and down. Spin the surface
4856 * around its x-axis.
4857 */
4858 #define DDBLTFX_MIRRORUPDOWN 0x00000004l
4859
4860 /*
4861 * Schedule this blt to avoid tearing.
4862 */
4863 #define DDBLTFX_NOTEARING 0x00000008l
4864
4865 /*
4866 * Do this blt rotating the surface one hundred and eighty degrees.
4867 */
4868 #define DDBLTFX_ROTATE180 0x00000010l
4869
4870 /*
4871 * Do this blt rotating the surface two hundred and seventy degrees.
4872 */
4873 #define DDBLTFX_ROTATE270 0x00000020l
4874
4875 /*
4876 * Do this blt rotating the surface ninety degrees.
4877 */
4878 #define DDBLTFX_ROTATE90 0x00000040l
4879
4880 /*
4881 * Do this z blt using dwZBufferLow and dwZBufferHigh as range values
4882 * specified to limit the bits copied from the source surface.
4883 */
4884 #define DDBLTFX_ZBUFFERRANGE 0x00000080l
4885
4886 /*
4887 * Do this z blt adding the dwZBufferBaseDest to each of the sources z values
4888 * before comparing it with the desting z values.
4889 */
4890 #define DDBLTFX_ZBUFFERBASEDEST 0x00000100l
4891
4892 /****************************************************************************
4893 *
4894 * DIRECTDRAWSURFACE OVERLAY FX FLAGS
4895 *
4896 ****************************************************************************/
4897
4898 /*
4899 * If stretching, use arithmetic stretching along the Y axis for this overlay.
4900 */
4901 #define DDOVERFX_ARITHSTRETCHY 0x00000001l
4902
4903 /*
4904 * Mirror the overlay across the vertical axis
4905 */
4906 #define DDOVERFX_MIRRORLEFTRIGHT 0x00000002l
4907
4908 /*
4909 * Mirror the overlay across the horizontal axis
4910 */
4911 #define DDOVERFX_MIRRORUPDOWN 0x00000004l
4912
4913 /*
4914 * Deinterlace the overlay, if possible
4915 */
4916 #define DDOVERFX_DEINTERLACE 0x00000008l
4917
4918
4919 /****************************************************************************
4920 *
4921 * DIRECTDRAW WAITFORVERTICALBLANK FLAGS
4922 *
4923 ****************************************************************************/
4924
4925 /*
4926 * return when the vertical blank interval begins
4927 */
4928 #define DDWAITVB_BLOCKBEGIN 0x00000001l
4929
4930 /*
4931 * set up an event to trigger when the vertical blank begins
4932 */
4933 #define DDWAITVB_BLOCKBEGINEVENT 0x00000002l
4934
4935 /*
4936 * return when the vertical blank interval ends and display begins
4937 */
4938 #define DDWAITVB_BLOCKEND 0x00000004l
4939
4940 /****************************************************************************
4941 *
4942 * DIRECTDRAW GETFLIPSTATUS FLAGS
4943 *
4944 ****************************************************************************/
4945
4946 /*
4947 * is it OK to flip now?
4948 */
4949 #define DDGFS_CANFLIP 0x00000001l
4950
4951 /*
4952 * is the last flip finished?
4953 */
4954 #define DDGFS_ISFLIPDONE 0x00000002l
4955
4956 /****************************************************************************
4957 *
4958 * DIRECTDRAW GETBLTSTATUS FLAGS
4959 *
4960 ****************************************************************************/
4961
4962 /*
4963 * is it OK to blt now?
4964 */
4965 #define DDGBS_CANBLT 0x00000001l
4966
4967 /*
4968 * is the blt to the surface finished?
4969 */
4970 #define DDGBS_ISBLTDONE 0x00000002l
4971
4972
4973 /****************************************************************************
4974 *
4975 * DIRECTDRAW ENUMOVERLAYZORDER FLAGS
4976 *
4977 ****************************************************************************/
4978
4979 /*
4980 * Enumerate overlays back to front.
4981 */
4982 #define DDENUMOVERLAYZ_BACKTOFRONT 0x00000000l
4983
4984 /*
4985 * Enumerate overlays front to back
4986 */
4987 #define DDENUMOVERLAYZ_FRONTTOBACK 0x00000001l
4988
4989 /****************************************************************************
4990 *
4991 * DIRECTDRAW UPDATEOVERLAYZORDER FLAGS
4992 *
4993 ****************************************************************************/
4994
4995 /*
4996 * Send overlay to front
4997 */
4998 #define DDOVERZ_SENDTOFRONT 0x00000000l
4999
5000 /*
5001 * Send overlay to back
5002 */
5003 #define DDOVERZ_SENDTOBACK 0x00000001l
5004
5005 /*
5006 * Move Overlay forward
5007 */
5008 #define DDOVERZ_MOVEFORWARD 0x00000002l
5009
5010 /*
5011 * Move Overlay backward
5012 */
5013 #define DDOVERZ_MOVEBACKWARD 0x00000003l
5014
5015 /*
5016 * Move Overlay in front of relative surface
5017 */
5018 #define DDOVERZ_INSERTINFRONTOF 0x00000004l
5019
5020 /*
5021 * Move Overlay in back of relative surface
5022 */
5023 #define DDOVERZ_INSERTINBACKOF 0x00000005l
5024
5025
5026 /****************************************************************************
5027 *
5028 * DIRECTDRAW SETGAMMARAMP FLAGS
5029 *
5030 ****************************************************************************/
5031
5032 /*
5033 * Request calibrator to adjust the gamma ramp according to the physical
5034 * properties of the display so that the result should appear identical
5035 * on all systems.
5036 */
5037 #define DDSGR_CALIBRATE 0x00000001L
5038
5039
5040 /****************************************************************************
5041 *
5042 * DIRECTDRAW STARTMODETEST FLAGS
5043 *
5044 ****************************************************************************/
5045
5046 /*
5047 * Indicates that the mode being tested has passed
5048 */
5049 #define DDSMT_ISTESTREQUIRED 0x00000001L
5050
5051
5052 /****************************************************************************
5053 *
5054 * DIRECTDRAW EVALUATEMODE FLAGS
5055 *
5056 ****************************************************************************/
5057
5058 /*
5059 * Indicates that the mode being tested has passed
5060 */
5061 #define DDEM_MODEPASSED 0x00000001L
5062
5063 /*
5064 * Indicates that the mode being tested has failed
5065 */
5066 #define DDEM_MODEFAILED 0x00000002L
5067
5068
5069 /*===========================================================================
5070 *
5071 *
5072 * DIRECTDRAW RETURN CODES
5073 *
5074 * The return values from DirectDraw Commands and Surface that return an HRESULT
5075 * are codes from DirectDraw concerning the results of the action
5076 * requested by DirectDraw.
5077 *
5078 *==========================================================================*/
5079
5080 /*
5081 * Status is OK
5082 *
5083 * Issued by: DirectDraw Commands and all callbacks
5084 */
5085 #define DD_OK S_OK
5086 #define DD_FALSE S_FALSE
5087
5088 /****************************************************************************
5089 *
5090 * DIRECTDRAW ENUMCALLBACK RETURN VALUES
5091 *
5092 * EnumCallback returns are used to control the flow of the DIRECTDRAW and
5093 * DIRECTDRAWSURFACE object enumerations. They can only be returned by
5094 * enumeration callback routines.
5095 *
5096 ****************************************************************************/
5097
5098 /*
5099 * stop the enumeration
5100 */
5101 #define DDENUMRET_CANCEL 0
5102
5103 /*
5104 * continue the enumeration
5105 */
5106 #define DDENUMRET_OK 1
5107
5108 /****************************************************************************
5109 *
5110 * DIRECTDRAW ERRORS
5111 *
5112 * Errors are represented by negative values and cannot be combined.
5113 *
5114 ****************************************************************************/
5115
5116 /*
5117 * This object is already initialized
5118 */
5119 #define DDERR_ALREADYINITIALIZED MAKE_DDHRESULT( 5 )
5120
5121 /*
5122 * This surface can not be attached to the requested surface.
5123 */
5124 #define DDERR_CANNOTATTACHSURFACE MAKE_DDHRESULT( 10 )
5125
5126 /*
5127 * This surface can not be detached from the requested surface.
5128 */
5129 #define DDERR_CANNOTDETACHSURFACE MAKE_DDHRESULT( 20 )
5130
5131 /*
5132 * Support is currently not available.
5133 */
5134 #define DDERR_CURRENTLYNOTAVAIL MAKE_DDHRESULT( 40 )
5135
5136 /*
5137 * An exception was encountered while performing the requested operation
5138 */
5139 #define DDERR_EXCEPTION MAKE_DDHRESULT( 55 )
5140
5141 /*
5142 * Generic failure.
5143 */
5144 #define DDERR_GENERIC E_FAIL
5145
5146 /*
5147 * Height of rectangle provided is not a multiple of reqd alignment
5148 */
5149 #define DDERR_HEIGHTALIGN MAKE_DDHRESULT( 90 )
5150
5151 /*
5152 * Unable to match primary surface creation request with existing
5153 * primary surface.
5154 */
5155 #define DDERR_INCOMPATIBLEPRIMARY MAKE_DDHRESULT( 95 )
5156
5157 /*
5158 * One or more of the caps bits passed to the callback are incorrect.
5159 */
5160 #define DDERR_INVALIDCAPS MAKE_DDHRESULT( 100 )
5161
5162 /*
5163 * DirectDraw does not support provided Cliplist.
5164 */
5165 #define DDERR_INVALIDCLIPLIST MAKE_DDHRESULT( 110 )
5166
5167 /*
5168 * DirectDraw does not support the requested mode
5169 */
5170 #define DDERR_INVALIDMODE MAKE_DDHRESULT( 120 )
5171
5172 /*
5173 * DirectDraw received a pointer that was an invalid DIRECTDRAW object.
5174 */
5175 #define DDERR_INVALIDOBJECT MAKE_DDHRESULT( 130 )
5176
5177 /*
5178 * One or more of the parameters passed to the callback function are
5179 * incorrect.
5180 */
5181 #define DDERR_INVALIDPARAMS E_INVALIDARG
5182
5183 /*
5184 * pixel format was invalid as specified
5185 */
5186 #define DDERR_INVALIDPIXELFORMAT MAKE_DDHRESULT( 145 )
5187
5188 /*
5189 * Rectangle provided was invalid.
5190 */
5191 #define DDERR_INVALIDRECT MAKE_DDHRESULT( 150 )
5192
5193 /*
5194 * Operation could not be carried out because one or more surfaces are locked
5195 */
5196 #define DDERR_LOCKEDSURFACES MAKE_DDHRESULT( 160 )
5197
5198 /*
5199 * There is no 3D present.
5200 */
5201 #define DDERR_NO3D MAKE_DDHRESULT( 170 )
5202
5203 /*
5204 * Operation could not be carried out because there is no alpha accleration
5205 * hardware present or available.
5206 */
5207 #define DDERR_NOALPHAHW MAKE_DDHRESULT( 180 )
5208
5209 /*
5210 * Operation could not be carried out because there is no stereo
5211 * hardware present or available.
5212 */
5213 #define DDERR_NOSTEREOHARDWARE MAKE_DDHRESULT( 181 )
5214
5215 /*
5216 * Operation could not be carried out because there is no hardware
5217 * present which supports stereo surfaces
5218 */
5219 #define DDERR_NOSURFACELEFT MAKE_DDHRESULT( 182 )
5220
5221
5222
5223 /*
5224 * no clip list available
5225 */
5226 #define DDERR_NOCLIPLIST MAKE_DDHRESULT( 205 )
5227
5228 /*
5229 * Operation could not be carried out because there is no color conversion
5230 * hardware present or available.
5231 */
5232 #define DDERR_NOCOLORCONVHW MAKE_DDHRESULT( 210 )
5233
5234 /*
5235 * Create function called without DirectDraw object method SetCooperativeLevel
5236 * being called.
5237 */
5238 #define DDERR_NOCOOPERATIVELEVELSET MAKE_DDHRESULT( 212 )
5239
5240 /*
5241 * Surface doesn't currently have a color key
5242 */
5243 #define DDERR_NOCOLORKEY MAKE_DDHRESULT( 215 )
5244
5245 /*
5246 * Operation could not be carried out because there is no hardware support
5247 * of the dest color key.
5248 */
5249 #define DDERR_NOCOLORKEYHW MAKE_DDHRESULT( 220 )
5250
5251 /*
5252 * No DirectDraw support possible with current display driver
5253 */
5254 #define DDERR_NODIRECTDRAWSUPPORT MAKE_DDHRESULT( 222 )
5255
5256 /*
5257 * Operation requires the application to have exclusive mode but the
5258 * application does not have exclusive mode.
5259 */
5260 #define DDERR_NOEXCLUSIVEMODE MAKE_DDHRESULT( 225 )
5261
5262 /*
5263 * Flipping visible surfaces is not supported.
5264 */
5265 #define DDERR_NOFLIPHW MAKE_DDHRESULT( 230 )
5266
5267 /*
5268 * There is no GDI present.
5269 */
5270 #define DDERR_NOGDI MAKE_DDHRESULT( 240 )
5271
5272 /*
5273 * Operation could not be carried out because there is no hardware present
5274 * or available.
5275 */
5276 #define DDERR_NOMIRRORHW MAKE_DDHRESULT( 250 )
5277
5278 /*
5279 * Requested item was not found
5280 */
5281 #define DDERR_NOTFOUND MAKE_DDHRESULT( 255 )
5282
5283 /*
5284 * Operation could not be carried out because there is no overlay hardware
5285 * present or available.
5286 */
5287 #define DDERR_NOOVERLAYHW MAKE_DDHRESULT( 260 )
5288
5289 /*
5290 * Operation could not be carried out because the source and destination
5291 * rectangles are on the same surface and overlap each other.
5292 */
5293 #define DDERR_OVERLAPPINGRECTS MAKE_DDHRESULT( 270 )
5294
5295 /*
5296 * Operation could not be carried out because there is no appropriate raster
5297 * op hardware present or available.
5298 */
5299 #define DDERR_NORASTEROPHW MAKE_DDHRESULT( 280 )
5300
5301 /*
5302 * Operation could not be carried out because there is no rotation hardware
5303 * present or available.
5304 */
5305 #define DDERR_NOROTATIONHW MAKE_DDHRESULT( 290 )
5306
5307 /*
5308 * Operation could not be carried out because there is no hardware support
5309 * for stretching
5310 */
5311 #define DDERR_NOSTRETCHHW MAKE_DDHRESULT( 310 )
5312
5313 /*
5314 * DirectDrawSurface is not in 4 bit color palette and the requested operation
5315 * requires 4 bit color palette.
5316 */
5317 #define DDERR_NOT4BITCOLOR MAKE_DDHRESULT( 316 )
5318
5319 /*
5320 * DirectDrawSurface is not in 4 bit color index palette and the requested
5321 * operation requires 4 bit color index palette.
5322 */
5323 #define DDERR_NOT4BITCOLORINDEX MAKE_DDHRESULT( 317 )
5324
5325 /*
5326 * DirectDraw Surface is not in 8 bit color mode and the requested operation
5327 * requires 8 bit color.
5328 */
5329 #define DDERR_NOT8BITCOLOR MAKE_DDHRESULT( 320 )
5330
5331 /*
5332 * Operation could not be carried out because there is no texture mapping
5333 * hardware present or available.
5334 */
5335 #define DDERR_NOTEXTUREHW MAKE_DDHRESULT( 330 )
5336
5337 /*
5338 * Operation could not be carried out because there is no hardware support
5339 * for vertical blank synchronized operations.
5340 */
5341 #define DDERR_NOVSYNCHW MAKE_DDHRESULT( 335 )
5342
5343 /*
5344 * Operation could not be carried out because there is no hardware support
5345 * for zbuffer blting.
5346 */
5347 #define DDERR_NOZBUFFERHW MAKE_DDHRESULT( 340 )
5348
5349 /*
5350 * Overlay surfaces could not be z layered based on their BltOrder because
5351 * the hardware does not support z layering of overlays.
5352 */
5353 #define DDERR_NOZOVERLAYHW MAKE_DDHRESULT( 350 )
5354
5355 /*
5356 * The hardware needed for the requested operation has already been
5357 * allocated.
5358 */
5359 #define DDERR_OUTOFCAPS MAKE_DDHRESULT( 360 )
5360
5361 /*
5362 * DirectDraw does not have enough memory to perform the operation.
5363 */
5364 #define DDERR_OUTOFMEMORY E_OUTOFMEMORY
5365
5366 /*
5367 * DirectDraw does not have enough memory to perform the operation.
5368 */
5369 #define DDERR_OUTOFVIDEOMEMORY MAKE_DDHRESULT( 380 )
5370
5371 /*
5372 * hardware does not support clipped overlays
5373 */
5374 #define DDERR_OVERLAYCANTCLIP MAKE_DDHRESULT( 382 )
5375
5376 /*
5377 * Can only have ony color key active at one time for overlays
5378 */
5379 #define DDERR_OVERLAYCOLORKEYONLYONEACTIVE MAKE_DDHRESULT( 384 )
5380
5381 /*
5382 * Access to this palette is being refused because the palette is already
5383 * locked by another thread.
5384 */
5385 #define DDERR_PALETTEBUSY MAKE_DDHRESULT( 387 )
5386
5387 /*
5388 * No src color key specified for this operation.
5389 */
5390 #define DDERR_COLORKEYNOTSET MAKE_DDHRESULT( 400 )
5391
5392 /*
5393 * This surface is already attached to the surface it is being attached to.
5394 */
5395 #define DDERR_SURFACEALREADYATTACHED MAKE_DDHRESULT( 410 )
5396
5397 /*
5398 * This surface is already a dependency of the surface it is being made a
5399 * dependency of.
5400 */
5401 #define DDERR_SURFACEALREADYDEPENDENT MAKE_DDHRESULT( 420 )
5402
5403 /*
5404 * Access to this surface is being refused because the surface is already
5405 * locked by another thread.
5406 */
5407 #define DDERR_SURFACEBUSY MAKE_DDHRESULT( 430 )
5408
5409 /*
5410 * Access to this surface is being refused because no driver exists
5411 * which can supply a pointer to the surface.
5412 * This is most likely to happen when attempting to lock the primary
5413 * surface when no DCI provider is present.
5414 * Will also happen on attempts to lock an optimized surface.
5415 */
5416 #define DDERR_CANTLOCKSURFACE MAKE_DDHRESULT( 435 )
5417
5418 /*
5419 * Access to Surface refused because Surface is obscured.
5420 */
5421 #define DDERR_SURFACEISOBSCURED MAKE_DDHRESULT( 440 )
5422
5423 /*
5424 * Access to this surface is being refused because the surface is gone.
5425 * The DIRECTDRAWSURFACE object representing this surface should
5426 * have Restore called on it.
5427 */
5428 #define DDERR_SURFACELOST MAKE_DDHRESULT( 450 )
5429
5430 /*
5431 * The requested surface is not attached.
5432 */
5433 #define DDERR_SURFACENOTATTACHED MAKE_DDHRESULT( 460 )
5434
5435 /*
5436 * Height requested by DirectDraw is too large.
5437 */
5438 #define DDERR_TOOBIGHEIGHT MAKE_DDHRESULT( 470 )
5439
5440 /*
5441 * Size requested by DirectDraw is too large -- The individual height and
5442 * width are OK.
5443 */
5444 #define DDERR_TOOBIGSIZE MAKE_DDHRESULT( 480 )
5445
5446 /*
5447 * Width requested by DirectDraw is too large.
5448 */
5449 #define DDERR_TOOBIGWIDTH MAKE_DDHRESULT( 490 )
5450
5451 /*
5452 * Action not supported.
5453 */
5454 #define DDERR_UNSUPPORTED E_NOTIMPL
5455
5456 /*
5457 * Pixel format requested is unsupported by DirectDraw
5458 */
5459 #define DDERR_UNSUPPORTEDFORMAT MAKE_DDHRESULT( 510 )
5460
5461 /*
5462 * Bitmask in the pixel format requested is unsupported by DirectDraw
5463 */
5464 #define DDERR_UNSUPPORTEDMASK MAKE_DDHRESULT( 520 )
5465
5466 /*
5467 * The specified stream contains invalid data
5468 */
5469 #define DDERR_INVALIDSTREAM MAKE_DDHRESULT( 521 )
5470
5471 /*
5472 * vertical blank is in progress
5473 */
5474 #define DDERR_VERTICALBLANKINPROGRESS MAKE_DDHRESULT( 537 )
5475
5476 /*
5477 * Informs DirectDraw that the previous Blt which is transfering information
5478 * to or from this Surface is incomplete.
5479 */
5480 #define DDERR_WASSTILLDRAWING MAKE_DDHRESULT( 540 )
5481
5482
5483 /*
5484 * The specified surface type requires specification of the COMPLEX flag
5485 */
5486 #define DDERR_DDSCAPSCOMPLEXREQUIRED MAKE_DDHRESULT( 542 )
5487
5488
5489 /*
5490 * Rectangle provided was not horizontally aligned on reqd. boundary
5491 */
5492 #define DDERR_XALIGN MAKE_DDHRESULT( 560 )
5493
5494 /*
5495 * The GUID passed to DirectDrawCreate is not a valid DirectDraw driver
5496 * identifier.
5497 */
5498 #define DDERR_INVALIDDIRECTDRAWGUID MAKE_DDHRESULT( 561 )
5499
5500 /*
5501 * A DirectDraw object representing this driver has already been created
5502 * for this process.
5503 */
5504 #define DDERR_DIRECTDRAWALREADYCREATED MAKE_DDHRESULT( 562 )
5505
5506 /*
5507 * A hardware only DirectDraw object creation was attempted but the driver
5508 * did not support any hardware.
5509 */
5510 #define DDERR_NODIRECTDRAWHW MAKE_DDHRESULT( 563 )
5511
5512 /*
5513 * this process already has created a primary surface
5514 */
5515 #define DDERR_PRIMARYSURFACEALREADYEXISTS MAKE_DDHRESULT( 564 )
5516
5517 /*
5518 * software emulation not available.
5519 */
5520 #define DDERR_NOEMULATION MAKE_DDHRESULT( 565 )
5521
5522 /*
5523 * region passed to Clipper::GetClipList is too small.
5524 */
5525 #define DDERR_REGIONTOOSMALL MAKE_DDHRESULT( 566 )
5526
5527 /*
5528 * an attempt was made to set a clip list for a clipper objec that
5529 * is already monitoring an hwnd.
5530 */
5531 #define DDERR_CLIPPERISUSINGHWND MAKE_DDHRESULT( 567 )
5532
5533 /*
5534 * No clipper object attached to surface object
5535 */
5536 #define DDERR_NOCLIPPERATTACHED MAKE_DDHRESULT( 568 )
5537
5538 /*
5539 * Clipper notification requires an HWND or
5540 * no HWND has previously been set as the CooperativeLevel HWND.
5541 */
5542 #define DDERR_NOHWND MAKE_DDHRESULT( 569 )
5543
5544 /*
5545 * HWND used by DirectDraw CooperativeLevel has been subclassed,
5546 * this prevents DirectDraw from restoring state.
5547 */
5548 #define DDERR_HWNDSUBCLASSED MAKE_DDHRESULT( 570 )
5549
5550 /*
5551 * The CooperativeLevel HWND has already been set.
5552 * It can not be reset while the process has surfaces or palettes created.
5553 */
5554 #define DDERR_HWNDALREADYSET MAKE_DDHRESULT( 571 )
5555
5556 /*
5557 * No palette object attached to this surface.
5558 */
5559 #define DDERR_NOPALETTEATTACHED MAKE_DDHRESULT( 572 )
5560
5561 /*
5562 * No hardware support for 16 or 256 color palettes.
5563 */
5564 #define DDERR_NOPALETTEHW MAKE_DDHRESULT( 573 )
5565
5566 /*
5567 * If a clipper object is attached to the source surface passed into a
5568 * BltFast call.
5569 */
5570 #define DDERR_BLTFASTCANTCLIP MAKE_DDHRESULT( 574 )
5571
5572 /*
5573 * No blter.
5574 */
5575 #define DDERR_NOBLTHW MAKE_DDHRESULT( 575 )
5576
5577 /*
5578 * No DirectDraw ROP hardware.
5579 */
5580 #define DDERR_NODDROPSHW MAKE_DDHRESULT( 576 )
5581
5582 /*
5583 * returned when GetOverlayPosition is called on a hidden overlay
5584 */
5585 #define DDERR_OVERLAYNOTVISIBLE MAKE_DDHRESULT( 577 )
5586
5587 /*
5588 * returned when GetOverlayPosition is called on a overlay that UpdateOverlay
5589 * has never been called on to establish a destionation.
5590 */
5591 #define DDERR_NOOVERLAYDEST MAKE_DDHRESULT( 578 )
5592
5593 /*
5594 * returned when the position of the overlay on the destionation is no longer
5595 * legal for that destionation.
5596 */
5597 #define DDERR_INVALIDPOSITION MAKE_DDHRESULT( 579 )
5598
5599 /*
5600 * returned when an overlay member is called for a non-overlay surface
5601 */
5602 #define DDERR_NOTAOVERLAYSURFACE MAKE_DDHRESULT( 580 )
5603
5604 /*
5605 * An attempt was made to set the cooperative level when it was already
5606 * set to exclusive.
5607 */
5608 #define DDERR_EXCLUSIVEMODEALREADYSET MAKE_DDHRESULT( 581 )
5609
5610 /*
5611 * An attempt has been made to flip a surface that is not flippable.
5612 */
5613 #define DDERR_NOTFLIPPABLE MAKE_DDHRESULT( 582 )
5614
5615 /*
5616 * Can't duplicate primary & 3D surfaces, or surfaces that are implicitly
5617 * created.
5618 */
5619 #define DDERR_CANTDUPLICATE MAKE_DDHRESULT( 583 )
5620
5621 /*
5622 * Surface was not locked. An attempt to unlock a surface that was not
5623 * locked at all, or by this process, has been attempted.
5624 */
5625 #define DDERR_NOTLOCKED MAKE_DDHRESULT( 584 )
5626
5627 /*
5628 * Windows can not create any more DCs, or a DC was requested for a paltte-indexed
5629 * surface when the surface had no palette AND the display mode was not palette-indexed
5630 * (in this case DirectDraw cannot select a proper palette into the DC)
5631 */
5632 #define DDERR_CANTCREATEDC MAKE_DDHRESULT( 585 )
5633
5634 /*
5635 * No DC was ever created for this surface.
5636 */
5637 #define DDERR_NODC MAKE_DDHRESULT( 586 )
5638
5639 /*
5640 * This surface can not be restored because it was created in a different
5641 * mode.
5642 */
5643 #define DDERR_WRONGMODE MAKE_DDHRESULT( 587 )
5644
5645 /*
5646 * This surface can not be restored because it is an implicitly created
5647 * surface.
5648 */
5649 #define DDERR_IMPLICITLYCREATED MAKE_DDHRESULT( 588 )
5650
5651 /*
5652 * The surface being used is not a palette-based surface
5653 */
5654 #define DDERR_NOTPALETTIZED MAKE_DDHRESULT( 589 )
5655
5656
5657 /*
5658 * The display is currently in an unsupported mode
5659 */
5660 #define DDERR_UNSUPPORTEDMODE MAKE_DDHRESULT( 590 )
5661
5662 /*
5663 * Operation could not be carried out because there is no mip-map
5664 * texture mapping hardware present or available.
5665 */
5666 #define DDERR_NOMIPMAPHW MAKE_DDHRESULT( 591 )
5667
5668 /*
5669 * The requested action could not be performed because the surface was of
5670 * the wrong type.
5671 */
5672 #define DDERR_INVALIDSURFACETYPE MAKE_DDHRESULT( 592 )
5673
5674
5675 /*
5676 * Device does not support optimized surfaces, therefore no video memory optimized surfaces
5677 */
5678 #define DDERR_NOOPTIMIZEHW MAKE_DDHRESULT( 600 )
5679
5680 /*
5681 * Surface is an optimized surface, but has not yet been allocated any memory
5682 */
5683 #define DDERR_NOTLOADED MAKE_DDHRESULT( 601 )
5684
5685 /*
5686 * Attempt was made to create or set a device window without first setting
5687 * the focus window
5688 */
5689 #define DDERR_NOFOCUSWINDOW MAKE_DDHRESULT( 602 )
5690
5691 /*
5692 * Attempt was made to set a palette on a mipmap sublevel
5693 */
5694 #define DDERR_NOTONMIPMAPSUBLEVEL MAKE_DDHRESULT( 603 )
5695
5696 /*
5697 * A DC has already been returned for this surface. Only one DC can be
5698 * retrieved per surface.
5699 */
5700 #define DDERR_DCALREADYCREATED MAKE_DDHRESULT( 620 )
5701
5702 /*
5703 * An attempt was made to allocate non-local video memory from a device
5704 * that does not support non-local video memory.
5705 */
5706 #define DDERR_NONONLOCALVIDMEM MAKE_DDHRESULT( 630 )
5707
5708 /*
5709 * The attempt to page lock a surface failed.
5710 */
5711 #define DDERR_CANTPAGELOCK MAKE_DDHRESULT( 640 )
5712
5713
5714 /*
5715 * The attempt to page unlock a surface failed.
5716 */
5717 #define DDERR_CANTPAGEUNLOCK MAKE_DDHRESULT( 660 )
5718
5719 /*
5720 * An attempt was made to page unlock a surface with no outstanding page locks.
5721 */
5722 #define DDERR_NOTPAGELOCKED MAKE_DDHRESULT( 680 )
5723
5724 /*
5725 * There is more data available than the specified buffer size could hold
5726 */
5727 #define DDERR_MOREDATA MAKE_DDHRESULT( 690 )
5728
5729 /*
5730 * The data has expired and is therefore no longer valid.
5731 */
5732 #define DDERR_EXPIRED MAKE_DDHRESULT( 691 )
5733
5734 /*
5735 * The mode test has finished executing.
5736 */
5737 #define DDERR_TESTFINISHED MAKE_DDHRESULT( 692 )
5738
5739 /*
5740 * The mode test has switched to a new mode.
5741 */
5742 #define DDERR_NEWMODE MAKE_DDHRESULT( 693 )
5743
5744 /*
5745 * D3D has not yet been initialized.
5746 */
5747 #define DDERR_D3DNOTINITIALIZED MAKE_DDHRESULT( 694 )
5748
5749 /*
5750 * The video port is not active
5751 */
5752 #define DDERR_VIDEONOTACTIVE MAKE_DDHRESULT( 695 )
5753
5754 /*
5755 * The monitor does not have EDID data.
5756 */
5757 #define DDERR_NOMONITORINFORMATION MAKE_DDHRESULT( 696 )
5758
5759 /*
5760 * The driver does not enumerate display mode refresh rates.
5761 */
5762 #define DDERR_NODRIVERSUPPORT MAKE_DDHRESULT( 697 )
5763
5764 /*
5765 * Surfaces created by one direct draw device cannot be used directly by
5766 * another direct draw device.
5767 */
5768 #define DDERR_DEVICEDOESNTOWNSURFACE MAKE_DDHRESULT( 699 )
5769
5770
5771
5772 /*
5773 * An attempt was made to invoke an interface member of a DirectDraw object
5774 * created by CoCreateInstance() before it was initialized.
5775 */
5776 #define DDERR_NOTINITIALIZED CO_E_NOTINITIALIZED
5777
5778
5779 /* Alpha bit depth constants */
5780
5781
5782 #ifdef __cplusplus
5783 };
5784 #endif
5785
5786 #ifdef ENABLE_NAMELESS_UNION_PRAGMA
5787 #pragma warning(default:4201)
5788 #endif
5789
5790 #endif //__DDRAW_INCLUDED__
5791
5792