~swag/armagetronad/0.2.9-sty+ct+ap-fork : revision 1078

1

/*==========================================================================;

2

*

3

4

*

5

* File: ddraw.h

6

* Content: DirectDraw include file

7

*

8

***************************************************************************/

9

10

#ifndef __DDRAW_INCLUDED__

11

#define __DDRAW_INCLUDED__

12

13

//Disable the nameless union warning when building internally

14

#undef ENABLE_NAMELESS_UNION_PRAGMA

15

#ifdef DIRECTX_REDIST

16

#define ENABLE_NAMELESS_UNION_PRAGMA

17

#endif

18

19

#ifdef ENABLE_NAMELESS_UNION_PRAGMA

20

#pragma warning(disable:4201)

21

#endif

22

23

/*

24

* If you wish an application built against the newest version of DirectDraw

25

* to run against an older DirectDraw run time then define DIRECTDRAW_VERSION

26

* to be the earlies version of DirectDraw you wish to run against. For,

27

* example if you wish an application to run against a DX 3 runtime define

28

* DIRECTDRAW_VERSION to be 0x0300.

29

*/

30

#ifndef DIRECTDRAW_VERSION

31

#define DIRECTDRAW_VERSION 0x0700

32

#endif /* DIRECTDRAW_VERSION */

33

34

#if defined( _WIN32 ) && !defined( _NO_COM )

35

#define COM_NO_WINDOWS_H

36

#include <objbase.h>

37

#else

38

#define IUnknown void

39

#if !defined( NT_BUILD_ENVIRONMENT ) && !defined(WINNT)

40

#define CO_E_NOTINITIALIZED 0x800401F0L

41

#endif

42

#endif

43

44

#define _FACDD 0x876

45

#define MAKE_DDHRESULT( code ) MAKE_HRESULT( 1, _FACDD, code )

46

47

#ifdef __cplusplus

48

extern "C" {

49

#endif

50

51

//

52

// For compilers that don't support nameless unions, do a

53

//

54

// #define NONAMELESSUNION

55

//

56

// before #include <ddraw.h>

57

//

58

#ifndef DUMMYUNIONNAMEN

59

#if defined(__cplusplus) || !defined(NONAMELESSUNION)

60

#define DUMMYUNIONNAMEN(n)

61

#else

62

#define DUMMYUNIONNAMEN(n) u##n

63

#endif

64

#endif

65

66

#ifndef MAKEFOURCC

67

#define MAKEFOURCC(ch0, ch1, ch2, ch3) \

68

((DWORD)(BYTE)(ch0) | ((DWORD)(BYTE)(ch1) << 8) | \

69

((DWORD)(BYTE)(ch2) << 16) | ((DWORD)(BYTE)(ch3) << 24 ))

70

#endif //defined(MAKEFOURCC)

71

72

/*

73

* FOURCC codes for DX compressed-texture pixel formats

74

*/

75

#define FOURCC_DXT1 (MAKEFOURCC('D','X','T','1'))

76

#define FOURCC_DXT2 (MAKEFOURCC('D','X','T','2'))

77

#define FOURCC_DXT3 (MAKEFOURCC('D','X','T','3'))

78

#define FOURCC_DXT4 (MAKEFOURCC('D','X','T','4'))

79

#define FOURCC_DXT5 (MAKEFOURCC('D','X','T','5'))

80

81

/*

82

* GUIDS used by DirectDraw objects

83

*/

84

#if defined( _WIN32 ) && !defined( _NO_COM )

85

86

DEFINE_GUID( CLSID_DirectDraw, 0xD7B70EE0,0x4340,0x11CF,0xB0,0x63,0x00,0x20,0xAF,0xC2,0xCD,0x35 );

87

DEFINE_GUID( CLSID_DirectDraw7, 0x3c305196,0x50db,0x11d3,0x9c,0xfe,0x00,0xc0,0x4f,0xd9,0x30,0xc5 );

88

DEFINE_GUID( CLSID_DirectDrawClipper, 0x593817A0,0x7DB3,0x11CF,0xA2,0xDE,0x00,0xAA,0x00,0xb9,0x33,0x56 );

89

DEFINE_GUID( IID_IDirectDraw, 0x6C14DB80,0xA733,0x11CE,0xA5,0x21,0x00,0x20,0xAF,0x0B,0xE5,0x60 );

90

DEFINE_GUID( IID_IDirectDraw2, 0xB3A6F3E0,0x2B43,0x11CF,0xA2,0xDE,0x00,0xAA,0x00,0xB9,0x33,0x56 );

91

DEFINE_GUID( IID_IDirectDraw4, 0x9c59509a,0x39bd,0x11d1,0x8c,0x4a,0x00,0xc0,0x4f,0xd9,0x30,0xc5 );

92

DEFINE_GUID( IID_IDirectDraw7, 0x15e65ec0,0x3b9c,0x11d2,0xb9,0x2f,0x00,0x60,0x97,0x97,0xea,0x5b );

93

DEFINE_GUID( IID_IDirectDrawSurface, 0x6C14DB81,0xA733,0x11CE,0xA5,0x21,0x00,0x20,0xAF,0x0B,0xE5,0x60 );

94

DEFINE_GUID( IID_IDirectDrawSurface2, 0x57805885,0x6eec,0x11cf,0x94,0x41,0xa8,0x23,0x03,0xc1,0x0e,0x27 );

95

DEFINE_GUID( IID_IDirectDrawSurface3, 0xDA044E00,0x69B2,0x11D0,0xA1,0xD5,0x00,0xAA,0x00,0xB8,0xDF,0xBB );

96

DEFINE_GUID( IID_IDirectDrawSurface4, 0x0B2B8630,0xAD35,0x11D0,0x8E,0xA6,0x00,0x60,0x97,0x97,0xEA,0x5B );

97

DEFINE_GUID( IID_IDirectDrawSurface7, 0x06675a80,0x3b9b,0x11d2,0xb9,0x2f,0x00,0x60,0x97,0x97,0xea,0x5b );

98

DEFINE_GUID( IID_IDirectDrawPalette, 0x6C14DB84,0xA733,0x11CE,0xA5,0x21,0x00,0x20,0xAF,0x0B,0xE5,0x60 );

99

DEFINE_GUID( IID_IDirectDrawClipper, 0x6C14DB85,0xA733,0x11CE,0xA5,0x21,0x00,0x20,0xAF,0x0B,0xE5,0x60 );

100

DEFINE_GUID( IID_IDirectDrawColorControl, 0x4B9F0EE0,0x0D7E,0x11D0,0x9B,0x06,0x00,0xA0,0xC9,0x03,0xA3,0xB8 );

101

DEFINE_GUID( IID_IDirectDrawGammaControl, 0x69C11C3E,0xB46B,0x11D1,0xAD,0x7A,0x00,0xC0,0x4F,0xC2,0x9B,0x4E );

102

103

#endif

104

105

/*============================================================================

106

*

107

* DirectDraw Structures

108

*

109

* Various structures used to invoke DirectDraw.

110

*

111

*==========================================================================*/

112

113

struct IDirectDraw;

114

struct IDirectDrawSurface;

115

struct IDirectDrawPalette;

116

struct IDirectDrawClipper;

117

118

typedef struct IDirectDraw FAR *LPDIRECTDRAW;

119

typedef struct IDirectDraw2 FAR *LPDIRECTDRAW2;

120

typedef struct IDirectDraw4 FAR *LPDIRECTDRAW4;

121

typedef struct IDirectDraw7 FAR *LPDIRECTDRAW7;

122

typedef struct IDirectDrawSurface FAR *LPDIRECTDRAWSURFACE;

123

typedef struct IDirectDrawSurface2 FAR *LPDIRECTDRAWSURFACE2;

124

typedef struct IDirectDrawSurface3 FAR *LPDIRECTDRAWSURFACE3;

125

typedef struct IDirectDrawSurface4 FAR *LPDIRECTDRAWSURFACE4;

126

typedef struct IDirectDrawSurface7 FAR *LPDIRECTDRAWSURFACE7;

127

typedef struct IDirectDrawPalette FAR *LPDIRECTDRAWPALETTE;

128

typedef struct IDirectDrawClipper FAR *LPDIRECTDRAWCLIPPER;

129

typedef struct IDirectDrawColorControl FAR *LPDIRECTDRAWCOLORCONTROL;

130

typedef struct IDirectDrawGammaControl FAR *LPDIRECTDRAWGAMMACONTROL;

131

132

typedef struct _DDFXROP FAR *LPDDFXROP;

133

typedef struct _DDSURFACEDESC FAR *LPDDSURFACEDESC;

134

typedef struct _DDSURFACEDESC2 FAR *LPDDSURFACEDESC2;

135

typedef struct _DDCOLORCONTROL FAR *LPDDCOLORCONTROL;

136

137

/*

138

* API's

139

*/

140

#if (defined (WIN32) || defined( _WIN32 ) ) && !defined( _NO_COM )

141

//#if defined( _WIN32 ) && !defined( _NO_ENUM )

142

typedef BOOL (FAR PASCAL * LPDDENUMCALLBACKA)(GUID FAR *, LPSTR, LPSTR, LPVOID);

143

typedef BOOL (FAR PASCAL * LPDDENUMCALLBACKW)(GUID FAR *, LPWSTR, LPWSTR, LPVOID);

144

extern HRESULT WINAPI DirectDrawEnumerateW( LPDDENUMCALLBACKW lpCallback, LPVOID lpContext );

145

extern HRESULT WINAPI DirectDrawEnumerateA( LPDDENUMCALLBACKA lpCallback, LPVOID lpContext );

146

/*

147

* Protect against old SDKs

148

*/

149

#if !defined(HMONITOR_DECLARED) && (WINVER < 0x0500)

150

#define HMONITOR_DECLARED

151

DECLARE_HANDLE(HMONITOR);

152

#endif

153

typedef BOOL (FAR PASCAL * LPDDENUMCALLBACKEXA)(GUID FAR *, LPSTR, LPSTR, LPVOID, HMONITOR);

154

typedef BOOL (FAR PASCAL * LPDDENUMCALLBACKEXW)(GUID FAR *, LPWSTR, LPWSTR, LPVOID, HMONITOR);

155

extern HRESULT WINAPI DirectDrawEnumerateExW( LPDDENUMCALLBACKEXW lpCallback, LPVOID lpContext, DWORD dwFlags);

156

extern HRESULT WINAPI DirectDrawEnumerateExA( LPDDENUMCALLBACKEXA lpCallback, LPVOID lpContext, DWORD dwFlags);

157

typedef HRESULT (WINAPI * LPDIRECTDRAWENUMERATEEXA)( LPDDENUMCALLBACKEXA lpCallback, LPVOID lpContext, DWORD dwFlags);

158

typedef HRESULT (WINAPI * LPDIRECTDRAWENUMERATEEXW)( LPDDENUMCALLBACKEXW lpCallback, LPVOID lpContext, DWORD dwFlags);

159

160

#ifdef UNICODE

161

typedef LPDDENUMCALLBACKW LPDDENUMCALLBACK;

162

#define DirectDrawEnumerate DirectDrawEnumerateW

163

typedef LPDDENUMCALLBACKEXW LPDDENUMCALLBACKEX;

164

typedef LPDIRECTDRAWENUMERATEEXW LPDIRECTDRAWENUMERATEEX;

165

#define DirectDrawEnumerateEx DirectDrawEnumerateExW

166

#else

167

typedef LPDDENUMCALLBACKA LPDDENUMCALLBACK;

168

#define DirectDrawEnumerate DirectDrawEnumerateA

169

typedef LPDDENUMCALLBACKEXA LPDDENUMCALLBACKEX;

170

typedef LPDIRECTDRAWENUMERATEEXA LPDIRECTDRAWENUMERATEEX;

171

#define DirectDrawEnumerateEx DirectDrawEnumerateExA

172

#endif

173

extern HRESULT WINAPI DirectDrawCreate( GUID FAR *lpGUID, LPDIRECTDRAW FAR *lplpDD, IUnknown FAR *pUnkOuter );

174

extern HRESULT WINAPI DirectDrawCreateEx( GUID FAR * lpGuid, LPVOID *lplpDD, REFIID iid,IUnknown FAR *pUnkOuter );

175

extern HRESULT WINAPI DirectDrawCreateClipper( DWORD dwFlags, LPDIRECTDRAWCLIPPER FAR *lplpDDClipper, IUnknown FAR *pUnkOuter );

176

#endif

177

/*

178

* Flags for DirectDrawEnumerateEx

179

* DirectDrawEnumerateEx supercedes DirectDrawEnumerate. You must use GetProcAddress to

180

* obtain a function pointer (of type LPDIRECTDRAWENUMERATEEX) to DirectDrawEnumerateEx.

181

* By default, only the primary display device is enumerated.

182

* DirectDrawEnumerate is equivalent to DirectDrawEnumerate(,,DDENUM_NONDISPLAYDEVICES)

183

*/

184

185

/*

186

* This flag causes enumeration of any GDI display devices which are part of

187

* the Windows Desktop

188

*/

189

#define DDENUM_ATTACHEDSECONDARYDEVICES 0x00000001L

190

191

/*

192

* This flag causes enumeration of any GDI display devices which are not

193

* part of the Windows Desktop

194

*/

195

#define DDENUM_DETACHEDSECONDARYDEVICES 0x00000002L

196

197

/*

198

* This flag causes enumeration of non-display devices

199

*/

200

#define DDENUM_NONDISPLAYDEVICES 0x00000004L

201

202

203

#define REGSTR_KEY_DDHW_DESCRIPTION "Description"

204

#define REGSTR_KEY_DDHW_DRIVERNAME "DriverName"

205

#define REGSTR_PATH_DDHW "Hardware\\DirectDrawDrivers"

206

207

#define DDCREATE_HARDWAREONLY 0x00000001l

208

#define DDCREATE_EMULATIONONLY 0x00000002l

209

210

#if defined(WINNT) || !defined(WIN32)

211

typedef long HRESULT;

212

#endif

213

214

//#ifndef WINNT

215

typedef HRESULT (FAR PASCAL * LPDDENUMMODESCALLBACK)(LPDDSURFACEDESC, LPVOID);

216

typedef HRESULT (FAR PASCAL * LPDDENUMMODESCALLBACK2)(LPDDSURFACEDESC2, LPVOID);

217

typedef HRESULT (FAR PASCAL * LPDDENUMSURFACESCALLBACK)(LPDIRECTDRAWSURFACE, LPDDSURFACEDESC, LPVOID);

218

typedef HRESULT (FAR PASCAL * LPDDENUMSURFACESCALLBACK2)(LPDIRECTDRAWSURFACE4, LPDDSURFACEDESC2, LPVOID);

219

typedef HRESULT (FAR PASCAL * LPDDENUMSURFACESCALLBACK7)(LPDIRECTDRAWSURFACE7, LPDDSURFACEDESC2, LPVOID);

220

//#endif

221

222

/*

223

* Generic pixel format with 8-bit RGB and alpha components

224

*/

225

typedef struct _DDARGB

226

{

227

BYTE blue;

228

BYTE green;

229

BYTE red;

230

BYTE alpha;

231

} DDARGB;

232

233

typedef DDARGB FAR *LPDDARGB;

234

235

/*

236

* This version of the structure remains for backwards source compatibility.

237

* The DDARGB structure is the one that should be used for all DirectDraw APIs.

238

*/

239

typedef struct _DDRGBA

240

{

241

BYTE red;

242

BYTE green;

243

BYTE blue;

244

BYTE alpha;

245

} DDRGBA;

246

247

typedef DDRGBA FAR *LPDDRGBA;

248

249

250

/*

251

* DDCOLORKEY

252

*/

253

typedef struct _DDCOLORKEY

254

{

255

DWORD dwColorSpaceLowValue; // low boundary of color space that is to

256

// be treated as Color Key, inclusive

257

DWORD dwColorSpaceHighValue; // high boundary of color space that is

258

// to be treated as Color Key, inclusive

259

} DDCOLORKEY;

260

261

typedef DDCOLORKEY FAR* LPDDCOLORKEY;

262

263

/*

264

* DDBLTFX

265

* Used to pass override information to the DIRECTDRAWSURFACE callback Blt.

266

*/

267

typedef struct _DDBLTFX

268

{

269

DWORD dwSize; // size of structure

270

DWORD dwDDFX; // FX operations

271

DWORD dwROP; // Win32 raster operations

272

DWORD dwDDROP; // Raster operations new for DirectDraw

273

DWORD dwRotationAngle; // Rotation angle for blt

274

DWORD dwZBufferOpCode; // ZBuffer compares

275

DWORD dwZBufferLow; // Low limit of Z buffer

276

DWORD dwZBufferHigh; // High limit of Z buffer

277

DWORD dwZBufferBaseDest; // Destination base value

278

DWORD dwZDestConstBitDepth; // Bit depth used to specify Z constant for destination

279

union

280

{

281

DWORD dwZDestConst; // Constant to use as Z buffer for dest

282

LPDIRECTDRAWSURFACE lpDDSZBufferDest; // Surface to use as Z buffer for dest

283

} DUMMYUNIONNAMEN(1);

284

DWORD dwZSrcConstBitDepth; // Bit depth used to specify Z constant for source

285

union

286

{

287

DWORD dwZSrcConst; // Constant to use as Z buffer for src

288

LPDIRECTDRAWSURFACE lpDDSZBufferSrc; // Surface to use as Z buffer for src

289

} DUMMYUNIONNAMEN(2);

290

DWORD dwAlphaEdgeBlendBitDepth; // Bit depth used to specify constant for alpha edge blend

291

DWORD dwAlphaEdgeBlend; // Alpha for edge blending

292

DWORD dwReserved;

293

DWORD dwAlphaDestConstBitDepth; // Bit depth used to specify alpha constant for destination

294

union

295

{

296

DWORD dwAlphaDestConst; // Constant to use as Alpha Channel

297

LPDIRECTDRAWSURFACE lpDDSAlphaDest; // Surface to use as Alpha Channel

298

} DUMMYUNIONNAMEN(3);

299

DWORD dwAlphaSrcConstBitDepth; // Bit depth used to specify alpha constant for source

300

union

301

{

302

DWORD dwAlphaSrcConst; // Constant to use as Alpha Channel

303

LPDIRECTDRAWSURFACE lpDDSAlphaSrc; // Surface to use as Alpha Channel

304

} DUMMYUNIONNAMEN(4);

305

union

306

{

307

DWORD dwFillColor; // color in RGB or Palettized

308

DWORD dwFillDepth; // depth value for z-buffer

309

DWORD dwFillPixel; // pixel value for RGBA or RGBZ

310

LPDIRECTDRAWSURFACE lpDDSPattern; // Surface to use as pattern

311

} DUMMYUNIONNAMEN(5);

312

DDCOLORKEY ddckDestColorkey; // DestColorkey override

313

DDCOLORKEY ddckSrcColorkey; // SrcColorkey override

314

} DDBLTFX;

315

316

typedef DDBLTFX FAR* LPDDBLTFX;

317

318

319

320

/*

321

* DDSCAPS

322

*/

323

typedef struct _DDSCAPS

324

{

325

DWORD dwCaps; // capabilities of surface wanted

326

} DDSCAPS;

327

328

typedef DDSCAPS FAR* LPDDSCAPS;

329

330

331

/*

332

* DDOSCAPS

333

*/

334

typedef struct _DDOSCAPS

335

{

336

DWORD dwCaps; // capabilities of surface wanted

337

} DDOSCAPS;

338

339

typedef DDOSCAPS FAR* LPDDOSCAPS;

340

341

/*

342

* This structure is used internally by DirectDraw.

343

*/

344

typedef struct _DDSCAPSEX

345

{

346

DWORD dwCaps2;

347

DWORD dwCaps3;

348

union

349

{

350

DWORD dwCaps4;

351

DWORD dwVolumeDepth;

352

} DUMMYUNIONNAMEN(1);

353

} DDSCAPSEX, FAR * LPDDSCAPSEX;

354

355

/*

356

* DDSCAPS2

357

*/

358

typedef struct _DDSCAPS2

359

{

360

DWORD dwCaps; // capabilities of surface wanted

361

DWORD dwCaps2;

362

DWORD dwCaps3;

363

union

364

{

365

DWORD dwCaps4;

366

DWORD dwVolumeDepth;

367

} DUMMYUNIONNAMEN(1);

368

} DDSCAPS2;

369

370

typedef DDSCAPS2 FAR* LPDDSCAPS2;

371

372

/*

373

* DDCAPS

374

*/

375

#define DD_ROP_SPACE (256/32) // space required to store ROP array

376

/*

377

* NOTE: Our choosen structure number scheme is to append a single digit to

378

* the end of the structure giving the version that structure is associated

379

* with.

380

*/

381

382

/*

383

* This structure represents the DDCAPS structure released in DirectDraw 1.0. It is used internally

384

* by DirectDraw to interpret caps passed into ddraw by drivers written prior to the release of DirectDraw 2.0.

385

* New applications should use the DDCAPS structure defined below.

386

*/

387

typedef struct _DDCAPS_DX1

388

{

389

DWORD dwSize; // size of the DDDRIVERCAPS structure

390

DWORD dwCaps; // driver specific capabilities

391

DWORD dwCaps2; // more driver specific capabilites

392

DWORD dwCKeyCaps; // color key capabilities of the surface

393

DWORD dwFXCaps; // driver specific stretching and effects capabilites

394

DWORD dwFXAlphaCaps; // alpha driver specific capabilities

395

DWORD dwPalCaps; // palette capabilities

396

DWORD dwSVCaps; // stereo vision capabilities

397

DWORD dwAlphaBltConstBitDepths; // DDBD_2,4,8

398

DWORD dwAlphaBltPixelBitDepths; // DDBD_1,2,4,8

399

DWORD dwAlphaBltSurfaceBitDepths; // DDBD_1,2,4,8

400

DWORD dwAlphaOverlayConstBitDepths; // DDBD_2,4,8

401

DWORD dwAlphaOverlayPixelBitDepths; // DDBD_1,2,4,8

402

DWORD dwAlphaOverlaySurfaceBitDepths; // DDBD_1,2,4,8

403

DWORD dwZBufferBitDepths; // DDBD_8,16,24,32

404

DWORD dwVidMemTotal; // total amount of video memory

405

DWORD dwVidMemFree; // amount of free video memory

406

DWORD dwMaxVisibleOverlays; // maximum number of visible overlays

407

DWORD dwCurrVisibleOverlays; // current number of visible overlays

408

DWORD dwNumFourCCCodes; // number of four cc codes

409

DWORD dwAlignBoundarySrc; // source rectangle alignment

410

DWORD dwAlignSizeSrc; // source rectangle byte size

411

DWORD dwAlignBoundaryDest; // dest rectangle alignment

412

DWORD dwAlignSizeDest; // dest rectangle byte size

413

DWORD dwAlignStrideAlign; // stride alignment

414

DWORD dwRops[DD_ROP_SPACE]; // ROPS supported

415

DDSCAPS ddsCaps; // DDSCAPS structure has all the general capabilities

416

DWORD dwMinOverlayStretch; // minimum overlay stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3

417

DWORD dwMaxOverlayStretch; // maximum overlay stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3

418

DWORD dwMinLiveVideoStretch; // OBSOLETE! This field remains for compatability reasons only

419

DWORD dwMaxLiveVideoStretch; // OBSOLETE! This field remains for compatability reasons only

420

DWORD dwMinHwCodecStretch; // OBSOLETE! This field remains for compatability reasons only

421

DWORD dwMaxHwCodecStretch; // OBSOLETE! This field remains for compatability reasons only

422

DWORD dwReserved1; // reserved

423

DWORD dwReserved2; // reserved

424

DWORD dwReserved3; // reserved

425

} DDCAPS_DX1;

426

427

typedef DDCAPS_DX1 FAR* LPDDCAPS_DX1;

428

429

/*

430

* This structure is the DDCAPS structure as it was in version 2 and 3 of Direct X.

431

* It is present for back compatability.

432

*/

433

typedef struct _DDCAPS_DX3

434

{

435

DWORD dwSize; // size of the DDDRIVERCAPS structure

436

DWORD dwCaps; // driver specific capabilities

437

DWORD dwCaps2; // more driver specific capabilites

438

DWORD dwCKeyCaps; // color key capabilities of the surface

439

DWORD dwFXCaps; // driver specific stretching and effects capabilites

440

DWORD dwFXAlphaCaps; // alpha driver specific capabilities

441

DWORD dwPalCaps; // palette capabilities

442

DWORD dwSVCaps; // stereo vision capabilities

443

DWORD dwAlphaBltConstBitDepths; // DDBD_2,4,8

444

DWORD dwAlphaBltPixelBitDepths; // DDBD_1,2,4,8

445

DWORD dwAlphaBltSurfaceBitDepths; // DDBD_1,2,4,8

446

DWORD dwAlphaOverlayConstBitDepths; // DDBD_2,4,8

447

DWORD dwAlphaOverlayPixelBitDepths; // DDBD_1,2,4,8

448

DWORD dwAlphaOverlaySurfaceBitDepths; // DDBD_1,2,4,8

449

DWORD dwZBufferBitDepths; // DDBD_8,16,24,32

450

DWORD dwVidMemTotal; // total amount of video memory

451

DWORD dwVidMemFree; // amount of free video memory

452

DWORD dwMaxVisibleOverlays; // maximum number of visible overlays

453

DWORD dwCurrVisibleOverlays; // current number of visible overlays

454

DWORD dwNumFourCCCodes; // number of four cc codes

455

DWORD dwAlignBoundarySrc; // source rectangle alignment

456

DWORD dwAlignSizeSrc; // source rectangle byte size

457

DWORD dwAlignBoundaryDest; // dest rectangle alignment

458

DWORD dwAlignSizeDest; // dest rectangle byte size

459

DWORD dwAlignStrideAlign; // stride alignment

460

DWORD dwRops[DD_ROP_SPACE]; // ROPS supported

461

DDSCAPS ddsCaps; // DDSCAPS structure has all the general capabilities

462

DWORD dwMinOverlayStretch; // minimum overlay stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3

463

DWORD dwMaxOverlayStretch; // maximum overlay stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3

464

DWORD dwMinLiveVideoStretch; // minimum live video stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3

465

DWORD dwMaxLiveVideoStretch; // maximum live video stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3

466

DWORD dwMinHwCodecStretch; // minimum hardware codec stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3

467

DWORD dwMaxHwCodecStretch; // maximum hardware codec stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3

468

DWORD dwReserved1; // reserved

469

DWORD dwReserved2; // reserved

470

DWORD dwReserved3; // reserved

471

DWORD dwSVBCaps; // driver specific capabilities for System->Vmem blts

472

DWORD dwSVBCKeyCaps; // driver color key capabilities for System->Vmem blts

473

DWORD dwSVBFXCaps; // driver FX capabilities for System->Vmem blts

474

DWORD dwSVBRops[DD_ROP_SPACE];// ROPS supported for System->Vmem blts

475

DWORD dwVSBCaps; // driver specific capabilities for Vmem->System blts

476

DWORD dwVSBCKeyCaps; // driver color key capabilities for Vmem->System blts

477

DWORD dwVSBFXCaps; // driver FX capabilities for Vmem->System blts

478

DWORD dwVSBRops[DD_ROP_SPACE];// ROPS supported for Vmem->System blts

479

DWORD dwSSBCaps; // driver specific capabilities for System->System blts

480

DWORD dwSSBCKeyCaps; // driver color key capabilities for System->System blts

481

DWORD dwSSBFXCaps; // driver FX capabilities for System->System blts

482

DWORD dwSSBRops[DD_ROP_SPACE];// ROPS supported for System->System blts

483

DWORD dwReserved4; // reserved

484

DWORD dwReserved5; // reserved

485

DWORD dwReserved6; // reserved

486

} DDCAPS_DX3;

487

typedef DDCAPS_DX3 FAR* LPDDCAPS_DX3;

488

489

/*

490

* This structure is the DDCAPS structure as it was in version 5 of Direct X.

491

* It is present for back compatability.

492

*/

493

typedef struct _DDCAPS_DX5

494

{

495

/* 0*/ DWORD dwSize; // size of the DDDRIVERCAPS structure

496

/* 4*/ DWORD dwCaps; // driver specific capabilities

497

/* 8*/ DWORD dwCaps2; // more driver specific capabilites

498

/* c*/ DWORD dwCKeyCaps; // color key capabilities of the surface

499

/* 10*/ DWORD dwFXCaps; // driver specific stretching and effects capabilites

500

/* 14*/ DWORD dwFXAlphaCaps; // alpha driver specific capabilities

501

/* 18*/ DWORD dwPalCaps; // palette capabilities

502

/* 1c*/ DWORD dwSVCaps; // stereo vision capabilities

503

/* 20*/ DWORD dwAlphaBltConstBitDepths; // DDBD_2,4,8

504

/* 24*/ DWORD dwAlphaBltPixelBitDepths; // DDBD_1,2,4,8

505

/* 28*/ DWORD dwAlphaBltSurfaceBitDepths; // DDBD_1,2,4,8

506

/* 2c*/ DWORD dwAlphaOverlayConstBitDepths; // DDBD_2,4,8

507

/* 30*/ DWORD dwAlphaOverlayPixelBitDepths; // DDBD_1,2,4,8

508

/* 34*/ DWORD dwAlphaOverlaySurfaceBitDepths; // DDBD_1,2,4,8

509

/* 38*/ DWORD dwZBufferBitDepths; // DDBD_8,16,24,32

510

/* 3c*/ DWORD dwVidMemTotal; // total amount of video memory

511

/* 40*/ DWORD dwVidMemFree; // amount of free video memory

512

/* 44*/ DWORD dwMaxVisibleOverlays; // maximum number of visible overlays

513

/* 48*/ DWORD dwCurrVisibleOverlays; // current number of visible overlays

514

/* 4c*/ DWORD dwNumFourCCCodes; // number of four cc codes

515

/* 50*/ DWORD dwAlignBoundarySrc; // source rectangle alignment

516

/* 54*/ DWORD dwAlignSizeSrc; // source rectangle byte size

517

/* 58*/ DWORD dwAlignBoundaryDest; // dest rectangle alignment

518

/* 5c*/ DWORD dwAlignSizeDest; // dest rectangle byte size

519

/* 60*/ DWORD dwAlignStrideAlign; // stride alignment

520

/* 64*/ DWORD dwRops[DD_ROP_SPACE]; // ROPS supported

521

/* 84*/ DDSCAPS ddsCaps; // DDSCAPS structure has all the general capabilities

522

/* 88*/ DWORD dwMinOverlayStretch; // minimum overlay stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3

523

/* 8c*/ DWORD dwMaxOverlayStretch; // maximum overlay stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3

524

/* 90*/ DWORD dwMinLiveVideoStretch; // minimum live video stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3

525

/* 94*/ DWORD dwMaxLiveVideoStretch; // maximum live video stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3

526

/* 98*/ DWORD dwMinHwCodecStretch; // minimum hardware codec stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3

527

/* 9c*/ DWORD dwMaxHwCodecStretch; // maximum hardware codec stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3

528

/* a0*/ DWORD dwReserved1; // reserved

529

/* a4*/ DWORD dwReserved2; // reserved

530

/* a8*/ DWORD dwReserved3; // reserved

531

/* ac*/ DWORD dwSVBCaps; // driver specific capabilities for System->Vmem blts

532

/* b0*/ DWORD dwSVBCKeyCaps; // driver color key capabilities for System->Vmem blts

533

/* b4*/ DWORD dwSVBFXCaps; // driver FX capabilities for System->Vmem blts

534

/* b8*/ DWORD dwSVBRops[DD_ROP_SPACE];// ROPS supported for System->Vmem blts

535

/* d8*/ DWORD dwVSBCaps; // driver specific capabilities for Vmem->System blts

536

/* dc*/ DWORD dwVSBCKeyCaps; // driver color key capabilities for Vmem->System blts

537

/* e0*/ DWORD dwVSBFXCaps; // driver FX capabilities for Vmem->System blts

538

/* e4*/ DWORD dwVSBRops[DD_ROP_SPACE];// ROPS supported for Vmem->System blts

539

/*104*/ DWORD dwSSBCaps; // driver specific capabilities for System->System blts

540

/*108*/ DWORD dwSSBCKeyCaps; // driver color key capabilities for System->System blts

541

/*10c*/ DWORD dwSSBFXCaps; // driver FX capabilities for System->System blts

542

/*110*/ DWORD dwSSBRops[DD_ROP_SPACE];// ROPS supported for System->System blts

543

// Members added for DX5:

544

/*130*/ DWORD dwMaxVideoPorts; // maximum number of usable video ports

545

/*134*/ DWORD dwCurrVideoPorts; // current number of video ports used

546

/*138*/ DWORD dwSVBCaps2; // more driver specific capabilities for System->Vmem blts

547

/*13c*/ DWORD dwNLVBCaps; // driver specific capabilities for non-local->local vidmem blts

548

/*140*/ DWORD dwNLVBCaps2; // more driver specific capabilities non-local->local vidmem blts

549

/*144*/ DWORD dwNLVBCKeyCaps; // driver color key capabilities for non-local->local vidmem blts

550

/*148*/ DWORD dwNLVBFXCaps; // driver FX capabilities for non-local->local blts

551

/*14c*/ DWORD dwNLVBRops[DD_ROP_SPACE]; // ROPS supported for non-local->local blts

552

} DDCAPS_DX5;

553

typedef DDCAPS_DX5 FAR* LPDDCAPS_DX5;

554

555

typedef struct _DDCAPS_DX6

556

{

557

/* 0*/ DWORD dwSize; // size of the DDDRIVERCAPS structure

558

/* 4*/ DWORD dwCaps; // driver specific capabilities

559

/* 8*/ DWORD dwCaps2; // more driver specific capabilites

560

/* c*/ DWORD dwCKeyCaps; // color key capabilities of the surface

561

/* 10*/ DWORD dwFXCaps; // driver specific stretching and effects capabilites

562

/* 14*/ DWORD dwFXAlphaCaps; // alpha caps

563

/* 18*/ DWORD dwPalCaps; // palette capabilities

564

/* 1c*/ DWORD dwSVCaps; // stereo vision capabilities

565

/* 20*/ DWORD dwAlphaBltConstBitDepths; // DDBD_2,4,8

566

/* 24*/ DWORD dwAlphaBltPixelBitDepths; // DDBD_1,2,4,8

567

/* 28*/ DWORD dwAlphaBltSurfaceBitDepths; // DDBD_1,2,4,8

568

/* 2c*/ DWORD dwAlphaOverlayConstBitDepths; // DDBD_2,4,8

569

/* 30*/ DWORD dwAlphaOverlayPixelBitDepths; // DDBD_1,2,4,8

570

/* 34*/ DWORD dwAlphaOverlaySurfaceBitDepths; // DDBD_1,2,4,8

571

/* 38*/ DWORD dwZBufferBitDepths; // DDBD_8,16,24,32

572

/* 3c*/ DWORD dwVidMemTotal; // total amount of video memory

573

/* 40*/ DWORD dwVidMemFree; // amount of free video memory

574

/* 44*/ DWORD dwMaxVisibleOverlays; // maximum number of visible overlays

575

/* 48*/ DWORD dwCurrVisibleOverlays; // current number of visible overlays

576

/* 4c*/ DWORD dwNumFourCCCodes; // number of four cc codes

577

/* 50*/ DWORD dwAlignBoundarySrc; // source rectangle alignment

578

/* 54*/ DWORD dwAlignSizeSrc; // source rectangle byte size

579

/* 58*/ DWORD dwAlignBoundaryDest; // dest rectangle alignment

580

/* 5c*/ DWORD dwAlignSizeDest; // dest rectangle byte size

581

/* 60*/ DWORD dwAlignStrideAlign; // stride alignment

582

/* 64*/ DWORD dwRops[DD_ROP_SPACE]; // ROPS supported

583

/* 84*/ DDSCAPS ddsOldCaps; // Was DDSCAPS ddsCaps. ddsCaps is of type DDSCAPS2 for DX6

584

/* 88*/ DWORD dwMinOverlayStretch; // minimum overlay stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3

585

/* 8c*/ DWORD dwMaxOverlayStretch; // maximum overlay stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3

586

/* 90*/ DWORD dwMinLiveVideoStretch; // minimum live video stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3

587

/* 94*/ DWORD dwMaxLiveVideoStretch; // maximum live video stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3

588

/* 98*/ DWORD dwMinHwCodecStretch; // minimum hardware codec stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3

589

/* 9c*/ DWORD dwMaxHwCodecStretch; // maximum hardware codec stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3

590

/* a0*/ DWORD dwReserved1; // reserved

591

/* a4*/ DWORD dwReserved2; // reserved

592

/* a8*/ DWORD dwReserved3; // reserved

593

/* ac*/ DWORD dwSVBCaps; // driver specific capabilities for System->Vmem blts

594

/* b0*/ DWORD dwSVBCKeyCaps; // driver color key capabilities for System->Vmem blts

595

/* b4*/ DWORD dwSVBFXCaps; // driver FX capabilities for System->Vmem blts

596

/* b8*/ DWORD dwSVBRops[DD_ROP_SPACE];// ROPS supported for System->Vmem blts

597

/* d8*/ DWORD dwVSBCaps; // driver specific capabilities for Vmem->System blts

598

/* dc*/ DWORD dwVSBCKeyCaps; // driver color key capabilities for Vmem->System blts

599

/* e0*/ DWORD dwVSBFXCaps; // driver FX capabilities for Vmem->System blts

600

/* e4*/ DWORD dwVSBRops[DD_ROP_SPACE];// ROPS supported for Vmem->System blts

601

/*104*/ DWORD dwSSBCaps; // driver specific capabilities for System->System blts

602

/*108*/ DWORD dwSSBCKeyCaps; // driver color key capabilities for System->System blts

603

/*10c*/ DWORD dwSSBFXCaps; // driver FX capabilities for System->System blts

604

/*110*/ DWORD dwSSBRops[DD_ROP_SPACE];// ROPS supported for System->System blts

605

/*130*/ DWORD dwMaxVideoPorts; // maximum number of usable video ports

606

/*134*/ DWORD dwCurrVideoPorts; // current number of video ports used

607

/*138*/ DWORD dwSVBCaps2; // more driver specific capabilities for System->Vmem blts

608

/*13c*/ DWORD dwNLVBCaps; // driver specific capabilities for non-local->local vidmem blts

609

/*140*/ DWORD dwNLVBCaps2; // more driver specific capabilities non-local->local vidmem blts

610

/*144*/ DWORD dwNLVBCKeyCaps; // driver color key capabilities for non-local->local vidmem blts

611

/*148*/ DWORD dwNLVBFXCaps; // driver FX capabilities for non-local->local blts

612

/*14c*/ DWORD dwNLVBRops[DD_ROP_SPACE]; // ROPS supported for non-local->local blts

613

// Members added for DX6 release

614

/*16c*/ DDSCAPS2 ddsCaps; // Surface Caps

615

} DDCAPS_DX6;

616

typedef DDCAPS_DX6 FAR* LPDDCAPS_DX6;

617

618

typedef struct _DDCAPS_DX7

619

{

620

/* 0*/ DWORD dwSize; // size of the DDDRIVERCAPS structure

621

/* 4*/ DWORD dwCaps; // driver specific capabilities

622

/* 8*/ DWORD dwCaps2; // more driver specific capabilites

623

/* c*/ DWORD dwCKeyCaps; // color key capabilities of the surface

624

/* 10*/ DWORD dwFXCaps; // driver specific stretching and effects capabilites

625

/* 14*/ DWORD dwFXAlphaCaps; // alpha driver specific capabilities

626

/* 18*/ DWORD dwPalCaps; // palette capabilities

627

/* 1c*/ DWORD dwSVCaps; // stereo vision capabilities

628

/* 20*/ DWORD dwAlphaBltConstBitDepths; // DDBD_2,4,8

629

/* 24*/ DWORD dwAlphaBltPixelBitDepths; // DDBD_1,2,4,8

630

/* 28*/ DWORD dwAlphaBltSurfaceBitDepths; // DDBD_1,2,4,8

631

/* 2c*/ DWORD dwAlphaOverlayConstBitDepths; // DDBD_2,4,8

632

/* 30*/ DWORD dwAlphaOverlayPixelBitDepths; // DDBD_1,2,4,8

633

/* 34*/ DWORD dwAlphaOverlaySurfaceBitDepths; // DDBD_1,2,4,8

634

/* 38*/ DWORD dwZBufferBitDepths; // DDBD_8,16,24,32

635

/* 3c*/ DWORD dwVidMemTotal; // total amount of video memory

636

/* 40*/ DWORD dwVidMemFree; // amount of free video memory

637

/* 44*/ DWORD dwMaxVisibleOverlays; // maximum number of visible overlays

638

/* 48*/ DWORD dwCurrVisibleOverlays; // current number of visible overlays

639

/* 4c*/ DWORD dwNumFourCCCodes; // number of four cc codes

640

/* 50*/ DWORD dwAlignBoundarySrc; // source rectangle alignment

641

/* 54*/ DWORD dwAlignSizeSrc; // source rectangle byte size

642

/* 58*/ DWORD dwAlignBoundaryDest; // dest rectangle alignment

643

/* 5c*/ DWORD dwAlignSizeDest; // dest rectangle byte size

644

/* 60*/ DWORD dwAlignStrideAlign; // stride alignment

645

/* 64*/ DWORD dwRops[DD_ROP_SPACE]; // ROPS supported

646

/* 84*/ DDSCAPS ddsOldCaps; // Was DDSCAPS ddsCaps. ddsCaps is of type DDSCAPS2 for DX6

647

/* 88*/ DWORD dwMinOverlayStretch; // minimum overlay stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3

648

/* 8c*/ DWORD dwMaxOverlayStretch; // maximum overlay stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3

649

/* 90*/ DWORD dwMinLiveVideoStretch; // minimum live video stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3

650

/* 94*/ DWORD dwMaxLiveVideoStretch; // maximum live video stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3

651

/* 98*/ DWORD dwMinHwCodecStretch; // minimum hardware codec stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3

652

/* 9c*/ DWORD dwMaxHwCodecStretch; // maximum hardware codec stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3

653

/* a0*/ DWORD dwReserved1; // reserved

654

/* a4*/ DWORD dwReserved2; // reserved

655

/* a8*/ DWORD dwReserved3; // reserved

656

/* ac*/ DWORD dwSVBCaps; // driver specific capabilities for System->Vmem blts

657

/* b0*/ DWORD dwSVBCKeyCaps; // driver color key capabilities for System->Vmem blts

658

/* b4*/ DWORD dwSVBFXCaps; // driver FX capabilities for System->Vmem blts

659

/* b8*/ DWORD dwSVBRops[DD_ROP_SPACE];// ROPS supported for System->Vmem blts

660

/* d8*/ DWORD dwVSBCaps; // driver specific capabilities for Vmem->System blts

661

/* dc*/ DWORD dwVSBCKeyCaps; // driver color key capabilities for Vmem->System blts

662

/* e0*/ DWORD dwVSBFXCaps; // driver FX capabilities for Vmem->System blts

663

/* e4*/ DWORD dwVSBRops[DD_ROP_SPACE];// ROPS supported for Vmem->System blts

664

/*104*/ DWORD dwSSBCaps; // driver specific capabilities for System->System blts

665

/*108*/ DWORD dwSSBCKeyCaps; // driver color key capabilities for System->System blts

666

/*10c*/ DWORD dwSSBFXCaps; // driver FX capabilities for System->System blts

667

/*110*/ DWORD dwSSBRops[DD_ROP_SPACE];// ROPS supported for System->System blts

668

/*130*/ DWORD dwMaxVideoPorts; // maximum number of usable video ports

669

/*134*/ DWORD dwCurrVideoPorts; // current number of video ports used

670

/*138*/ DWORD dwSVBCaps2; // more driver specific capabilities for System->Vmem blts

671

/*13c*/ DWORD dwNLVBCaps; // driver specific capabilities for non-local->local vidmem blts

672

/*140*/ DWORD dwNLVBCaps2; // more driver specific capabilities non-local->local vidmem blts

673

/*144*/ DWORD dwNLVBCKeyCaps; // driver color key capabilities for non-local->local vidmem blts

674

/*148*/ DWORD dwNLVBFXCaps; // driver FX capabilities for non-local->local blts

675

/*14c*/ DWORD dwNLVBRops[DD_ROP_SPACE]; // ROPS supported for non-local->local blts

676

// Members added for DX6 release

677

/*16c*/ DDSCAPS2 ddsCaps; // Surface Caps

678

} DDCAPS_DX7;

679

typedef DDCAPS_DX7 FAR* LPDDCAPS_DX7;

680

681

682

#if DIRECTDRAW_VERSION <= 0x300

683

typedef DDCAPS_DX3 DDCAPS;

684

#elif DIRECTDRAW_VERSION <= 0x500

685

typedef DDCAPS_DX5 DDCAPS;

686

#elif DIRECTDRAW_VERSION <= 0x600

687

typedef DDCAPS_DX6 DDCAPS;

688

#else

689

typedef DDCAPS_DX7 DDCAPS;

690

#endif

691

692

typedef DDCAPS FAR* LPDDCAPS;

693

694

695

696

/*

697

* DDPIXELFORMAT

698

*/

699

typedef struct _DDPIXELFORMAT

700

{

701

DWORD dwSize; // size of structure

702

DWORD dwFlags; // pixel format flags

703

DWORD dwFourCC; // (FOURCC code)

704

union

705

{

706

DWORD dwRGBBitCount; // how many bits per pixel

707

DWORD dwYUVBitCount; // how many bits per pixel

708

DWORD dwZBufferBitDepth; // how many total bits/pixel in z buffer (including any stencil bits)

709

DWORD dwAlphaBitDepth; // how many bits for alpha channels

710

DWORD dwLuminanceBitCount; // how many bits per pixel

711

DWORD dwBumpBitCount; // how many bits per "buxel", total

712

DWORD dwPrivateFormatBitCount;// Bits per pixel of private driver formats. Only valid in texture

713

// format list and if DDPF_D3DFORMAT is set

714

} DUMMYUNIONNAMEN(1);

715

union

716

{

717

DWORD dwRBitMask; // mask for red bit

718

DWORD dwYBitMask; // mask for Y bits

719

DWORD dwStencilBitDepth; // how many stencil bits (note: dwZBufferBitDepth-dwStencilBitDepth is total Z-only bits)

720

DWORD dwLuminanceBitMask; // mask for luminance bits

721

DWORD dwBumpDuBitMask; // mask for bump map U delta bits

722

DWORD dwOperations; // DDPF_D3DFORMAT Operations

723

} DUMMYUNIONNAMEN(2);

724

union

725

{

726

DWORD dwGBitMask; // mask for green bits

727

DWORD dwUBitMask; // mask for U bits

728

DWORD dwZBitMask; // mask for Z bits

729

DWORD dwBumpDvBitMask; // mask for bump map V delta bits

730

struct

731

{

732

WORD wFlipMSTypes; // Multisample methods supported via flip for this D3DFORMAT

733

WORD wBltMSTypes; // Multisample methods supported via blt for this D3DFORMAT

734

} MultiSampleCaps;

735

736

} DUMMYUNIONNAMEN(3);

737

union

738

{

739

DWORD dwBBitMask; // mask for blue bits

740

DWORD dwVBitMask; // mask for V bits

741

DWORD dwStencilBitMask; // mask for stencil bits

742

DWORD dwBumpLuminanceBitMask; // mask for luminance in bump map

743

} DUMMYUNIONNAMEN(4);

744

union

745

{

746

DWORD dwRGBAlphaBitMask; // mask for alpha channel

747

DWORD dwYUVAlphaBitMask; // mask for alpha channel

748

DWORD dwLuminanceAlphaBitMask;// mask for alpha channel

749

DWORD dwRGBZBitMask; // mask for Z channel

750

DWORD dwYUVZBitMask; // mask for Z channel

751

} DUMMYUNIONNAMEN(5);

752

} DDPIXELFORMAT;

753

754

typedef DDPIXELFORMAT FAR* LPDDPIXELFORMAT;

755

756

/*

757

* DDOVERLAYFX

758

*/

759

typedef struct _DDOVERLAYFX

760

{

761

DWORD dwSize; // size of structure

762

DWORD dwAlphaEdgeBlendBitDepth; // Bit depth used to specify constant for alpha edge blend

763

DWORD dwAlphaEdgeBlend; // Constant to use as alpha for edge blend

764

DWORD dwReserved;

765

DWORD dwAlphaDestConstBitDepth; // Bit depth used to specify alpha constant for destination

766

union

767

{

768

DWORD dwAlphaDestConst; // Constant to use as alpha channel for dest

769

LPDIRECTDRAWSURFACE lpDDSAlphaDest; // Surface to use as alpha channel for dest

770

} DUMMYUNIONNAMEN(1);

771

DWORD dwAlphaSrcConstBitDepth; // Bit depth used to specify alpha constant for source

772

union

773

{

774

DWORD dwAlphaSrcConst; // Constant to use as alpha channel for src

775

LPDIRECTDRAWSURFACE lpDDSAlphaSrc; // Surface to use as alpha channel for src

776

} DUMMYUNIONNAMEN(2);

777

DDCOLORKEY dckDestColorkey; // DestColorkey override

778

DDCOLORKEY dckSrcColorkey; // DestColorkey override

779

DWORD dwDDFX; // Overlay FX

780

DWORD dwFlags; // flags

781

} DDOVERLAYFX;

782

783

typedef DDOVERLAYFX FAR *LPDDOVERLAYFX;

784

785

786

/*

787

* DDBLTBATCH: BltBatch entry structure

788

*/

789

typedef struct _DDBLTBATCH

790

{

791

LPRECT lprDest;

792

LPDIRECTDRAWSURFACE lpDDSSrc;

793

LPRECT lprSrc;

794

DWORD dwFlags;

795

LPDDBLTFX lpDDBltFx;

796

} DDBLTBATCH;

797

798

typedef DDBLTBATCH FAR * LPDDBLTBATCH;

799

800

801

/*

802

* DDGAMMARAMP

803

*/

804

typedef struct _DDGAMMARAMP

805

{

806

WORD red[256];

807

WORD green[256];

808

WORD blue[256];

809

} DDGAMMARAMP;

810

typedef DDGAMMARAMP FAR * LPDDGAMMARAMP;

811

812

/*

813

* This is the structure within which DirectDraw returns data about the current graphics driver and chipset

814

*/

815

816

#define MAX_DDDEVICEID_STRING 512

817

818

typedef struct tagDDDEVICEIDENTIFIER

819

{

820

/*

821

* These elements are for presentation to the user only. They should not be used to identify particular

822

* drivers, since this is unreliable and many different strings may be associated with the same

823

* device, and the same driver from different vendors.

824

*/

825

char szDriver[MAX_DDDEVICEID_STRING];

826

char szDescription[MAX_DDDEVICEID_STRING];

827

828

/*

829

* This element is the version of the DirectDraw/3D driver. It is legal to do <, > comparisons

830

* on the whole 64 bits. Caution should be exercised if you use this element to identify problematic

831

* drivers. It is recommended that guidDeviceIdentifier is used for this purpose.

832

*

833

* This version has the form:

834

* wProduct = HIWORD(liDriverVersion.HighPart)

835

* wVersion = LOWORD(liDriverVersion.HighPart)

836

* wSubVersion = HIWORD(liDriverVersion.LowPart)

837

* wBuild = LOWORD(liDriverVersion.LowPart)

838

*/

839

#ifdef _WIN32

840

LARGE_INTEGER liDriverVersion; /* Defined for applications and other 32 bit components */

841

#else

842

DWORD dwDriverVersionLowPart; /* Defined for 16 bit driver components */

843

DWORD dwDriverVersionHighPart;

844

#endif

845

846

847

/*

848

* These elements can be used to identify particular chipsets. Use with extreme caution.

849

* dwVendorId Identifies the manufacturer. May be zero if unknown.

850

* dwDeviceId Identifies the type of chipset. May be zero if unknown.

851

* dwSubSysId Identifies the subsystem, typically this means the particular board. May be zero if unknown.

852

* dwRevision Identifies the revision level of the chipset. May be zero if unknown.

853

*/

854

DWORD dwVendorId;

855

DWORD dwDeviceId;

856

DWORD dwSubSysId;

857

DWORD dwRevision;

858

859

/*

860

* This element can be used to check changes in driver/chipset. This GUID is a unique identifier for the

861

* driver/chipset pair. Use this element if you wish to track changes to the driver/chipset in order to

862

* reprofile the graphics subsystem.

863

* This element can also be used to identify particular problematic drivers.

864

*/

865

GUID guidDeviceIdentifier;

866

} DDDEVICEIDENTIFIER, * LPDDDEVICEIDENTIFIER;

867

868

typedef struct tagDDDEVICEIDENTIFIER2

869

{

870

/*

871

* These elements are for presentation to the user only. They should not be used to identify particular

872

* drivers, since this is unreliable and many different strings may be associated with the same

873

* device, and the same driver from different vendors.

874

*/

875

char szDriver[MAX_DDDEVICEID_STRING];

876

char szDescription[MAX_DDDEVICEID_STRING];

877

878

/*

879

* This element is the version of the DirectDraw/3D driver. It is legal to do <, > comparisons

880

* on the whole 64 bits. Caution should be exercised if you use this element to identify problematic

881

* drivers. It is recommended that guidDeviceIdentifier is used for this purpose.

882

*

883

* This version has the form:

884

* wProduct = HIWORD(liDriverVersion.HighPart)

885

* wVersion = LOWORD(liDriverVersion.HighPart)

886

* wSubVersion = HIWORD(liDriverVersion.LowPart)

887

* wBuild = LOWORD(liDriverVersion.LowPart)

888

*/

889

#ifdef _WIN32

890

LARGE_INTEGER liDriverVersion; /* Defined for applications and other 32 bit components */

891

#else

892

DWORD dwDriverVersionLowPart; /* Defined for 16 bit driver components */

893

DWORD dwDriverVersionHighPart;

894

#endif

895

896

897

/*

898

* These elements can be used to identify particular chipsets. Use with extreme caution.

899

* dwVendorId Identifies the manufacturer. May be zero if unknown.

900

* dwDeviceId Identifies the type of chipset. May be zero if unknown.

901

* dwSubSysId Identifies the subsystem, typically this means the particular board. May be zero if unknown.

902

* dwRevision Identifies the revision level of the chipset. May be zero if unknown.

903

*/

904

DWORD dwVendorId;

905

DWORD dwDeviceId;

906

DWORD dwSubSysId;

907

DWORD dwRevision;

908

909

/*

910

* This element can be used to check changes in driver/chipset. This GUID is a unique identifier for the

911

* driver/chipset pair. Use this element if you wish to track changes to the driver/chipset in order to

912

* reprofile the graphics subsystem.

913

* This element can also be used to identify particular problematic drivers.

914

*/

915

GUID guidDeviceIdentifier;

916

917

/*

918

* This element is used to determine the Windows Hardware Quality Lab (WHQL)

919

* certification level for this driver/device pair.

920

*/

921

DWORD dwWHQLLevel;

922

923

} DDDEVICEIDENTIFIER2, * LPDDDEVICEIDENTIFIER2;

924

925

/*

926

* Flags for the IDirectDraw4::GetDeviceIdentifier method

927

*/

928

929

/*

930

* This flag causes GetDeviceIdentifier to return information about the host (typically 2D) adapter in a system equipped

931

* with a stacked secondary 3D adapter. Such an adapter appears to the application as if it were part of the

932

* host adapter, but is typically physcially located on a separate card. The stacked secondary's information is

933

* returned when GetDeviceIdentifier's dwFlags field is zero, since this most accurately reflects the qualities

934

* of the DirectDraw object involved.

935

*/

936

#define DDGDI_GETHOSTIDENTIFIER 0x00000001L

937

938

/*

939

* Macros for interpretting DDEVICEIDENTIFIER2.dwWHQLLevel

940

*/

941

#define GET_WHQL_YEAR( dwWHQLLevel ) \

942

( (dwWHQLLevel) / 0x10000 )

943

#define GET_WHQL_MONTH( dwWHQLLevel ) \

944

( ( (dwWHQLLevel) / 0x100 ) & 0x00ff )

945

#define GET_WHQL_DAY( dwWHQLLevel ) \

946

( (dwWHQLLevel) & 0xff )

947

948

949

/*

950

* callbacks

951

*/

952

typedef DWORD (FAR PASCAL *LPCLIPPERCALLBACK)(LPDIRECTDRAWCLIPPER lpDDClipper, HWND hWnd, DWORD code, LPVOID lpContext );

953

#ifdef STREAMING

954

typedef DWORD (FAR PASCAL *LPSURFACESTREAMINGCALLBACK)(DWORD);

955

#endif

956

957

958

/*

959

* INTERACES FOLLOW:

960

* IDirectDraw

961

* IDirectDrawClipper

962

* IDirectDrawPalette

963

* IDirectDrawSurface

964

*/

965

966

/*

967

* IDirectDraw

968

*/

969

#if defined( _WIN32 ) && !defined( _NO_COM )

970

#undef INTERFACE

971

#define INTERFACE IDirectDraw

972

DECLARE_INTERFACE_( IDirectDraw, IUnknown )

973

{

974

/*** IUnknown methods ***/

975

STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE;

976

STDMETHOD_(ULONG,AddRef) (THIS) PURE;

977

STDMETHOD_(ULONG,Release) (THIS) PURE;

978

/*** IDirectDraw methods ***/

979

STDMETHOD(Compact)(THIS) PURE;

980

STDMETHOD(CreateClipper)(THIS_ DWORD, LPDIRECTDRAWCLIPPER FAR*, IUnknown FAR * ) PURE;

981

STDMETHOD(CreatePalette)(THIS_ DWORD, LPPALETTEENTRY, LPDIRECTDRAWPALETTE FAR*, IUnknown FAR * ) PURE;

982

STDMETHOD(CreateSurface)(THIS_ LPDDSURFACEDESC, LPDIRECTDRAWSURFACE FAR *, IUnknown FAR *) PURE;

983

STDMETHOD(DuplicateSurface)( THIS_ LPDIRECTDRAWSURFACE, LPDIRECTDRAWSURFACE FAR * ) PURE;

984

STDMETHOD(EnumDisplayModes)( THIS_ DWORD, LPDDSURFACEDESC, LPVOID, LPDDENUMMODESCALLBACK ) PURE;

985

STDMETHOD(EnumSurfaces)(THIS_ DWORD, LPDDSURFACEDESC, LPVOID,LPDDENUMSURFACESCALLBACK ) PURE;

986

STDMETHOD(FlipToGDISurface)(THIS) PURE;

987

STDMETHOD(GetCaps)( THIS_ LPDDCAPS, LPDDCAPS) PURE;

988

STDMETHOD(GetDisplayMode)( THIS_ LPDDSURFACEDESC) PURE;

989

STDMETHOD(GetFourCCCodes)(THIS_ LPDWORD, LPDWORD ) PURE;

990

STDMETHOD(GetGDISurface)(THIS_ LPDIRECTDRAWSURFACE FAR *) PURE;

991

STDMETHOD(GetMonitorFrequency)(THIS_ LPDWORD) PURE;

992

STDMETHOD(GetScanLine)(THIS_ LPDWORD) PURE;

993

STDMETHOD(GetVerticalBlankStatus)(THIS_ LPBOOL ) PURE;

994

STDMETHOD(Initialize)(THIS_ GUID FAR *) PURE;

995

STDMETHOD(RestoreDisplayMode)(THIS) PURE;

996

STDMETHOD(SetCooperativeLevel)(THIS_ HWND, DWORD) PURE;

997

STDMETHOD(SetDisplayMode)(THIS_ DWORD, DWORD,DWORD) PURE;

998

STDMETHOD(WaitForVerticalBlank)(THIS_ DWORD, HANDLE ) PURE;

999

};

1000

1001

#if !defined(__cplusplus) || defined(CINTERFACE)

1002

#define IDirectDraw_QueryInterface(p, a, b) (p)->lpVtbl->QueryInterface(p, a, b)

1003

#define IDirectDraw_AddRef(p) (p)->lpVtbl->AddRef(p)

1004

#define IDirectDraw_Release(p) (p)->lpVtbl->Release(p)

1005

#define IDirectDraw_Compact(p) (p)->lpVtbl->Compact(p)

1006

#define IDirectDraw_CreateClipper(p, a, b, c) (p)->lpVtbl->CreateClipper(p, a, b, c)

1007

#define IDirectDraw_CreatePalette(p, a, b, c, d) (p)->lpVtbl->CreatePalette(p, a, b, c, d)

1008

#define IDirectDraw_CreateSurface(p, a, b, c) (p)->lpVtbl->CreateSurface(p, a, b, c)

1009

#define IDirectDraw_DuplicateSurface(p, a, b) (p)->lpVtbl->DuplicateSurface(p, a, b)

1010

#define IDirectDraw_EnumDisplayModes(p, a, b, c, d) (p)->lpVtbl->EnumDisplayModes(p, a, b, c, d)

1011

#define IDirectDraw_EnumSurfaces(p, a, b, c, d) (p)->lpVtbl->EnumSurfaces(p, a, b, c, d)

1012

#define IDirectDraw_FlipToGDISurface(p) (p)->lpVtbl->FlipToGDISurface(p)

1013

#define IDirectDraw_GetCaps(p, a, b) (p)->lpVtbl->GetCaps(p, a, b)

1014

#define IDirectDraw_GetDisplayMode(p, a) (p)->lpVtbl->GetDisplayMode(p, a)

1015

#define IDirectDraw_GetFourCCCodes(p, a, b) (p)->lpVtbl->GetFourCCCodes(p, a, b)

1016

#define IDirectDraw_GetGDISurface(p, a) (p)->lpVtbl->GetGDISurface(p, a)

1017

#define IDirectDraw_GetMonitorFrequency(p, a) (p)->lpVtbl->GetMonitorFrequency(p, a)

1018

#define IDirectDraw_GetScanLine(p, a) (p)->lpVtbl->GetScanLine(p, a)

1019

#define IDirectDraw_GetVerticalBlankStatus(p, a) (p)->lpVtbl->GetVerticalBlankStatus(p, a)

1020

#define IDirectDraw_Initialize(p, a) (p)->lpVtbl->Initialize(p, a)

1021

#define IDirectDraw_RestoreDisplayMode(p) (p)->lpVtbl->RestoreDisplayMode(p)

1022

#define IDirectDraw_SetCooperativeLevel(p, a, b) (p)->lpVtbl->SetCooperativeLevel(p, a, b)

1023

#define IDirectDraw_SetDisplayMode(p, a, b, c) (p)->lpVtbl->SetDisplayMode(p, a, b, c)

1024

#define IDirectDraw_WaitForVerticalBlank(p, a, b) (p)->lpVtbl->WaitForVerticalBlank(p, a, b)

1025

#else

1026

#define IDirectDraw_QueryInterface(p, a, b) (p)->QueryInterface(a, b)

1027

#define IDirectDraw_AddRef(p) (p)->AddRef()

1028

#define IDirectDraw_Release(p) (p)->Release()

1029

#define IDirectDraw_Compact(p) (p)->Compact()

1030

#define IDirectDraw_CreateClipper(p, a, b, c) (p)->CreateClipper(a, b, c)

1031

#define IDirectDraw_CreatePalette(p, a, b, c, d) (p)->CreatePalette(a, b, c, d)

1032

#define IDirectDraw_CreateSurface(p, a, b, c) (p)->CreateSurface(a, b, c)

1033

#define IDirectDraw_DuplicateSurface(p, a, b) (p)->DuplicateSurface(a, b)

1034

#define IDirectDraw_EnumDisplayModes(p, a, b, c, d) (p)->EnumDisplayModes(a, b, c, d)

1035

#define IDirectDraw_EnumSurfaces(p, a, b, c, d) (p)->EnumSurfaces(a, b, c, d)

1036

#define IDirectDraw_FlipToGDISurface(p) (p)->FlipToGDISurface()

1037

#define IDirectDraw_GetCaps(p, a, b) (p)->GetCaps(a, b)

1038

#define IDirectDraw_GetDisplayMode(p, a) (p)->GetDisplayMode(a)

1039

#define IDirectDraw_GetFourCCCodes(p, a, b) (p)->GetFourCCCodes(a, b)

1040

#define IDirectDraw_GetGDISurface(p, a) (p)->GetGDISurface(a)

1041

#define IDirectDraw_GetMonitorFrequency(p, a) (p)->GetMonitorFrequency(a)

1042

#define IDirectDraw_GetScanLine(p, a) (p)->GetScanLine(a)

1043

#define IDirectDraw_GetVerticalBlankStatus(p, a) (p)->GetVerticalBlankStatus(a)

1044

#define IDirectDraw_Initialize(p, a) (p)->Initialize(a)

1045

#define IDirectDraw_RestoreDisplayMode(p) (p)->RestoreDisplayMode()

1046

#define IDirectDraw_SetCooperativeLevel(p, a, b) (p)->SetCooperativeLevel(a, b)

1047

#define IDirectDraw_SetDisplayMode(p, a, b, c) (p)->SetDisplayMode(a, b, c)

1048

#define IDirectDraw_WaitForVerticalBlank(p, a, b) (p)->WaitForVerticalBlank(a, b)

1049

#endif

1050

1051

#endif

1052

1053

#if defined( _WIN32 ) && !defined( _NO_COM )

1054

#undef INTERFACE

1055

#define INTERFACE IDirectDraw2

1056

DECLARE_INTERFACE_( IDirectDraw2, IUnknown )

1057

{

1058

/*** IUnknown methods ***/

1059

STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE;

1060

STDMETHOD_(ULONG,AddRef) (THIS) PURE;

1061

STDMETHOD_(ULONG,Release) (THIS) PURE;

1062

/*** IDirectDraw methods ***/

1063

STDMETHOD(Compact)(THIS) PURE;

1064

STDMETHOD(CreateClipper)(THIS_ DWORD, LPDIRECTDRAWCLIPPER FAR*, IUnknown FAR * ) PURE;

1065

STDMETHOD(CreatePalette)(THIS_ DWORD, LPPALETTEENTRY, LPDIRECTDRAWPALETTE FAR*, IUnknown FAR * ) PURE;

1066

STDMETHOD(CreateSurface)(THIS_ LPDDSURFACEDESC, LPDIRECTDRAWSURFACE FAR *, IUnknown FAR *) PURE;

1067

STDMETHOD(DuplicateSurface)( THIS_ LPDIRECTDRAWSURFACE, LPDIRECTDRAWSURFACE FAR * ) PURE;

1068

STDMETHOD(EnumDisplayModes)( THIS_ DWORD, LPDDSURFACEDESC, LPVOID, LPDDENUMMODESCALLBACK ) PURE;

1069

STDMETHOD(EnumSurfaces)(THIS_ DWORD, LPDDSURFACEDESC, LPVOID,LPDDENUMSURFACESCALLBACK ) PURE;

1070

STDMETHOD(FlipToGDISurface)(THIS) PURE;

1071

STDMETHOD(GetCaps)( THIS_ LPDDCAPS, LPDDCAPS) PURE;

1072

STDMETHOD(GetDisplayMode)( THIS_ LPDDSURFACEDESC) PURE;

1073

STDMETHOD(GetFourCCCodes)(THIS_ LPDWORD, LPDWORD ) PURE;

1074

STDMETHOD(GetGDISurface)(THIS_ LPDIRECTDRAWSURFACE FAR *) PURE;

1075

STDMETHOD(GetMonitorFrequency)(THIS_ LPDWORD) PURE;

1076

STDMETHOD(GetScanLine)(THIS_ LPDWORD) PURE;

1077

STDMETHOD(GetVerticalBlankStatus)(THIS_ LPBOOL ) PURE;

1078

STDMETHOD(Initialize)(THIS_ GUID FAR *) PURE;

1079

STDMETHOD(RestoreDisplayMode)(THIS) PURE;

1080

STDMETHOD(SetCooperativeLevel)(THIS_ HWND, DWORD) PURE;

1081

STDMETHOD(SetDisplayMode)(THIS_ DWORD, DWORD,DWORD, DWORD, DWORD) PURE;

1082

STDMETHOD(WaitForVerticalBlank)(THIS_ DWORD, HANDLE ) PURE;

1083

/*** Added in the v2 interface ***/

1084

STDMETHOD(GetAvailableVidMem)(THIS_ LPDDSCAPS, LPDWORD, LPDWORD) PURE;

1085

};

1086

#if !defined(__cplusplus) || defined(CINTERFACE)

1087

#define IDirectDraw2_QueryInterface(p, a, b) (p)->lpVtbl->QueryInterface(p, a, b)

1088

#define IDirectDraw2_AddRef(p) (p)->lpVtbl->AddRef(p)

1089

#define IDirectDraw2_Release(p) (p)->lpVtbl->Release(p)

1090

#define IDirectDraw2_Compact(p) (p)->lpVtbl->Compact(p)

1091

#define IDirectDraw2_CreateClipper(p, a, b, c) (p)->lpVtbl->CreateClipper(p, a, b, c)

1092

#define IDirectDraw2_CreatePalette(p, a, b, c, d) (p)->lpVtbl->CreatePalette(p, a, b, c, d)

1093

#define IDirectDraw2_CreateSurface(p, a, b, c) (p)->lpVtbl->CreateSurface(p, a, b, c)

1094

#define IDirectDraw2_DuplicateSurface(p, a, b) (p)->lpVtbl->DuplicateSurface(p, a, b)

1095

#define IDirectDraw2_EnumDisplayModes(p, a, b, c, d) (p)->lpVtbl->EnumDisplayModes(p, a, b, c, d)

1096

#define IDirectDraw2_EnumSurfaces(p, a, b, c, d) (p)->lpVtbl->EnumSurfaces(p, a, b, c, d)

1097

#define IDirectDraw2_FlipToGDISurface(p) (p)->lpVtbl->FlipToGDISurface(p)

1098

#define IDirectDraw2_GetCaps(p, a, b) (p)->lpVtbl->GetCaps(p, a, b)

1099

#define IDirectDraw2_GetDisplayMode(p, a) (p)->lpVtbl->GetDisplayMode(p, a)

1100

#define IDirectDraw2_GetFourCCCodes(p, a, b) (p)->lpVtbl->GetFourCCCodes(p, a, b)

1101

#define IDirectDraw2_GetGDISurface(p, a) (p)->lpVtbl->GetGDISurface(p, a)

1102

#define IDirectDraw2_GetMonitorFrequency(p, a) (p)->lpVtbl->GetMonitorFrequency(p, a)

1103

#define IDirectDraw2_GetScanLine(p, a) (p)->lpVtbl->GetScanLine(p, a)

1104

#define IDirectDraw2_GetVerticalBlankStatus(p, a) (p)->lpVtbl->GetVerticalBlankStatus(p, a)

1105

#define IDirectDraw2_Initialize(p, a) (p)->lpVtbl->Initialize(p, a)

1106

#define IDirectDraw2_RestoreDisplayMode(p) (p)->lpVtbl->RestoreDisplayMode(p)

1107

#define IDirectDraw2_SetCooperativeLevel(p, a, b) (p)->lpVtbl->SetCooperativeLevel(p, a, b)

1108

#define IDirectDraw2_SetDisplayMode(p, a, b, c, d, e) (p)->lpVtbl->SetDisplayMode(p, a, b, c, d, e)

1109

#define IDirectDraw2_WaitForVerticalBlank(p, a, b) (p)->lpVtbl->WaitForVerticalBlank(p, a, b)

1110

#define IDirectDraw2_GetAvailableVidMem(p, a, b, c) (p)->lpVtbl->GetAvailableVidMem(p, a, b, c)

1111

#else

1112

#define IDirectDraw2_QueryInterface(p, a, b) (p)->QueryInterface(a, b)

1113

#define IDirectDraw2_AddRef(p) (p)->AddRef()

1114

#define IDirectDraw2_Release(p) (p)->Release()

1115

#define IDirectDraw2_Compact(p) (p)->Compact()

1116

#define IDirectDraw2_CreateClipper(p, a, b, c) (p)->CreateClipper(a, b, c)

1117

#define IDirectDraw2_CreatePalette(p, a, b, c, d) (p)->CreatePalette(a, b, c, d)

1118

#define IDirectDraw2_CreateSurface(p, a, b, c) (p)->CreateSurface(a, b, c)

1119

#define IDirectDraw2_DuplicateSurface(p, a, b) (p)->DuplicateSurface(a, b)

1120

#define IDirectDraw2_EnumDisplayModes(p, a, b, c, d) (p)->EnumDisplayModes(a, b, c, d)

1121

#define IDirectDraw2_EnumSurfaces(p, a, b, c, d) (p)->EnumSurfaces(a, b, c, d)

1122

#define IDirectDraw2_FlipToGDISurface(p) (p)->FlipToGDISurface()

1123

#define IDirectDraw2_GetCaps(p, a, b) (p)->GetCaps(a, b)

1124

#define IDirectDraw2_GetDisplayMode(p, a) (p)->GetDisplayMode(a)

1125

#define IDirectDraw2_GetFourCCCodes(p, a, b) (p)->GetFourCCCodes(a, b)

1126

#define IDirectDraw2_GetGDISurface(p, a) (p)->GetGDISurface(a)

1127

#define IDirectDraw2_GetMonitorFrequency(p, a) (p)->GetMonitorFrequency(a)

1128

#define IDirectDraw2_GetScanLine(p, a) (p)->GetScanLine(a)

1129

#define IDirectDraw2_GetVerticalBlankStatus(p, a) (p)->GetVerticalBlankStatus(a)

1130

#define IDirectDraw2_Initialize(p, a) (p)->Initialize(a)

1131

#define IDirectDraw2_RestoreDisplayMode(p) (p)->RestoreDisplayMode()

1132

#define IDirectDraw2_SetCooperativeLevel(p, a, b) (p)->SetCooperativeLevel(a, b)

1133

#define IDirectDraw2_SetDisplayMode(p, a, b, c, d, e) (p)->SetDisplayMode(a, b, c, d, e)

1134

#define IDirectDraw2_WaitForVerticalBlank(p, a, b) (p)->WaitForVerticalBlank(a, b)

1135

#define IDirectDraw2_GetAvailableVidMem(p, a, b, c) (p)->GetAvailableVidMem(a, b, c)

1136

#endif

1137

1138

#endif

1139

1140

#if defined( _WIN32 ) && !defined( _NO_COM )

1141

#undef INTERFACE

1142

#define INTERFACE IDirectDraw4

1143

DECLARE_INTERFACE_( IDirectDraw4, IUnknown )

1144

{

1145

/*** IUnknown methods ***/

1146

STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE;

1147

STDMETHOD_(ULONG,AddRef) (THIS) PURE;

1148

STDMETHOD_(ULONG,Release) (THIS) PURE;

1149

/*** IDirectDraw methods ***/

1150

STDMETHOD(Compact)(THIS) PURE;

1151

STDMETHOD(CreateClipper)(THIS_ DWORD, LPDIRECTDRAWCLIPPER FAR*, IUnknown FAR * ) PURE;

1152

STDMETHOD(CreatePalette)(THIS_ DWORD, LPPALETTEENTRY, LPDIRECTDRAWPALETTE FAR*, IUnknown FAR * ) PURE;

1153

STDMETHOD(CreateSurface)(THIS_ LPDDSURFACEDESC2, LPDIRECTDRAWSURFACE4 FAR *, IUnknown FAR *) PURE;

1154

STDMETHOD(DuplicateSurface)( THIS_ LPDIRECTDRAWSURFACE4, LPDIRECTDRAWSURFACE4 FAR * ) PURE;

1155

STDMETHOD(EnumDisplayModes)( THIS_ DWORD, LPDDSURFACEDESC2, LPVOID, LPDDENUMMODESCALLBACK2 ) PURE;

1156

STDMETHOD(EnumSurfaces)(THIS_ DWORD, LPDDSURFACEDESC2, LPVOID,LPDDENUMSURFACESCALLBACK2 ) PURE;

1157

STDMETHOD(FlipToGDISurface)(THIS) PURE;

1158

STDMETHOD(GetCaps)( THIS_ LPDDCAPS, LPDDCAPS) PURE;

1159

STDMETHOD(GetDisplayMode)( THIS_ LPDDSURFACEDESC2) PURE;

1160

STDMETHOD(GetFourCCCodes)(THIS_ LPDWORD, LPDWORD ) PURE;

1161

STDMETHOD(GetGDISurface)(THIS_ LPDIRECTDRAWSURFACE4 FAR *) PURE;

1162

STDMETHOD(GetMonitorFrequency)(THIS_ LPDWORD) PURE;

1163

STDMETHOD(GetScanLine)(THIS_ LPDWORD) PURE;

1164

STDMETHOD(GetVerticalBlankStatus)(THIS_ LPBOOL ) PURE;

1165

STDMETHOD(Initialize)(THIS_ GUID FAR *) PURE;

1166

STDMETHOD(RestoreDisplayMode)(THIS) PURE;

1167

STDMETHOD(SetCooperativeLevel)(THIS_ HWND, DWORD) PURE;

1168

STDMETHOD(SetDisplayMode)(THIS_ DWORD, DWORD,DWORD, DWORD, DWORD) PURE;

1169

STDMETHOD(WaitForVerticalBlank)(THIS_ DWORD, HANDLE ) PURE;

1170

/*** Added in the v2 interface ***/

1171

STDMETHOD(GetAvailableVidMem)(THIS_ LPDDSCAPS2, LPDWORD, LPDWORD) PURE;

1172

/*** Added in the V4 Interface ***/

1173

STDMETHOD(GetSurfaceFromDC) (THIS_ HDC, LPDIRECTDRAWSURFACE4 *) PURE;

1174

STDMETHOD(RestoreAllSurfaces)(THIS) PURE;

1175

STDMETHOD(TestCooperativeLevel)(THIS) PURE;

1176

STDMETHOD(GetDeviceIdentifier)(THIS_ LPDDDEVICEIDENTIFIER, DWORD ) PURE;

1177

};

1178

#if !defined(__cplusplus) || defined(CINTERFACE)

1179

#define IDirectDraw4_QueryInterface(p, a, b) (p)->lpVtbl->QueryInterface(p, a, b)

1180

#define IDirectDraw4_AddRef(p) (p)->lpVtbl->AddRef(p)

1181

#define IDirectDraw4_Release(p) (p)->lpVtbl->Release(p)

1182

#define IDirectDraw4_Compact(p) (p)->lpVtbl->Compact(p)

1183

#define IDirectDraw4_CreateClipper(p, a, b, c) (p)->lpVtbl->CreateClipper(p, a, b, c)

1184

#define IDirectDraw4_CreatePalette(p, a, b, c, d) (p)->lpVtbl->CreatePalette(p, a, b, c, d)

1185

#define IDirectDraw4_CreateSurface(p, a, b, c) (p)->lpVtbl->CreateSurface(p, a, b, c)

1186

#define IDirectDraw4_DuplicateSurface(p, a, b) (p)->lpVtbl->DuplicateSurface(p, a, b)

1187

#define IDirectDraw4_EnumDisplayModes(p, a, b, c, d) (p)->lpVtbl->EnumDisplayModes(p, a, b, c, d)

1188

#define IDirectDraw4_EnumSurfaces(p, a, b, c, d) (p)->lpVtbl->EnumSurfaces(p, a, b, c, d)

1189

#define IDirectDraw4_FlipToGDISurface(p) (p)->lpVtbl->FlipToGDISurface(p)

1190

#define IDirectDraw4_GetCaps(p, a, b) (p)->lpVtbl->GetCaps(p, a, b)

1191

#define IDirectDraw4_GetDisplayMode(p, a) (p)->lpVtbl->GetDisplayMode(p, a)

1192

#define IDirectDraw4_GetFourCCCodes(p, a, b) (p)->lpVtbl->GetFourCCCodes(p, a, b)

1193

#define IDirectDraw4_GetGDISurface(p, a) (p)->lpVtbl->GetGDISurface(p, a)

1194

#define IDirectDraw4_GetMonitorFrequency(p, a) (p)->lpVtbl->GetMonitorFrequency(p, a)

1195

#define IDirectDraw4_GetScanLine(p, a) (p)->lpVtbl->GetScanLine(p, a)

1196

#define IDirectDraw4_GetVerticalBlankStatus(p, a) (p)->lpVtbl->GetVerticalBlankStatus(p, a)

1197

#define IDirectDraw4_Initialize(p, a) (p)->lpVtbl->Initialize(p, a)

1198

#define IDirectDraw4_RestoreDisplayMode(p) (p)->lpVtbl->RestoreDisplayMode(p)

1199

#define IDirectDraw4_SetCooperativeLevel(p, a, b) (p)->lpVtbl->SetCooperativeLevel(p, a, b)

1200

#define IDirectDraw4_SetDisplayMode(p, a, b, c, d, e) (p)->lpVtbl->SetDisplayMode(p, a, b, c, d, e)

1201

#define IDirectDraw4_WaitForVerticalBlank(p, a, b) (p)->lpVtbl->WaitForVerticalBlank(p, a, b)

1202

#define IDirectDraw4_GetAvailableVidMem(p, a, b, c) (p)->lpVtbl->GetAvailableVidMem(p, a, b, c)

1203

#define IDirectDraw4_GetSurfaceFromDC(p, a, b) (p)->lpVtbl->GetSurfaceFromDC(p, a, b)

1204

#define IDirectDraw4_RestoreAllSurfaces(p) (p)->lpVtbl->RestoreAllSurfaces(p)

1205

#define IDirectDraw4_TestCooperativeLevel(p) (p)->lpVtbl->TestCooperativeLevel(p)

1206

#define IDirectDraw4_GetDeviceIdentifier(p,a,b) (p)->lpVtbl->GetDeviceIdentifier(p,a,b)

1207

#else

1208

#define IDirectDraw4_QueryInterface(p, a, b) (p)->QueryInterface(a, b)

1209

#define IDirectDraw4_AddRef(p) (p)->AddRef()

1210

#define IDirectDraw4_Release(p) (p)->Release()

1211

#define IDirectDraw4_Compact(p) (p)->Compact()

1212

#define IDirectDraw4_CreateClipper(p, a, b, c) (p)->CreateClipper(a, b, c)

1213

#define IDirectDraw4_CreatePalette(p, a, b, c, d) (p)->CreatePalette(a, b, c, d)

1214

#define IDirectDraw4_CreateSurface(p, a, b, c) (p)->CreateSurface(a, b, c)

1215

#define IDirectDraw4_DuplicateSurface(p, a, b) (p)->DuplicateSurface(a, b)

1216

#define IDirectDraw4_EnumDisplayModes(p, a, b, c, d) (p)->EnumDisplayModes(a, b, c, d)

1217

#define IDirectDraw4_EnumSurfaces(p, a, b, c, d) (p)->EnumSurfaces(a, b, c, d)

1218

#define IDirectDraw4_FlipToGDISurface(p) (p)->FlipToGDISurface()

1219

#define IDirectDraw4_GetCaps(p, a, b) (p)->GetCaps(a, b)

1220

#define IDirectDraw4_GetDisplayMode(p, a) (p)->GetDisplayMode(a)

1221

#define IDirectDraw4_GetFourCCCodes(p, a, b) (p)->GetFourCCCodes(a, b)

1222

#define IDirectDraw4_GetGDISurface(p, a) (p)->GetGDISurface(a)

1223

#define IDirectDraw4_GetMonitorFrequency(p, a) (p)->GetMonitorFrequency(a)

1224

#define IDirectDraw4_GetScanLine(p, a) (p)->GetScanLine(a)

1225

#define IDirectDraw4_GetVerticalBlankStatus(p, a) (p)->GetVerticalBlankStatus(a)

1226

#define IDirectDraw4_Initialize(p, a) (p)->Initialize(a)

1227

#define IDirectDraw4_RestoreDisplayMode(p) (p)->RestoreDisplayMode()

1228

#define IDirectDraw4_SetCooperativeLevel(p, a, b) (p)->SetCooperativeLevel(a, b)

1229

#define IDirectDraw4_SetDisplayMode(p, a, b, c, d, e) (p)->SetDisplayMode(a, b, c, d, e)

1230

#define IDirectDraw4_WaitForVerticalBlank(p, a, b) (p)->WaitForVerticalBlank(a, b)

1231

#define IDirectDraw4_GetAvailableVidMem(p, a, b, c) (p)->GetAvailableVidMem(a, b, c)

1232

#define IDirectDraw4_GetSurfaceFromDC(p, a, b) (p)->GetSurfaceFromDC(a, b)

1233

#define IDirectDraw4_RestoreAllSurfaces(p) (p)->RestoreAllSurfaces()

1234

#define IDirectDraw4_TestCooperativeLevel(p) (p)->TestCooperativeLevel()

1235

#define IDirectDraw4_GetDeviceIdentifier(p,a,b) (p)->GetDeviceIdentifier(a,b)

1236

#endif

1237

1238

#endif

1239

1240

#if defined( _WIN32 ) && !defined( _NO_COM )

1241

#undef INTERFACE

1242

#define INTERFACE IDirectDraw7

1243

DECLARE_INTERFACE_( IDirectDraw7, IUnknown )

1244

{

1245

/*** IUnknown methods ***/

1246

STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE;

1247

STDMETHOD_(ULONG,AddRef) (THIS) PURE;

1248

STDMETHOD_(ULONG,Release) (THIS) PURE;

1249

/*** IDirectDraw methods ***/

1250

STDMETHOD(Compact)(THIS) PURE;

1251

STDMETHOD(CreateClipper)(THIS_ DWORD, LPDIRECTDRAWCLIPPER FAR*, IUnknown FAR * ) PURE;

1252

STDMETHOD(CreatePalette)(THIS_ DWORD, LPPALETTEENTRY, LPDIRECTDRAWPALETTE FAR*, IUnknown FAR * ) PURE;

1253

STDMETHOD(CreateSurface)(THIS_ LPDDSURFACEDESC2, LPDIRECTDRAWSURFACE7 FAR *, IUnknown FAR *) PURE;

1254

STDMETHOD(DuplicateSurface)( THIS_ LPDIRECTDRAWSURFACE7, LPDIRECTDRAWSURFACE7 FAR * ) PURE;

1255

STDMETHOD(EnumDisplayModes)( THIS_ DWORD, LPDDSURFACEDESC2, LPVOID, LPDDENUMMODESCALLBACK2 ) PURE;

1256

STDMETHOD(EnumSurfaces)(THIS_ DWORD, LPDDSURFACEDESC2, LPVOID,LPDDENUMSURFACESCALLBACK7 ) PURE;

1257

STDMETHOD(FlipToGDISurface)(THIS) PURE;

1258

STDMETHOD(GetCaps)( THIS_ LPDDCAPS, LPDDCAPS) PURE;

1259

STDMETHOD(GetDisplayMode)( THIS_ LPDDSURFACEDESC2) PURE;

1260

STDMETHOD(GetFourCCCodes)(THIS_ LPDWORD, LPDWORD ) PURE;

1261

STDMETHOD(GetGDISurface)(THIS_ LPDIRECTDRAWSURFACE7 FAR *) PURE;

1262

STDMETHOD(GetMonitorFrequency)(THIS_ LPDWORD) PURE;

1263

STDMETHOD(GetScanLine)(THIS_ LPDWORD) PURE;

1264

STDMETHOD(GetVerticalBlankStatus)(THIS_ LPBOOL ) PURE;

1265

STDMETHOD(Initialize)(THIS_ GUID FAR *) PURE;

1266

STDMETHOD(RestoreDisplayMode)(THIS) PURE;

1267

STDMETHOD(SetCooperativeLevel)(THIS_ HWND, DWORD) PURE;

1268

STDMETHOD(SetDisplayMode)(THIS_ DWORD, DWORD,DWORD, DWORD, DWORD) PURE;

1269

STDMETHOD(WaitForVerticalBlank)(THIS_ DWORD, HANDLE ) PURE;

1270

/*** Added in the v2 interface ***/

1271

STDMETHOD(GetAvailableVidMem)(THIS_ LPDDSCAPS2, LPDWORD, LPDWORD) PURE;

1272

/*** Added in the V4 Interface ***/

1273

STDMETHOD(GetSurfaceFromDC) (THIS_ HDC, LPDIRECTDRAWSURFACE7 *) PURE;

1274

STDMETHOD(RestoreAllSurfaces)(THIS) PURE;

1275

STDMETHOD(TestCooperativeLevel)(THIS) PURE;

1276

STDMETHOD(GetDeviceIdentifier)(THIS_ LPDDDEVICEIDENTIFIER2, DWORD ) PURE;

1277

STDMETHOD(StartModeTest)(THIS_ LPSIZE, DWORD, DWORD ) PURE;

1278

STDMETHOD(EvaluateMode)(THIS_ DWORD, DWORD * ) PURE;

1279

};

1280

#if !defined(__cplusplus) || defined(CINTERFACE)

1281

#define IDirectDraw7_QueryInterface(p, a, b) (p)->lpVtbl->QueryInterface(p, a, b)

1282

#define IDirectDraw7_AddRef(p) (p)->lpVtbl->AddRef(p)

1283

#define IDirectDraw7_Release(p) (p)->lpVtbl->Release(p)

1284

#define IDirectDraw7_Compact(p) (p)->lpVtbl->Compact(p)

1285

#define IDirectDraw7_CreateClipper(p, a, b, c) (p)->lpVtbl->CreateClipper(p, a, b, c)

1286

#define IDirectDraw7_CreatePalette(p, a, b, c, d) (p)->lpVtbl->CreatePalette(p, a, b, c, d)

1287

#define IDirectDraw7_CreateSurface(p, a, b, c) (p)->lpVtbl->CreateSurface(p, a, b, c)

1288

#define IDirectDraw7_DuplicateSurface(p, a, b) (p)->lpVtbl->DuplicateSurface(p, a, b)

1289

#define IDirectDraw7_EnumDisplayModes(p, a, b, c, d) (p)->lpVtbl->EnumDisplayModes(p, a, b, c, d)

1290

#define IDirectDraw7_EnumSurfaces(p, a, b, c, d) (p)->lpVtbl->EnumSurfaces(p, a, b, c, d)

1291

#define IDirectDraw7_FlipToGDISurface(p) (p)->lpVtbl->FlipToGDISurface(p)

1292

#define IDirectDraw7_GetCaps(p, a, b) (p)->lpVtbl->GetCaps(p, a, b)

1293

#define IDirectDraw7_GetDisplayMode(p, a) (p)->lpVtbl->GetDisplayMode(p, a)

1294

#define IDirectDraw7_GetFourCCCodes(p, a, b) (p)->lpVtbl->GetFourCCCodes(p, a, b)

1295

#define IDirectDraw7_GetGDISurface(p, a) (p)->lpVtbl->GetGDISurface(p, a)

1296

#define IDirectDraw7_GetMonitorFrequency(p, a) (p)->lpVtbl->GetMonitorFrequency(p, a)

1297

#define IDirectDraw7_GetScanLine(p, a) (p)->lpVtbl->GetScanLine(p, a)

1298

#define IDirectDraw7_GetVerticalBlankStatus(p, a) (p)->lpVtbl->GetVerticalBlankStatus(p, a)

1299

#define IDirectDraw7_Initialize(p, a) (p)->lpVtbl->Initialize(p, a)

1300

#define IDirectDraw7_RestoreDisplayMode(p) (p)->lpVtbl->RestoreDisplayMode(p)

1301

#define IDirectDraw7_SetCooperativeLevel(p, a, b) (p)->lpVtbl->SetCooperativeLevel(p, a, b)

1302

#define IDirectDraw7_SetDisplayMode(p, a, b, c, d, e) (p)->lpVtbl->SetDisplayMode(p, a, b, c, d, e)

1303

#define IDirectDraw7_WaitForVerticalBlank(p, a, b) (p)->lpVtbl->WaitForVerticalBlank(p, a, b)

1304

#define IDirectDraw7_GetAvailableVidMem(p, a, b, c) (p)->lpVtbl->GetAvailableVidMem(p, a, b, c)

1305

#define IDirectDraw7_GetSurfaceFromDC(p, a, b) (p)->lpVtbl->GetSurfaceFromDC(p, a, b)

1306

#define IDirectDraw7_RestoreAllSurfaces(p) (p)->lpVtbl->RestoreAllSurfaces(p)

1307

#define IDirectDraw7_TestCooperativeLevel(p) (p)->lpVtbl->TestCooperativeLevel(p)

1308

#define IDirectDraw7_GetDeviceIdentifier(p,a,b) (p)->lpVtbl->GetDeviceIdentifier(p,a,b)

1309

#define IDirectDraw7_StartModeTest(p,a,b,c) (p)->lpVtbl->StartModeTest(p,a,b,c)

1310

#define IDirectDraw7_EvaluateMode(p,a,b) (p)->lpVtbl->EvaluateMode(p,a,b)

1311

#else

1312

#define IDirectDraw7_QueryInterface(p, a, b) (p)->QueryInterface(a, b)

1313

#define IDirectDraw7_AddRef(p) (p)->AddRef()

1314

#define IDirectDraw7_Release(p) (p)->Release()

1315

#define IDirectDraw7_Compact(p) (p)->Compact()

1316

#define IDirectDraw7_CreateClipper(p, a, b, c) (p)->CreateClipper(a, b, c)

1317

#define IDirectDraw7_CreatePalette(p, a, b, c, d) (p)->CreatePalette(a, b, c, d)

1318

#define IDirectDraw7_CreateSurface(p, a, b, c) (p)->CreateSurface(a, b, c)

1319

#define IDirectDraw7_DuplicateSurface(p, a, b) (p)->DuplicateSurface(a, b)

1320

#define IDirectDraw7_EnumDisplayModes(p, a, b, c, d) (p)->EnumDisplayModes(a, b, c, d)

1321

#define IDirectDraw7_EnumSurfaces(p, a, b, c, d) (p)->EnumSurfaces(a, b, c, d)

1322

#define IDirectDraw7_FlipToGDISurface(p) (p)->FlipToGDISurface()

1323

#define IDirectDraw7_GetCaps(p, a, b) (p)->GetCaps(a, b)

1324

#define IDirectDraw7_GetDisplayMode(p, a) (p)->GetDisplayMode(a)

1325

#define IDirectDraw7_GetFourCCCodes(p, a, b) (p)->GetFourCCCodes(a, b)

1326

#define IDirectDraw7_GetGDISurface(p, a) (p)->GetGDISurface(a)

1327

#define IDirectDraw7_GetMonitorFrequency(p, a) (p)->GetMonitorFrequency(a)

1328

#define IDirectDraw7_GetScanLine(p, a) (p)->GetScanLine(a)

1329

#define IDirectDraw7_GetVerticalBlankStatus(p, a) (p)->GetVerticalBlankStatus(a)

1330

#define IDirectDraw7_Initialize(p, a) (p)->Initialize(a)

1331

#define IDirectDraw7_RestoreDisplayMode(p) (p)->RestoreDisplayMode()

1332

#define IDirectDraw7_SetCooperativeLevel(p, a, b) (p)->SetCooperativeLevel(a, b)

1333

#define IDirectDraw7_SetDisplayMode(p, a, b, c, d, e) (p)->SetDisplayMode(a, b, c, d, e)

1334

#define IDirectDraw7_WaitForVerticalBlank(p, a, b) (p)->WaitForVerticalBlank(a, b)

1335

#define IDirectDraw7_GetAvailableVidMem(p, a, b, c) (p)->GetAvailableVidMem(a, b, c)

1336

#define IDirectDraw7_GetSurfaceFromDC(p, a, b) (p)->GetSurfaceFromDC(a, b)

1337

#define IDirectDraw7_RestoreAllSurfaces(p) (p)->RestoreAllSurfaces()

1338

#define IDirectDraw7_TestCooperativeLevel(p) (p)->TestCooperativeLevel()

1339

#define IDirectDraw7_GetDeviceIdentifier(p,a,b) (p)->GetDeviceIdentifier(a,b)

1340

#define IDirectDraw7_StartModeTest(p,a,b,c) (p)->lpVtbl->StartModeTest(a,b,c)

1341

#define IDirectDraw7_EvaluateMode(p,a,b) (p)->lpVtbl->EvaluateMode(a,b)

1342

#endif

1343

1344

#endif

1345

1346

1347

/*

1348

* IDirectDrawPalette

1349

*/

1350

#if defined( _WIN32 ) && !defined( _NO_COM )

1351

#undef INTERFACE

1352

#define INTERFACE IDirectDrawPalette

1353

DECLARE_INTERFACE_( IDirectDrawPalette, IUnknown )

1354

{

1355

/*** IUnknown methods ***/

1356

STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE;

1357

STDMETHOD_(ULONG,AddRef) (THIS) PURE;

1358

STDMETHOD_(ULONG,Release) (THIS) PURE;

1359

/*** IDirectDrawPalette methods ***/

1360

STDMETHOD(GetCaps)(THIS_ LPDWORD) PURE;

1361

STDMETHOD(GetEntries)(THIS_ DWORD,DWORD,DWORD,LPPALETTEENTRY) PURE;

1362

STDMETHOD(Initialize)(THIS_ LPDIRECTDRAW, DWORD, LPPALETTEENTRY) PURE;

1363

STDMETHOD(SetEntries)(THIS_ DWORD,DWORD,DWORD,LPPALETTEENTRY) PURE;

1364

};

1365

1366

#if !defined(__cplusplus) || defined(CINTERFACE)

1367

#define IDirectDrawPalette_QueryInterface(p, a, b) (p)->lpVtbl->QueryInterface(p, a, b)

1368

#define IDirectDrawPalette_AddRef(p) (p)->lpVtbl->AddRef(p)

1369

#define IDirectDrawPalette_Release(p) (p)->lpVtbl->Release(p)

1370

#define IDirectDrawPalette_GetCaps(p, a) (p)->lpVtbl->GetCaps(p, a)

1371

#define IDirectDrawPalette_GetEntries(p, a, b, c, d) (p)->lpVtbl->GetEntries(p, a, b, c, d)

1372

#define IDirectDrawPalette_Initialize(p, a, b, c) (p)->lpVtbl->Initialize(p, a, b, c)

1373

#define IDirectDrawPalette_SetEntries(p, a, b, c, d) (p)->lpVtbl->SetEntries(p, a, b, c, d)

1374

#else

1375

#define IDirectDrawPalette_QueryInterface(p, a, b) (p)->QueryInterface(a, b)

1376

#define IDirectDrawPalette_AddRef(p) (p)->AddRef()

1377

#define IDirectDrawPalette_Release(p) (p)->Release()

1378

#define IDirectDrawPalette_GetCaps(p, a) (p)->GetCaps(a)

1379

#define IDirectDrawPalette_GetEntries(p, a, b, c, d) (p)->GetEntries(a, b, c, d)

1380

#define IDirectDrawPalette_Initialize(p, a, b, c) (p)->Initialize(a, b, c)

1381

#define IDirectDrawPalette_SetEntries(p, a, b, c, d) (p)->SetEntries(a, b, c, d)

1382

#endif

1383

1384

#endif

1385

1386

1387

/*

1388

* IDirectDrawClipper

1389

*/

1390

#if defined( _WIN32 ) && !defined( _NO_COM )

1391

#undef INTERFACE

1392

#define INTERFACE IDirectDrawClipper

1393

DECLARE_INTERFACE_( IDirectDrawClipper, IUnknown )

1394

{

1395

/*** IUnknown methods ***/

1396

STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE;

1397

STDMETHOD_(ULONG,AddRef) (THIS) PURE;

1398

STDMETHOD_(ULONG,Release) (THIS) PURE;

1399

/*** IDirectDrawClipper methods ***/

1400

STDMETHOD(GetClipList)(THIS_ LPRECT, LPRGNDATA, LPDWORD) PURE;

1401

STDMETHOD(GetHWnd)(THIS_ HWND FAR *) PURE;

1402

STDMETHOD(Initialize)(THIS_ LPDIRECTDRAW, DWORD) PURE;

1403

STDMETHOD(IsClipListChanged)(THIS_ BOOL FAR *) PURE;

1404

STDMETHOD(SetClipList)(THIS_ LPRGNDATA,DWORD) PURE;

1405

STDMETHOD(SetHWnd)(THIS_ DWORD, HWND ) PURE;

1406

};

1407

1408

#if !defined(__cplusplus) || defined(CINTERFACE)

1409

#define IDirectDrawClipper_QueryInterface(p, a, b) (p)->lpVtbl->QueryInterface(p, a, b)

1410

#define IDirectDrawClipper_AddRef(p) (p)->lpVtbl->AddRef(p)

1411

#define IDirectDrawClipper_Release(p) (p)->lpVtbl->Release(p)

1412

#define IDirectDrawClipper_GetClipList(p, a, b, c) (p)->lpVtbl->GetClipList(p, a, b, c)

1413

#define IDirectDrawClipper_GetHWnd(p, a) (p)->lpVtbl->GetHWnd(p, a)

1414

#define IDirectDrawClipper_Initialize(p, a, b) (p)->lpVtbl->Initialize(p, a, b)

1415

#define IDirectDrawClipper_IsClipListChanged(p, a) (p)->lpVtbl->IsClipListChanged(p, a)

1416

#define IDirectDrawClipper_SetClipList(p, a, b) (p)->lpVtbl->SetClipList(p, a, b)

1417

#define IDirectDrawClipper_SetHWnd(p, a, b) (p)->lpVtbl->SetHWnd(p, a, b)

1418

#else

1419

#define IDirectDrawClipper_QueryInterface(p, a, b) (p)->QueryInterface(a, b)

1420

#define IDirectDrawClipper_AddRef(p) (p)->AddRef()

1421

#define IDirectDrawClipper_Release(p) (p)->Release()

1422

#define IDirectDrawClipper_GetClipList(p, a, b, c) (p)->GetClipList(a, b, c)

1423

#define IDirectDrawClipper_GetHWnd(p, a) (p)->GetHWnd(a)

1424

#define IDirectDrawClipper_Initialize(p, a, b) (p)->Initialize(a, b)

1425

#define IDirectDrawClipper_IsClipListChanged(p, a) (p)->IsClipListChanged(a)

1426

#define IDirectDrawClipper_SetClipList(p, a, b) (p)->SetClipList(a, b)

1427

#define IDirectDrawClipper_SetHWnd(p, a, b) (p)->SetHWnd(a, b)

1428

#endif

1429

1430

#endif

1431

1432

/*

1433

* IDirectDrawSurface and related interfaces

1434

*/

1435

#if defined( _WIN32 ) && !defined( _NO_COM )

1436

#undef INTERFACE

1437

#define INTERFACE IDirectDrawSurface

1438

DECLARE_INTERFACE_( IDirectDrawSurface, IUnknown )

1439

{

1440

/*** IUnknown methods ***/

1441

STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE;

1442

STDMETHOD_(ULONG,AddRef) (THIS) PURE;

1443

STDMETHOD_(ULONG,Release) (THIS) PURE;

1444

/*** IDirectDrawSurface methods ***/

1445

STDMETHOD(AddAttachedSurface)(THIS_ LPDIRECTDRAWSURFACE) PURE;

1446

STDMETHOD(AddOverlayDirtyRect)(THIS_ LPRECT) PURE;

1447

STDMETHOD(Blt)(THIS_ LPRECT,LPDIRECTDRAWSURFACE, LPRECT,DWORD, LPDDBLTFX) PURE;

1448

STDMETHOD(BltBatch)(THIS_ LPDDBLTBATCH, DWORD, DWORD ) PURE;

1449

STDMETHOD(BltFast)(THIS_ DWORD,DWORD,LPDIRECTDRAWSURFACE, LPRECT,DWORD) PURE;

1450

STDMETHOD(DeleteAttachedSurface)(THIS_ DWORD,LPDIRECTDRAWSURFACE) PURE;

1451

STDMETHOD(EnumAttachedSurfaces)(THIS_ LPVOID,LPDDENUMSURFACESCALLBACK) PURE;

1452

STDMETHOD(EnumOverlayZOrders)(THIS_ DWORD,LPVOID,LPDDENUMSURFACESCALLBACK) PURE;

1453

STDMETHOD(Flip)(THIS_ LPDIRECTDRAWSURFACE, DWORD) PURE;

1454

STDMETHOD(GetAttachedSurface)(THIS_ LPDDSCAPS, LPDIRECTDRAWSURFACE FAR *) PURE;

1455

STDMETHOD(GetBltStatus)(THIS_ DWORD) PURE;

1456

STDMETHOD(GetCaps)(THIS_ LPDDSCAPS) PURE;

1457

STDMETHOD(GetClipper)(THIS_ LPDIRECTDRAWCLIPPER FAR*) PURE;

1458

STDMETHOD(GetColorKey)(THIS_ DWORD, LPDDCOLORKEY) PURE;

1459

STDMETHOD(GetDC)(THIS_ HDC FAR *) PURE;

1460

STDMETHOD(GetFlipStatus)(THIS_ DWORD) PURE;

1461

STDMETHOD(GetOverlayPosition)(THIS_ LPLONG, LPLONG ) PURE;

1462

STDMETHOD(GetPalette)(THIS_ LPDIRECTDRAWPALETTE FAR*) PURE;

1463

STDMETHOD(GetPixelFormat)(THIS_ LPDDPIXELFORMAT) PURE;

1464

STDMETHOD(GetSurfaceDesc)(THIS_ LPDDSURFACEDESC) PURE;

1465

STDMETHOD(Initialize)(THIS_ LPDIRECTDRAW, LPDDSURFACEDESC) PURE;

1466

STDMETHOD(IsLost)(THIS) PURE;

1467

STDMETHOD(Lock)(THIS_ LPRECT,LPDDSURFACEDESC,DWORD,HANDLE) PURE;

1468

STDMETHOD(ReleaseDC)(THIS_ HDC) PURE;

1469

STDMETHOD(Restore)(THIS) PURE;

1470

STDMETHOD(SetClipper)(THIS_ LPDIRECTDRAWCLIPPER) PURE;

1471

STDMETHOD(SetColorKey)(THIS_ DWORD, LPDDCOLORKEY) PURE;

1472

STDMETHOD(SetOverlayPosition)(THIS_ LONG, LONG ) PURE;

1473

STDMETHOD(SetPalette)(THIS_ LPDIRECTDRAWPALETTE) PURE;

1474

STDMETHOD(Unlock)(THIS_ LPVOID) PURE;

1475

STDMETHOD(UpdateOverlay)(THIS_ LPRECT, LPDIRECTDRAWSURFACE,LPRECT,DWORD, LPDDOVERLAYFX) PURE;

1476

STDMETHOD(UpdateOverlayDisplay)(THIS_ DWORD) PURE;

1477

STDMETHOD(UpdateOverlayZOrder)(THIS_ DWORD, LPDIRECTDRAWSURFACE) PURE;

1478

};

1479

1480

#if !defined(__cplusplus) || defined(CINTERFACE)

1481

#define IDirectDrawSurface_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)

1482

#define IDirectDrawSurface_AddRef(p) (p)->lpVtbl->AddRef(p)

1483

#define IDirectDrawSurface_Release(p) (p)->lpVtbl->Release(p)

1484

#define IDirectDrawSurface_AddAttachedSurface(p,a) (p)->lpVtbl->AddAttachedSurface(p,a)

1485

#define IDirectDrawSurface_AddOverlayDirtyRect(p,a) (p)->lpVtbl->AddOverlayDirtyRect(p,a)

1486

#define IDirectDrawSurface_Blt(p,a,b,c,d,e) (p)->lpVtbl->Blt(p,a,b,c,d,e)

1487

#define IDirectDrawSurface_BltBatch(p,a,b,c) (p)->lpVtbl->BltBatch(p,a,b,c)

1488

#define IDirectDrawSurface_BltFast(p,a,b,c,d,e) (p)->lpVtbl->BltFast(p,a,b,c,d,e)

1489

#define IDirectDrawSurface_DeleteAttachedSurface(p,a,b) (p)->lpVtbl->DeleteAttachedSurface(p,a,b)

1490

#define IDirectDrawSurface_EnumAttachedSurfaces(p,a,b) (p)->lpVtbl->EnumAttachedSurfaces(p,a,b)

1491

#define IDirectDrawSurface_EnumOverlayZOrders(p,a,b,c) (p)->lpVtbl->EnumOverlayZOrders(p,a,b,c)

1492

#define IDirectDrawSurface_Flip(p,a,b) (p)->lpVtbl->Flip(p,a,b)

1493

#define IDirectDrawSurface_GetAttachedSurface(p,a,b) (p)->lpVtbl->GetAttachedSurface(p,a,b)

1494

#define IDirectDrawSurface_GetBltStatus(p,a) (p)->lpVtbl->GetBltStatus(p,a)

1495

#define IDirectDrawSurface_GetCaps(p,b) (p)->lpVtbl->GetCaps(p,b)

1496

#define IDirectDrawSurface_GetClipper(p,a) (p)->lpVtbl->GetClipper(p,a)

1497

#define IDirectDrawSurface_GetColorKey(p,a,b) (p)->lpVtbl->GetColorKey(p,a,b)

1498

#define IDirectDrawSurface_GetDC(p,a) (p)->lpVtbl->GetDC(p,a)

1499

#define IDirectDrawSurface_GetFlipStatus(p,a) (p)->lpVtbl->GetFlipStatus(p,a)

1500

#define IDirectDrawSurface_GetOverlayPosition(p,a,b) (p)->lpVtbl->GetOverlayPosition(p,a,b)

1501

#define IDirectDrawSurface_GetPalette(p,a) (p)->lpVtbl->GetPalette(p,a)

1502

#define IDirectDrawSurface_GetPixelFormat(p,a) (p)->lpVtbl->GetPixelFormat(p,a)

1503

#define IDirectDrawSurface_GetSurfaceDesc(p,a) (p)->lpVtbl->GetSurfaceDesc(p,a)

1504

#define IDirectDrawSurface_Initialize(p,a,b) (p)->lpVtbl->Initialize(p,a,b)

1505

#define IDirectDrawSurface_IsLost(p) (p)->lpVtbl->IsLost(p)

1506

#define IDirectDrawSurface_Lock(p,a,b,c,d) (p)->lpVtbl->Lock(p,a,b,c,d)

1507

#define IDirectDrawSurface_ReleaseDC(p,a) (p)->lpVtbl->ReleaseDC(p,a)

1508

#define IDirectDrawSurface_Restore(p) (p)->lpVtbl->Restore(p)

1509

#define IDirectDrawSurface_SetClipper(p,a) (p)->lpVtbl->SetClipper(p,a)

1510

#define IDirectDrawSurface_SetColorKey(p,a,b) (p)->lpVtbl->SetColorKey(p,a,b)

1511

#define IDirectDrawSurface_SetOverlayPosition(p,a,b) (p)->lpVtbl->SetOverlayPosition(p,a,b)

1512

#define IDirectDrawSurface_SetPalette(p,a) (p)->lpVtbl->SetPalette(p,a)

1513

#define IDirectDrawSurface_Unlock(p,b) (p)->lpVtbl->Unlock(p,b)

1514

#define IDirectDrawSurface_UpdateOverlay(p,a,b,c,d,e) (p)->lpVtbl->UpdateOverlay(p,a,b,c,d,e)

1515

#define IDirectDrawSurface_UpdateOverlayDisplay(p,a) (p)->lpVtbl->UpdateOverlayDisplay(p,a)

1516

#define IDirectDrawSurface_UpdateOverlayZOrder(p,a,b) (p)->lpVtbl->UpdateOverlayZOrder(p,a,b)

1517

#else

1518

#define IDirectDrawSurface_QueryInterface(p,a,b) (p)->QueryInterface(a,b)

1519

#define IDirectDrawSurface_AddRef(p) (p)->AddRef()

1520

#define IDirectDrawSurface_Release(p) (p)->Release()

1521

#define IDirectDrawSurface_AddAttachedSurface(p,a) (p)->AddAttachedSurface(a)

1522

#define IDirectDrawSurface_AddOverlayDirtyRect(p,a) (p)->AddOverlayDirtyRect(a)

1523

#define IDirectDrawSurface_Blt(p,a,b,c,d,e) (p)->Blt(a,b,c,d,e)

1524

#define IDirectDrawSurface_BltBatch(p,a,b,c) (p)->BltBatch(a,b,c)

1525

#define IDirectDrawSurface_BltFast(p,a,b,c,d,e) (p)->BltFast(a,b,c,d,e)

1526

#define IDirectDrawSurface_DeleteAttachedSurface(p,a,b) (p)->DeleteAttachedSurface(a,b)

1527

#define IDirectDrawSurface_EnumAttachedSurfaces(p,a,b) (p)->EnumAttachedSurfaces(a,b)

1528

#define IDirectDrawSurface_EnumOverlayZOrders(p,a,b,c) (p)->EnumOverlayZOrders(a,b,c)

1529

#define IDirectDrawSurface_Flip(p,a,b) (p)->Flip(a,b)

1530

#define IDirectDrawSurface_GetAttachedSurface(p,a,b) (p)->GetAttachedSurface(a,b)

1531

#define IDirectDrawSurface_GetBltStatus(p,a) (p)->GetBltStatus(a)

1532

#define IDirectDrawSurface_GetCaps(p,b) (p)->GetCaps(b)

1533

#define IDirectDrawSurface_GetClipper(p,a) (p)->GetClipper(a)

1534

#define IDirectDrawSurface_GetColorKey(p,a,b) (p)->GetColorKey(a,b)

1535

#define IDirectDrawSurface_GetDC(p,a) (p)->GetDC(a)

1536

#define IDirectDrawSurface_GetFlipStatus(p,a) (p)->GetFlipStatus(a)

1537

#define IDirectDrawSurface_GetOverlayPosition(p,a,b) (p)->GetOverlayPosition(a,b)

1538

#define IDirectDrawSurface_GetPalette(p,a) (p)->GetPalette(a)

1539

#define IDirectDrawSurface_GetPixelFormat(p,a) (p)->GetPixelFormat(a)

1540

#define IDirectDrawSurface_GetSurfaceDesc(p,a) (p)->GetSurfaceDesc(a)

1541

#define IDirectDrawSurface_Initialize(p,a,b) (p)->Initialize(a,b)

1542

#define IDirectDrawSurface_IsLost(p) (p)->IsLost()

1543

#define IDirectDrawSurface_Lock(p,a,b,c,d) (p)->Lock(a,b,c,d)

1544

#define IDirectDrawSurface_ReleaseDC(p,a) (p)->ReleaseDC(a)

1545

#define IDirectDrawSurface_Restore(p) (p)->Restore()

1546

#define IDirectDrawSurface_SetClipper(p,a) (p)->SetClipper(a)

1547

#define IDirectDrawSurface_SetColorKey(p,a,b) (p)->SetColorKey(a,b)

1548

#define IDirectDrawSurface_SetOverlayPosition(p,a,b) (p)->SetOverlayPosition(a,b)

1549

#define IDirectDrawSurface_SetPalette(p,a) (p)->SetPalette(a)

1550

#define IDirectDrawSurface_Unlock(p,b) (p)->Unlock(b)

1551

#define IDirectDrawSurface_UpdateOverlay(p,a,b,c,d,e) (p)->UpdateOverlay(a,b,c,d,e)

1552

#define IDirectDrawSurface_UpdateOverlayDisplay(p,a) (p)->UpdateOverlayDisplay(a)

1553

#define IDirectDrawSurface_UpdateOverlayZOrder(p,a,b) (p)->UpdateOverlayZOrder(a,b)

1554

#endif

1555

1556

/*

1557

* IDirectDrawSurface2 and related interfaces

1558

*/

1559

#undef INTERFACE

1560

#define INTERFACE IDirectDrawSurface2

1561

DECLARE_INTERFACE_( IDirectDrawSurface2, IUnknown )

1562

{

1563

/*** IUnknown methods ***/

1564

STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE;

1565

STDMETHOD_(ULONG,AddRef) (THIS) PURE;

1566

STDMETHOD_(ULONG,Release) (THIS) PURE;

1567

/*** IDirectDrawSurface methods ***/

1568

STDMETHOD(AddAttachedSurface)(THIS_ LPDIRECTDRAWSURFACE2) PURE;

1569

STDMETHOD(AddOverlayDirtyRect)(THIS_ LPRECT) PURE;

1570

STDMETHOD(Blt)(THIS_ LPRECT,LPDIRECTDRAWSURFACE2, LPRECT,DWORD, LPDDBLTFX) PURE;

1571

STDMETHOD(BltBatch)(THIS_ LPDDBLTBATCH, DWORD, DWORD ) PURE;

1572

STDMETHOD(BltFast)(THIS_ DWORD,DWORD,LPDIRECTDRAWSURFACE2, LPRECT,DWORD) PURE;

1573

STDMETHOD(DeleteAttachedSurface)(THIS_ DWORD,LPDIRECTDRAWSURFACE2) PURE;

1574

STDMETHOD(EnumAttachedSurfaces)(THIS_ LPVOID,LPDDENUMSURFACESCALLBACK) PURE;

1575

STDMETHOD(EnumOverlayZOrders)(THIS_ DWORD,LPVOID,LPDDENUMSURFACESCALLBACK) PURE;

1576

STDMETHOD(Flip)(THIS_ LPDIRECTDRAWSURFACE2, DWORD) PURE;

1577

STDMETHOD(GetAttachedSurface)(THIS_ LPDDSCAPS, LPDIRECTDRAWSURFACE2 FAR *) PURE;

1578

STDMETHOD(GetBltStatus)(THIS_ DWORD) PURE;

1579

STDMETHOD(GetCaps)(THIS_ LPDDSCAPS) PURE;

1580

STDMETHOD(GetClipper)(THIS_ LPDIRECTDRAWCLIPPER FAR*) PURE;

1581

STDMETHOD(GetColorKey)(THIS_ DWORD, LPDDCOLORKEY) PURE;

1582

STDMETHOD(GetDC)(THIS_ HDC FAR *) PURE;

1583

STDMETHOD(GetFlipStatus)(THIS_ DWORD) PURE;

1584

STDMETHOD(GetOverlayPosition)(THIS_ LPLONG, LPLONG ) PURE;

1585

STDMETHOD(GetPalette)(THIS_ LPDIRECTDRAWPALETTE FAR*) PURE;

1586

STDMETHOD(GetPixelFormat)(THIS_ LPDDPIXELFORMAT) PURE;

1587

STDMETHOD(GetSurfaceDesc)(THIS_ LPDDSURFACEDESC) PURE;

1588

STDMETHOD(Initialize)(THIS_ LPDIRECTDRAW, LPDDSURFACEDESC) PURE;

1589

STDMETHOD(IsLost)(THIS) PURE;

1590

STDMETHOD(Lock)(THIS_ LPRECT,LPDDSURFACEDESC,DWORD,HANDLE) PURE;

1591

STDMETHOD(ReleaseDC)(THIS_ HDC) PURE;

1592

STDMETHOD(Restore)(THIS) PURE;

1593

STDMETHOD(SetClipper)(THIS_ LPDIRECTDRAWCLIPPER) PURE;

1594

STDMETHOD(SetColorKey)(THIS_ DWORD, LPDDCOLORKEY) PURE;

1595

STDMETHOD(SetOverlayPosition)(THIS_ LONG, LONG ) PURE;

1596

STDMETHOD(SetPalette)(THIS_ LPDIRECTDRAWPALETTE) PURE;

1597

STDMETHOD(Unlock)(THIS_ LPVOID) PURE;

1598

STDMETHOD(UpdateOverlay)(THIS_ LPRECT, LPDIRECTDRAWSURFACE2,LPRECT,DWORD, LPDDOVERLAYFX) PURE;

1599

STDMETHOD(UpdateOverlayDisplay)(THIS_ DWORD) PURE;

1600

STDMETHOD(UpdateOverlayZOrder)(THIS_ DWORD, LPDIRECTDRAWSURFACE2) PURE;

1601

/*** Added in the v2 interface ***/

1602

STDMETHOD(GetDDInterface)(THIS_ LPVOID FAR *) PURE;

1603

STDMETHOD(PageLock)(THIS_ DWORD) PURE;

1604

STDMETHOD(PageUnlock)(THIS_ DWORD) PURE;

1605

};

1606

1607

#if !defined(__cplusplus) || defined(CINTERFACE)

1608

#define IDirectDrawSurface2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)

1609

#define IDirectDrawSurface2_AddRef(p) (p)->lpVtbl->AddRef(p)

1610

#define IDirectDrawSurface2_Release(p) (p)->lpVtbl->Release(p)

1611

#define IDirectDrawSurface2_AddAttachedSurface(p,a) (p)->lpVtbl->AddAttachedSurface(p,a)

1612

#define IDirectDrawSurface2_AddOverlayDirtyRect(p,a) (p)->lpVtbl->AddOverlayDirtyRect(p,a)

1613

#define IDirectDrawSurface2_Blt(p,a,b,c,d,e) (p)->lpVtbl->Blt(p,a,b,c,d,e)

1614

#define IDirectDrawSurface2_BltBatch(p,a,b,c) (p)->lpVtbl->BltBatch(p,a,b,c)

1615

#define IDirectDrawSurface2_BltFast(p,a,b,c,d,e) (p)->lpVtbl->BltFast(p,a,b,c,d,e)

1616

#define IDirectDrawSurface2_DeleteAttachedSurface(p,a,b) (p)->lpVtbl->DeleteAttachedSurface(p,a,b)

1617

#define IDirectDrawSurface2_EnumAttachedSurfaces(p,a,b) (p)->lpVtbl->EnumAttachedSurfaces(p,a,b)

1618

#define IDirectDrawSurface2_EnumOverlayZOrders(p,a,b,c) (p)->lpVtbl->EnumOverlayZOrders(p,a,b,c)

1619

#define IDirectDrawSurface2_Flip(p,a,b) (p)->lpVtbl->Flip(p,a,b)

1620

#define IDirectDrawSurface2_GetAttachedSurface(p,a,b) (p)->lpVtbl->GetAttachedSurface(p,a,b)

1621

#define IDirectDrawSurface2_GetBltStatus(p,a) (p)->lpVtbl->GetBltStatus(p,a)

1622

#define IDirectDrawSurface2_GetCaps(p,b) (p)->lpVtbl->GetCaps(p,b)

1623

#define IDirectDrawSurface2_GetClipper(p,a) (p)->lpVtbl->GetClipper(p,a)

1624

#define IDirectDrawSurface2_GetColorKey(p,a,b) (p)->lpVtbl->GetColorKey(p,a,b)

1625

#define IDirectDrawSurface2_GetDC(p,a) (p)->lpVtbl->GetDC(p,a)

1626

#define IDirectDrawSurface2_GetFlipStatus(p,a) (p)->lpVtbl->GetFlipStatus(p,a)

1627

#define IDirectDrawSurface2_GetOverlayPosition(p,a,b) (p)->lpVtbl->GetOverlayPosition(p,a,b)

1628

#define IDirectDrawSurface2_GetPalette(p,a) (p)->lpVtbl->GetPalette(p,a)

1629

#define IDirectDrawSurface2_GetPixelFormat(p,a) (p)->lpVtbl->GetPixelFormat(p,a)

1630

#define IDirectDrawSurface2_GetSurfaceDesc(p,a) (p)->lpVtbl->GetSurfaceDesc(p,a)

1631

#define IDirectDrawSurface2_Initialize(p,a,b) (p)->lpVtbl->Initialize(p,a,b)

1632

#define IDirectDrawSurface2_IsLost(p) (p)->lpVtbl->IsLost(p)

1633

#define IDirectDrawSurface2_Lock(p,a,b,c,d) (p)->lpVtbl->Lock(p,a,b,c,d)

1634

#define IDirectDrawSurface2_ReleaseDC(p,a) (p)->lpVtbl->ReleaseDC(p,a)

1635

#define IDirectDrawSurface2_Restore(p) (p)->lpVtbl->Restore(p)

1636

#define IDirectDrawSurface2_SetClipper(p,a) (p)->lpVtbl->SetClipper(p,a)

1637

#define IDirectDrawSurface2_SetColorKey(p,a,b) (p)->lpVtbl->SetColorKey(p,a,b)

1638

#define IDirectDrawSurface2_SetOverlayPosition(p,a,b) (p)->lpVtbl->SetOverlayPosition(p,a,b)

1639

#define IDirectDrawSurface2_SetPalette(p,a) (p)->lpVtbl->SetPalette(p,a)

1640

#define IDirectDrawSurface2_Unlock(p,b) (p)->lpVtbl->Unlock(p,b)

1641

#define IDirectDrawSurface2_UpdateOverlay(p,a,b,c,d,e) (p)->lpVtbl->UpdateOverlay(p,a,b,c,d,e)

1642

#define IDirectDrawSurface2_UpdateOverlayDisplay(p,a) (p)->lpVtbl->UpdateOverlayDisplay(p,a)

1643

#define IDirectDrawSurface2_UpdateOverlayZOrder(p,a,b) (p)->lpVtbl->UpdateOverlayZOrder(p,a,b)

1644

#define IDirectDrawSurface2_GetDDInterface(p,a) (p)->lpVtbl->GetDDInterface(p,a)

1645

#define IDirectDrawSurface2_PageLock(p,a) (p)->lpVtbl->PageLock(p,a)

1646

#define IDirectDrawSurface2_PageUnlock(p,a) (p)->lpVtbl->PageUnlock(p,a)

1647

#else

1648

#define IDirectDrawSurface2_QueryInterface(p,a,b) (p)->QueryInterface(a,b)

1649

#define IDirectDrawSurface2_AddRef(p) (p)->AddRef()

1650

#define IDirectDrawSurface2_Release(p) (p)->Release()

1651

#define IDirectDrawSurface2_AddAttachedSurface(p,a) (p)->AddAttachedSurface(a)

1652

#define IDirectDrawSurface2_AddOverlayDirtyRect(p,a) (p)->AddOverlayDirtyRect(a)

1653

#define IDirectDrawSurface2_Blt(p,a,b,c,d,e) (p)->Blt(a,b,c,d,e)

1654

#define IDirectDrawSurface2_BltBatch(p,a,b,c) (p)->BltBatch(a,b,c)

1655

#define IDirectDrawSurface2_BltFast(p,a,b,c,d,e) (p)->BltFast(a,b,c,d,e)

1656

#define IDirectDrawSurface2_DeleteAttachedSurface(p,a,b) (p)->DeleteAttachedSurface(a,b)

1657

#define IDirectDrawSurface2_EnumAttachedSurfaces(p,a,b) (p)->EnumAttachedSurfaces(a,b)

1658

#define IDirectDrawSurface2_EnumOverlayZOrders(p,a,b,c) (p)->EnumOverlayZOrders(a,b,c)

1659

#define IDirectDrawSurface2_Flip(p,a,b) (p)->Flip(a,b)

1660

#define IDirectDrawSurface2_GetAttachedSurface(p,a,b) (p)->GetAttachedSurface(a,b)

1661

#define IDirectDrawSurface2_GetBltStatus(p,a) (p)->GetBltStatus(a)

1662

#define IDirectDrawSurface2_GetCaps(p,b) (p)->GetCaps(b)

1663

#define IDirectDrawSurface2_GetClipper(p,a) (p)->GetClipper(a)

1664

#define IDirectDrawSurface2_GetColorKey(p,a,b) (p)->GetColorKey(a,b)

1665

#define IDirectDrawSurface2_GetDC(p,a) (p)->GetDC(a)

1666

#define IDirectDrawSurface2_GetFlipStatus(p,a) (p)->GetFlipStatus(a)

1667

#define IDirectDrawSurface2_GetOverlayPosition(p,a,b) (p)->GetOverlayPosition(a,b)

1668

#define IDirectDrawSurface2_GetPalette(p,a) (p)->GetPalette(a)

1669

#define IDirectDrawSurface2_GetPixelFormat(p,a) (p)->GetPixelFormat(a)

1670

#define IDirectDrawSurface2_GetSurfaceDesc(p,a) (p)->GetSurfaceDesc(a)

1671

#define IDirectDrawSurface2_Initialize(p,a,b) (p)->Initialize(a,b)

1672

#define IDirectDrawSurface2_IsLost(p) (p)->IsLost()

1673

#define IDirectDrawSurface2_Lock(p,a,b,c,d) (p)->Lock(a,b,c,d)

1674

#define IDirectDrawSurface2_ReleaseDC(p,a) (p)->ReleaseDC(a)

1675

#define IDirectDrawSurface2_Restore(p) (p)->Restore()

1676

#define IDirectDrawSurface2_SetClipper(p,a) (p)->SetClipper(a)

1677

#define IDirectDrawSurface2_SetColorKey(p,a,b) (p)->SetColorKey(a,b)

1678

#define IDirectDrawSurface2_SetOverlayPosition(p,a,b) (p)->SetOverlayPosition(a,b)

1679

#define IDirectDrawSurface2_SetPalette(p,a) (p)->SetPalette(a)

1680

#define IDirectDrawSurface2_Unlock(p,b) (p)->Unlock(b)

1681

#define IDirectDrawSurface2_UpdateOverlay(p,a,b,c,d,e) (p)->UpdateOverlay(a,b,c,d,e)

1682

#define IDirectDrawSurface2_UpdateOverlayDisplay(p,a) (p)->UpdateOverlayDisplay(a)

1683

#define IDirectDrawSurface2_UpdateOverlayZOrder(p,a,b) (p)->UpdateOverlayZOrder(a,b)

1684

#define IDirectDrawSurface2_GetDDInterface(p,a) (p)->GetDDInterface(a)

1685

#define IDirectDrawSurface2_PageLock(p,a) (p)->PageLock(a)

1686

#define IDirectDrawSurface2_PageUnlock(p,a) (p)->PageUnlock(a)

1687

#endif

1688

1689

/*

1690

* IDirectDrawSurface3 and related interfaces

1691

*/

1692

#undef INTERFACE

1693

#define INTERFACE IDirectDrawSurface3

1694

DECLARE_INTERFACE_( IDirectDrawSurface3, IUnknown )

1695

{

1696

/*** IUnknown methods ***/

1697

STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE;

1698

STDMETHOD_(ULONG,AddRef) (THIS) PURE;

1699

STDMETHOD_(ULONG,Release) (THIS) PURE;

1700

/*** IDirectDrawSurface methods ***/

1701

STDMETHOD(AddAttachedSurface)(THIS_ LPDIRECTDRAWSURFACE3) PURE;

1702

STDMETHOD(AddOverlayDirtyRect)(THIS_ LPRECT) PURE;

1703

STDMETHOD(Blt)(THIS_ LPRECT,LPDIRECTDRAWSURFACE3, LPRECT,DWORD, LPDDBLTFX) PURE;

1704

STDMETHOD(BltBatch)(THIS_ LPDDBLTBATCH, DWORD, DWORD ) PURE;

1705

STDMETHOD(BltFast)(THIS_ DWORD,DWORD,LPDIRECTDRAWSURFACE3, LPRECT,DWORD) PURE;

1706

STDMETHOD(DeleteAttachedSurface)(THIS_ DWORD,LPDIRECTDRAWSURFACE3) PURE;

1707

STDMETHOD(EnumAttachedSurfaces)(THIS_ LPVOID,LPDDENUMSURFACESCALLBACK) PURE;

1708

STDMETHOD(EnumOverlayZOrders)(THIS_ DWORD,LPVOID,LPDDENUMSURFACESCALLBACK) PURE;

1709

STDMETHOD(Flip)(THIS_ LPDIRECTDRAWSURFACE3, DWORD) PURE;

1710

STDMETHOD(GetAttachedSurface)(THIS_ LPDDSCAPS, LPDIRECTDRAWSURFACE3 FAR *) PURE;

1711

STDMETHOD(GetBltStatus)(THIS_ DWORD) PURE;

1712

STDMETHOD(GetCaps)(THIS_ LPDDSCAPS) PURE;

1713

STDMETHOD(GetClipper)(THIS_ LPDIRECTDRAWCLIPPER FAR*) PURE;

1714

STDMETHOD(GetColorKey)(THIS_ DWORD, LPDDCOLORKEY) PURE;

1715

STDMETHOD(GetDC)(THIS_ HDC FAR *) PURE;

1716

STDMETHOD(GetFlipStatus)(THIS_ DWORD) PURE;

1717

STDMETHOD(GetOverlayPosition)(THIS_ LPLONG, LPLONG ) PURE;

1718

STDMETHOD(GetPalette)(THIS_ LPDIRECTDRAWPALETTE FAR*) PURE;

1719

STDMETHOD(GetPixelFormat)(THIS_ LPDDPIXELFORMAT) PURE;

1720

STDMETHOD(GetSurfaceDesc)(THIS_ LPDDSURFACEDESC) PURE;

1721

STDMETHOD(Initialize)(THIS_ LPDIRECTDRAW, LPDDSURFACEDESC) PURE;

1722

STDMETHOD(IsLost)(THIS) PURE;

1723

STDMETHOD(Lock)(THIS_ LPRECT,LPDDSURFACEDESC,DWORD,HANDLE) PURE;

1724

STDMETHOD(ReleaseDC)(THIS_ HDC) PURE;

1725

STDMETHOD(Restore)(THIS) PURE;

1726

STDMETHOD(SetClipper)(THIS_ LPDIRECTDRAWCLIPPER) PURE;

1727

STDMETHOD(SetColorKey)(THIS_ DWORD, LPDDCOLORKEY) PURE;

1728

STDMETHOD(SetOverlayPosition)(THIS_ LONG, LONG ) PURE;

1729

STDMETHOD(SetPalette)(THIS_ LPDIRECTDRAWPALETTE) PURE;

1730

STDMETHOD(Unlock)(THIS_ LPVOID) PURE;

1731

STDMETHOD(UpdateOverlay)(THIS_ LPRECT, LPDIRECTDRAWSURFACE3,LPRECT,DWORD, LPDDOVERLAYFX) PURE;

1732

STDMETHOD(UpdateOverlayDisplay)(THIS_ DWORD) PURE;

1733

STDMETHOD(UpdateOverlayZOrder)(THIS_ DWORD, LPDIRECTDRAWSURFACE3) PURE;

1734

/*** Added in the v2 interface ***/

1735

STDMETHOD(GetDDInterface)(THIS_ LPVOID FAR *) PURE;

1736

STDMETHOD(PageLock)(THIS_ DWORD) PURE;

1737

STDMETHOD(PageUnlock)(THIS_ DWORD) PURE;

1738

/*** Added in the V3 interface ***/

1739

STDMETHOD(SetSurfaceDesc)(THIS_ LPDDSURFACEDESC, DWORD) PURE;

1740

};

1741

1742

#if !defined(__cplusplus) || defined(CINTERFACE)

1743

#define IDirectDrawSurface3_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)

1744

#define IDirectDrawSurface3_AddRef(p) (p)->lpVtbl->AddRef(p)

1745

#define IDirectDrawSurface3_Release(p) (p)->lpVtbl->Release(p)

1746

#define IDirectDrawSurface3_AddAttachedSurface(p,a) (p)->lpVtbl->AddAttachedSurface(p,a)

1747

#define IDirectDrawSurface3_AddOverlayDirtyRect(p,a) (p)->lpVtbl->AddOverlayDirtyRect(p,a)

1748

#define IDirectDrawSurface3_Blt(p,a,b,c,d,e) (p)->lpVtbl->Blt(p,a,b,c,d,e)

1749

#define IDirectDrawSurface3_BltBatch(p,a,b,c) (p)->lpVtbl->BltBatch(p,a,b,c)

1750

#define IDirectDrawSurface3_BltFast(p,a,b,c,d,e) (p)->lpVtbl->BltFast(p,a,b,c,d,e)

1751

#define IDirectDrawSurface3_DeleteAttachedSurface(p,a,b) (p)->lpVtbl->DeleteAttachedSurface(p,a,b)

1752

#define IDirectDrawSurface3_EnumAttachedSurfaces(p,a,b) (p)->lpVtbl->EnumAttachedSurfaces(p,a,b)

1753

#define IDirectDrawSurface3_EnumOverlayZOrders(p,a,b,c) (p)->lpVtbl->EnumOverlayZOrders(p,a,b,c)

1754

#define IDirectDrawSurface3_Flip(p,a,b) (p)->lpVtbl->Flip(p,a,b)

1755

#define IDirectDrawSurface3_GetAttachedSurface(p,a,b) (p)->lpVtbl->GetAttachedSurface(p,a,b)

1756

#define IDirectDrawSurface3_GetBltStatus(p,a) (p)->lpVtbl->GetBltStatus(p,a)

1757

#define IDirectDrawSurface3_GetCaps(p,b) (p)->lpVtbl->GetCaps(p,b)

1758

#define IDirectDrawSurface3_GetClipper(p,a) (p)->lpVtbl->GetClipper(p,a)

1759

#define IDirectDrawSurface3_GetColorKey(p,a,b) (p)->lpVtbl->GetColorKey(p,a,b)

1760

#define IDirectDrawSurface3_GetDC(p,a) (p)->lpVtbl->GetDC(p,a)

1761

#define IDirectDrawSurface3_GetFlipStatus(p,a) (p)->lpVtbl->GetFlipStatus(p,a)

1762

#define IDirectDrawSurface3_GetOverlayPosition(p,a,b) (p)->lpVtbl->GetOverlayPosition(p,a,b)

1763

#define IDirectDrawSurface3_GetPalette(p,a) (p)->lpVtbl->GetPalette(p,a)

1764

#define IDirectDrawSurface3_GetPixelFormat(p,a) (p)->lpVtbl->GetPixelFormat(p,a)

1765

#define IDirectDrawSurface3_GetSurfaceDesc(p,a) (p)->lpVtbl->GetSurfaceDesc(p,a)

1766

#define IDirectDrawSurface3_Initialize(p,a,b) (p)->lpVtbl->Initialize(p,a,b)

1767

#define IDirectDrawSurface3_IsLost(p) (p)->lpVtbl->IsLost(p)

1768

#define IDirectDrawSurface3_Lock(p,a,b,c,d) (p)->lpVtbl->Lock(p,a,b,c,d)

1769

#define IDirectDrawSurface3_ReleaseDC(p,a) (p)->lpVtbl->ReleaseDC(p,a)

1770

#define IDirectDrawSurface3_Restore(p) (p)->lpVtbl->Restore(p)

1771

#define IDirectDrawSurface3_SetClipper(p,a) (p)->lpVtbl->SetClipper(p,a)

1772

#define IDirectDrawSurface3_SetColorKey(p,a,b) (p)->lpVtbl->SetColorKey(p,a,b)

1773

#define IDirectDrawSurface3_SetOverlayPosition(p,a,b) (p)->lpVtbl->SetOverlayPosition(p,a,b)

1774

#define IDirectDrawSurface3_SetPalette(p,a) (p)->lpVtbl->SetPalette(p,a)

1775

#define IDirectDrawSurface3_Unlock(p,b) (p)->lpVtbl->Unlock(p,b)

1776

#define IDirectDrawSurface3_UpdateOverlay(p,a,b,c,d,e) (p)->lpVtbl->UpdateOverlay(p,a,b,c,d,e)

1777

#define IDirectDrawSurface3_UpdateOverlayDisplay(p,a) (p)->lpVtbl->UpdateOverlayDisplay(p,a)

1778

#define IDirectDrawSurface3_UpdateOverlayZOrder(p,a,b) (p)->lpVtbl->UpdateOverlayZOrder(p,a,b)

1779

#define IDirectDrawSurface3_GetDDInterface(p,a) (p)->lpVtbl->GetDDInterface(p,a)

1780

#define IDirectDrawSurface3_PageLock(p,a) (p)->lpVtbl->PageLock(p,a)

1781

#define IDirectDrawSurface3_PageUnlock(p,a) (p)->lpVtbl->PageUnlock(p,a)

1782

#define IDirectDrawSurface3_SetSurfaceDesc(p,a,b) (p)->lpVtbl->SetSurfaceDesc(p,a,b)

1783

#else

1784

#define IDirectDrawSurface3_QueryInterface(p,a,b) (p)->QueryInterface(a,b)

1785

#define IDirectDrawSurface3_AddRef(p) (p)->AddRef()

1786

#define IDirectDrawSurface3_Release(p) (p)->Release()

1787

#define IDirectDrawSurface3_AddAttachedSurface(p,a) (p)->AddAttachedSurface(a)

1788

#define IDirectDrawSurface3_AddOverlayDirtyRect(p,a) (p)->AddOverlayDirtyRect(a)

1789

#define IDirectDrawSurface3_Blt(p,a,b,c,d,e) (p)->Blt(a,b,c,d,e)

1790

#define IDirectDrawSurface3_BltBatch(p,a,b,c) (p)->BltBatch(a,b,c)

1791

#define IDirectDrawSurface3_BltFast(p,a,b,c,d,e) (p)->BltFast(a,b,c,d,e)

1792

#define IDirectDrawSurface3_DeleteAttachedSurface(p,a,b) (p)->DeleteAttachedSurface(a,b)

1793

#define IDirectDrawSurface3_EnumAttachedSurfaces(p,a,b) (p)->EnumAttachedSurfaces(a,b)

1794

#define IDirectDrawSurface3_EnumOverlayZOrders(p,a,b,c) (p)->EnumOverlayZOrders(a,b,c)

1795

#define IDirectDrawSurface3_Flip(p,a,b) (p)->Flip(a,b)

1796

#define IDirectDrawSurface3_GetAttachedSurface(p,a,b) (p)->GetAttachedSurface(a,b)

1797

#define IDirectDrawSurface3_GetBltStatus(p,a) (p)->GetBltStatus(a)

1798

#define IDirectDrawSurface3_GetCaps(p,b) (p)->GetCaps(b)

1799

#define IDirectDrawSurface3_GetClipper(p,a) (p)->GetClipper(a)

1800

#define IDirectDrawSurface3_GetColorKey(p,a,b) (p)->GetColorKey(a,b)

1801

#define IDirectDrawSurface3_GetDC(p,a) (p)->GetDC(a)

1802

#define IDirectDrawSurface3_GetFlipStatus(p,a) (p)->GetFlipStatus(a)

1803

#define IDirectDrawSurface3_GetOverlayPosition(p,a,b) (p)->GetOverlayPosition(a,b)

1804

#define IDirectDrawSurface3_GetPalette(p,a) (p)->GetPalette(a)

1805

#define IDirectDrawSurface3_GetPixelFormat(p,a) (p)->GetPixelFormat(a)

1806

#define IDirectDrawSurface3_GetSurfaceDesc(p,a) (p)->GetSurfaceDesc(a)

1807

#define IDirectDrawSurface3_Initialize(p,a,b) (p)->Initialize(a,b)

1808

#define IDirectDrawSurface3_IsLost(p) (p)->IsLost()

1809

#define IDirectDrawSurface3_Lock(p,a,b,c,d) (p)->Lock(a,b,c,d)

1810

#define IDirectDrawSurface3_ReleaseDC(p,a) (p)->ReleaseDC(a)

1811

#define IDirectDrawSurface3_Restore(p) (p)->Restore()

1812

#define IDirectDrawSurface3_SetClipper(p,a) (p)->SetClipper(a)

1813

#define IDirectDrawSurface3_SetColorKey(p,a,b) (p)->SetColorKey(a,b)

1814

#define IDirectDrawSurface3_SetOverlayPosition(p,a,b) (p)->SetOverlayPosition(a,b)

1815

#define IDirectDrawSurface3_SetPalette(p,a) (p)->SetPalette(a)

1816

#define IDirectDrawSurface3_Unlock(p,b) (p)->Unlock(b)

1817

#define IDirectDrawSurface3_UpdateOverlay(p,a,b,c,d,e) (p)->UpdateOverlay(a,b,c,d,e)

1818

#define IDirectDrawSurface3_UpdateOverlayDisplay(p,a) (p)->UpdateOverlayDisplay(a)

1819

#define IDirectDrawSurface3_UpdateOverlayZOrder(p,a,b) (p)->UpdateOverlayZOrder(a,b)

1820

#define IDirectDrawSurface3_GetDDInterface(p,a) (p)->GetDDInterface(a)

1821

#define IDirectDrawSurface3_PageLock(p,a) (p)->PageLock(a)

1822

#define IDirectDrawSurface3_PageUnlock(p,a) (p)->PageUnlock(a)

1823

#define IDirectDrawSurface3_SetSurfaceDesc(p,a,b) (p)->SetSurfaceDesc(a,b)

1824

#endif

1825

1826

/*

1827

* IDirectDrawSurface4 and related interfaces

1828

*/

1829

#undef INTERFACE

1830

#define INTERFACE IDirectDrawSurface4

1831

DECLARE_INTERFACE_( IDirectDrawSurface4, IUnknown )

1832

{

1833

/*** IUnknown methods ***/

1834

STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE;

1835

STDMETHOD_(ULONG,AddRef) (THIS) PURE;

1836

STDMETHOD_(ULONG,Release) (THIS) PURE;

1837

/*** IDirectDrawSurface methods ***/

1838

STDMETHOD(AddAttachedSurface)(THIS_ LPDIRECTDRAWSURFACE4) PURE;

1839

STDMETHOD(AddOverlayDirtyRect)(THIS_ LPRECT) PURE;

1840

STDMETHOD(Blt)(THIS_ LPRECT,LPDIRECTDRAWSURFACE4, LPRECT,DWORD, LPDDBLTFX) PURE;

1841

STDMETHOD(BltBatch)(THIS_ LPDDBLTBATCH, DWORD, DWORD ) PURE;

1842

STDMETHOD(BltFast)(THIS_ DWORD,DWORD,LPDIRECTDRAWSURFACE4, LPRECT,DWORD) PURE;

1843

STDMETHOD(DeleteAttachedSurface)(THIS_ DWORD,LPDIRECTDRAWSURFACE4) PURE;

1844

STDMETHOD(EnumAttachedSurfaces)(THIS_ LPVOID,LPDDENUMSURFACESCALLBACK2) PURE;

1845

STDMETHOD(EnumOverlayZOrders)(THIS_ DWORD,LPVOID,LPDDENUMSURFACESCALLBACK2) PURE;

1846

STDMETHOD(Flip)(THIS_ LPDIRECTDRAWSURFACE4, DWORD) PURE;

1847

STDMETHOD(GetAttachedSurface)(THIS_ LPDDSCAPS2, LPDIRECTDRAWSURFACE4 FAR *) PURE;

1848

STDMETHOD(GetBltStatus)(THIS_ DWORD) PURE;

1849

STDMETHOD(GetCaps)(THIS_ LPDDSCAPS2) PURE;

1850

STDMETHOD(GetClipper)(THIS_ LPDIRECTDRAWCLIPPER FAR*) PURE;

1851

STDMETHOD(GetColorKey)(THIS_ DWORD, LPDDCOLORKEY) PURE;

1852

STDMETHOD(GetDC)(THIS_ HDC FAR *) PURE;

1853

STDMETHOD(GetFlipStatus)(THIS_ DWORD) PURE;

1854

STDMETHOD(GetOverlayPosition)(THIS_ LPLONG, LPLONG ) PURE;

1855

STDMETHOD(GetPalette)(THIS_ LPDIRECTDRAWPALETTE FAR*) PURE;

1856

STDMETHOD(GetPixelFormat)(THIS_ LPDDPIXELFORMAT) PURE;

1857

STDMETHOD(GetSurfaceDesc)(THIS_ LPDDSURFACEDESC2) PURE;

1858

STDMETHOD(Initialize)(THIS_ LPDIRECTDRAW, LPDDSURFACEDESC2) PURE;

1859

STDMETHOD(IsLost)(THIS) PURE;

1860

STDMETHOD(Lock)(THIS_ LPRECT,LPDDSURFACEDESC2,DWORD,HANDLE) PURE;

1861

STDMETHOD(ReleaseDC)(THIS_ HDC) PURE;

1862

STDMETHOD(Restore)(THIS) PURE;

1863

STDMETHOD(SetClipper)(THIS_ LPDIRECTDRAWCLIPPER) PURE;

1864

STDMETHOD(SetColorKey)(THIS_ DWORD, LPDDCOLORKEY) PURE;

1865

STDMETHOD(SetOverlayPosition)(THIS_ LONG, LONG ) PURE;

1866

STDMETHOD(SetPalette)(THIS_ LPDIRECTDRAWPALETTE) PURE;

1867

STDMETHOD(Unlock)(THIS_ LPRECT) PURE;

1868

STDMETHOD(UpdateOverlay)(THIS_ LPRECT, LPDIRECTDRAWSURFACE4,LPRECT,DWORD, LPDDOVERLAYFX) PURE;

1869

STDMETHOD(UpdateOverlayDisplay)(THIS_ DWORD) PURE;

1870

STDMETHOD(UpdateOverlayZOrder)(THIS_ DWORD, LPDIRECTDRAWSURFACE4) PURE;

1871

/*** Added in the v2 interface ***/

1872

STDMETHOD(GetDDInterface)(THIS_ LPVOID FAR *) PURE;

1873

STDMETHOD(PageLock)(THIS_ DWORD) PURE;

1874

STDMETHOD(PageUnlock)(THIS_ DWORD) PURE;

1875

/*** Added in the v3 interface ***/

1876

STDMETHOD(SetSurfaceDesc)(THIS_ LPDDSURFACEDESC2, DWORD) PURE;

1877

/*** Added in the v4 interface ***/

1878

STDMETHOD(SetPrivateData)(THIS_ REFGUID, LPVOID, DWORD, DWORD) PURE;

1879

STDMETHOD(GetPrivateData)(THIS_ REFGUID, LPVOID, LPDWORD) PURE;

1880

STDMETHOD(FreePrivateData)(THIS_ REFGUID) PURE;

1881

STDMETHOD(GetUniquenessValue)(THIS_ LPDWORD) PURE;

1882

STDMETHOD(ChangeUniquenessValue)(THIS) PURE;

1883

};

1884

1885

#if !defined(__cplusplus) || defined(CINTERFACE)

1886

#define IDirectDrawSurface4_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)

1887

#define IDirectDrawSurface4_AddRef(p) (p)->lpVtbl->AddRef(p)

1888

#define IDirectDrawSurface4_Release(p) (p)->lpVtbl->Release(p)

1889

#define IDirectDrawSurface4_AddAttachedSurface(p,a) (p)->lpVtbl->AddAttachedSurface(p,a)

1890

#define IDirectDrawSurface4_AddOverlayDirtyRect(p,a) (p)->lpVtbl->AddOverlayDirtyRect(p,a)

1891

#define IDirectDrawSurface4_Blt(p,a,b,c,d,e) (p)->lpVtbl->Blt(p,a,b,c,d,e)

1892

#define IDirectDrawSurface4_BltBatch(p,a,b,c) (p)->lpVtbl->BltBatch(p,a,b,c)

1893

#define IDirectDrawSurface4_BltFast(p,a,b,c,d,e) (p)->lpVtbl->BltFast(p,a,b,c,d,e)

1894

#define IDirectDrawSurface4_DeleteAttachedSurface(p,a,b) (p)->lpVtbl->DeleteAttachedSurface(p,a,b)

1895

#define IDirectDrawSurface4_EnumAttachedSurfaces(p,a,b) (p)->lpVtbl->EnumAttachedSurfaces(p,a,b)

1896

#define IDirectDrawSurface4_EnumOverlayZOrders(p,a,b,c) (p)->lpVtbl->EnumOverlayZOrders(p,a,b,c)

1897

#define IDirectDrawSurface4_Flip(p,a,b) (p)->lpVtbl->Flip(p,a,b)

1898

#define IDirectDrawSurface4_GetAttachedSurface(p,a,b) (p)->lpVtbl->GetAttachedSurface(p,a,b)

1899

#define IDirectDrawSurface4_GetBltStatus(p,a) (p)->lpVtbl->GetBltStatus(p,a)

1900

#define IDirectDrawSurface4_GetCaps(p,b) (p)->lpVtbl->GetCaps(p,b)

1901

#define IDirectDrawSurface4_GetClipper(p,a) (p)->lpVtbl->GetClipper(p,a)

1902

#define IDirectDrawSurface4_GetColorKey(p,a,b) (p)->lpVtbl->GetColorKey(p,a,b)

1903

#define IDirectDrawSurface4_GetDC(p,a) (p)->lpVtbl->GetDC(p,a)

1904

#define IDirectDrawSurface4_GetFlipStatus(p,a) (p)->lpVtbl->GetFlipStatus(p,a)

1905

#define IDirectDrawSurface4_GetOverlayPosition(p,a,b) (p)->lpVtbl->GetOverlayPosition(p,a,b)

1906

#define IDirectDrawSurface4_GetPalette(p,a) (p)->lpVtbl->GetPalette(p,a)

1907

#define IDirectDrawSurface4_GetPixelFormat(p,a) (p)->lpVtbl->GetPixelFormat(p,a)

1908

#define IDirectDrawSurface4_GetSurfaceDesc(p,a) (p)->lpVtbl->GetSurfaceDesc(p,a)

1909

#define IDirectDrawSurface4_Initialize(p,a,b) (p)->lpVtbl->Initialize(p,a,b)

1910

#define IDirectDrawSurface4_IsLost(p) (p)->lpVtbl->IsLost(p)

1911

#define IDirectDrawSurface4_Lock(p,a,b,c,d) (p)->lpVtbl->Lock(p,a,b,c,d)

1912

#define IDirectDrawSurface4_ReleaseDC(p,a) (p)->lpVtbl->ReleaseDC(p,a)

1913

#define IDirectDrawSurface4_Restore(p) (p)->lpVtbl->Restore(p)

1914

#define IDirectDrawSurface4_SetClipper(p,a) (p)->lpVtbl->SetClipper(p,a)

1915

#define IDirectDrawSurface4_SetColorKey(p,a,b) (p)->lpVtbl->SetColorKey(p,a,b)

1916

#define IDirectDrawSurface4_SetOverlayPosition(p,a,b) (p)->lpVtbl->SetOverlayPosition(p,a,b)

1917

#define IDirectDrawSurface4_SetPalette(p,a) (p)->lpVtbl->SetPalette(p,a)

1918

#define IDirectDrawSurface4_Unlock(p,b) (p)->lpVtbl->Unlock(p,b)

1919

#define IDirectDrawSurface4_UpdateOverlay(p,a,b,c,d,e) (p)->lpVtbl->UpdateOverlay(p,a,b,c,d,e)

1920

#define IDirectDrawSurface4_UpdateOverlayDisplay(p,a) (p)->lpVtbl->UpdateOverlayDisplay(p,a)

1921

#define IDirectDrawSurface4_UpdateOverlayZOrder(p,a,b) (p)->lpVtbl->UpdateOverlayZOrder(p,a,b)

1922

#define IDirectDrawSurface4_GetDDInterface(p,a) (p)->lpVtbl->GetDDInterface(p,a)

1923

#define IDirectDrawSurface4_PageLock(p,a) (p)->lpVtbl->PageLock(p,a)

1924

#define IDirectDrawSurface4_PageUnlock(p,a) (p)->lpVtbl->PageUnlock(p,a)

1925

#define IDirectDrawSurface4_SetSurfaceDesc(p,a,b) (p)->lpVtbl->SetSurfaceDesc(p,a,b)

1926

#define IDirectDrawSurface4_SetPrivateData(p,a,b,c,d) (p)->lpVtbl->SetPrivateData(p,a,b,c,d)

1927

#define IDirectDrawSurface4_GetPrivateData(p,a,b,c) (p)->lpVtbl->GetPrivateData(p,a,b,c)

1928

#define IDirectDrawSurface4_FreePrivateData(p,a) (p)->lpVtbl->FreePrivateData(p,a)

1929

#define IDirectDrawSurface4_GetUniquenessValue(p, a) (p)->lpVtbl->GetUniquenessValue(p, a)

1930

#define IDirectDrawSurface4_ChangeUniquenessValue(p) (p)->lpVtbl->ChangeUniquenessValue(p)

1931

#else

1932

#define IDirectDrawSurface4_QueryInterface(p,a,b) (p)->QueryInterface(a,b)

1933

#define IDirectDrawSurface4_AddRef(p) (p)->AddRef()

1934

#define IDirectDrawSurface4_Release(p) (p)->Release()

1935

#define IDirectDrawSurface4_AddAttachedSurface(p,a) (p)->AddAttachedSurface(a)

1936

#define IDirectDrawSurface4_AddOverlayDirtyRect(p,a) (p)->AddOverlayDirtyRect(a)

1937

#define IDirectDrawSurface4_Blt(p,a,b,c,d,e) (p)->Blt(a,b,c,d,e)

1938

#define IDirectDrawSurface4_BltBatch(p,a,b,c) (p)->BltBatch(a,b,c)

1939

#define IDirectDrawSurface4_BltFast(p,a,b,c,d,e) (p)->BltFast(a,b,c,d,e)

1940

#define IDirectDrawSurface4_DeleteAttachedSurface(p,a,b) (p)->DeleteAttachedSurface(a,b)

1941

#define IDirectDrawSurface4_EnumAttachedSurfaces(p,a,b) (p)->EnumAttachedSurfaces(a,b)

1942

#define IDirectDrawSurface4_EnumOverlayZOrders(p,a,b,c) (p)->EnumOverlayZOrders(a,b,c)

1943

#define IDirectDrawSurface4_Flip(p,a,b) (p)->Flip(a,b)

1944

#define IDirectDrawSurface4_GetAttachedSurface(p,a,b) (p)->GetAttachedSurface(a,b)

1945

#define IDirectDrawSurface4_GetBltStatus(p,a) (p)->GetBltStatus(a)

1946

#define IDirectDrawSurface4_GetCaps(p,b) (p)->GetCaps(b)

1947

#define IDirectDrawSurface4_GetClipper(p,a) (p)->GetClipper(a)

1948

#define IDirectDrawSurface4_GetColorKey(p,a,b) (p)->GetColorKey(a,b)

1949

#define IDirectDrawSurface4_GetDC(p,a) (p)->GetDC(a)

1950

#define IDirectDrawSurface4_GetFlipStatus(p,a) (p)->GetFlipStatus(a)

1951

#define IDirectDrawSurface4_GetOverlayPosition(p,a,b) (p)->GetOverlayPosition(a,b)

1952

#define IDirectDrawSurface4_GetPalette(p,a) (p)->GetPalette(a)

1953

#define IDirectDrawSurface4_GetPixelFormat(p,a) (p)->GetPixelFormat(a)

1954

#define IDirectDrawSurface4_GetSurfaceDesc(p,a) (p)->GetSurfaceDesc(a)

1955

#define IDirectDrawSurface4_Initialize(p,a,b) (p)->Initialize(a,b)

1956

#define IDirectDrawSurface4_IsLost(p) (p)->IsLost()

1957

#define IDirectDrawSurface4_Lock(p,a,b,c,d) (p)->Lock(a,b,c,d)

1958

#define IDirectDrawSurface4_ReleaseDC(p,a) (p)->ReleaseDC(a)

1959

#define IDirectDrawSurface4_Restore(p) (p)->Restore()

1960

#define IDirectDrawSurface4_SetClipper(p,a) (p)->SetClipper(a)

1961

#define IDirectDrawSurface4_SetColorKey(p,a,b) (p)->SetColorKey(a,b)

1962

#define IDirectDrawSurface4_SetOverlayPosition(p,a,b) (p)->SetOverlayPosition(a,b)

1963

#define IDirectDrawSurface4_SetPalette(p,a) (p)->SetPalette(a)

1964

#define IDirectDrawSurface4_Unlock(p,b) (p)->Unlock(b)

1965

#define IDirectDrawSurface4_UpdateOverlay(p,a,b,c,d,e) (p)->UpdateOverlay(a,b,c,d,e)

1966

#define IDirectDrawSurface4_UpdateOverlayDisplay(p,a) (p)->UpdateOverlayDisplay(a)

1967

#define IDirectDrawSurface4_UpdateOverlayZOrder(p,a,b) (p)->UpdateOverlayZOrder(a,b)

1968

#define IDirectDrawSurface4_GetDDInterface(p,a) (p)->GetDDInterface(a)

1969

#define IDirectDrawSurface4_PageLock(p,a) (p)->PageLock(a)

1970

#define IDirectDrawSurface4_PageUnlock(p,a) (p)->PageUnlock(a)

1971

#define IDirectDrawSurface4_SetSurfaceDesc(p,a,b) (p)->SetSurfaceDesc(a,b)

1972

#define IDirectDrawSurface4_SetPrivateData(p,a,b,c,d) (p)->SetPrivateData(a,b,c,d)

1973

#define IDirectDrawSurface4_GetPrivateData(p,a,b,c) (p)->GetPrivateData(a,b,c)

1974

#define IDirectDrawSurface4_FreePrivateData(p,a) (p)->FreePrivateData(a)

1975

#define IDirectDrawSurface4_GetUniquenessValue(p, a) (p)->GetUniquenessValue(a)

1976

#define IDirectDrawSurface4_ChangeUniquenessValue(p) (p)->ChangeUniquenessValue()

1977

#endif

1978

1979

/*

1980

* IDirectDrawSurface7 and related interfaces

1981

*/

1982

#undef INTERFACE

1983

#define INTERFACE IDirectDrawSurface7

1984

DECLARE_INTERFACE_( IDirectDrawSurface7, IUnknown )

1985

{

1986

/*** IUnknown methods ***/

1987

STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE;

1988

STDMETHOD_(ULONG,AddRef) (THIS) PURE;

1989

STDMETHOD_(ULONG,Release) (THIS) PURE;

1990

/*** IDirectDrawSurface methods ***/

1991

STDMETHOD(AddAttachedSurface)(THIS_ LPDIRECTDRAWSURFACE7) PURE;

1992

STDMETHOD(AddOverlayDirtyRect)(THIS_ LPRECT) PURE;

1993

STDMETHOD(Blt)(THIS_ LPRECT,LPDIRECTDRAWSURFACE7, LPRECT,DWORD, LPDDBLTFX) PURE;

1994

STDMETHOD(BltBatch)(THIS_ LPDDBLTBATCH, DWORD, DWORD ) PURE;

1995

STDMETHOD(BltFast)(THIS_ DWORD,DWORD,LPDIRECTDRAWSURFACE7, LPRECT,DWORD) PURE;

1996

STDMETHOD(DeleteAttachedSurface)(THIS_ DWORD,LPDIRECTDRAWSURFACE7) PURE;

1997

STDMETHOD(EnumAttachedSurfaces)(THIS_ LPVOID,LPDDENUMSURFACESCALLBACK7) PURE;

1998

STDMETHOD(EnumOverlayZOrders)(THIS_ DWORD,LPVOID,LPDDENUMSURFACESCALLBACK7) PURE;

1999

STDMETHOD(Flip)(THIS_ LPDIRECTDRAWSURFACE7, DWORD) PURE;

2000

STDMETHOD(GetAttachedSurface)(THIS_ LPDDSCAPS2, LPDIRECTDRAWSURFACE7 FAR *) PURE;

2001

STDMETHOD(GetBltStatus)(THIS_ DWORD) PURE;

2002

STDMETHOD(GetCaps)(THIS_ LPDDSCAPS2) PURE;

2003

STDMETHOD(GetClipper)(THIS_ LPDIRECTDRAWCLIPPER FAR*) PURE;

2004

STDMETHOD(GetColorKey)(THIS_ DWORD, LPDDCOLORKEY) PURE;

2005

STDMETHOD(GetDC)(THIS_ HDC FAR *) PURE;

2006

STDMETHOD(GetFlipStatus)(THIS_ DWORD) PURE;

2007

STDMETHOD(GetOverlayPosition)(THIS_ LPLONG, LPLONG ) PURE;

2008

STDMETHOD(GetPalette)(THIS_ LPDIRECTDRAWPALETTE FAR*) PURE;

2009

STDMETHOD(GetPixelFormat)(THIS_ LPDDPIXELFORMAT) PURE;

2010

STDMETHOD(GetSurfaceDesc)(THIS_ LPDDSURFACEDESC2) PURE;

2011

STDMETHOD(Initialize)(THIS_ LPDIRECTDRAW, LPDDSURFACEDESC2) PURE;

2012

STDMETHOD(IsLost)(THIS) PURE;

2013

STDMETHOD(Lock)(THIS_ LPRECT,LPDDSURFACEDESC2,DWORD,HANDLE) PURE;

2014

STDMETHOD(ReleaseDC)(THIS_ HDC) PURE;

2015

STDMETHOD(Restore)(THIS) PURE;

2016

STDMETHOD(SetClipper)(THIS_ LPDIRECTDRAWCLIPPER) PURE;

2017

STDMETHOD(SetColorKey)(THIS_ DWORD, LPDDCOLORKEY) PURE;

2018

STDMETHOD(SetOverlayPosition)(THIS_ LONG, LONG ) PURE;

2019

STDMETHOD(SetPalette)(THIS_ LPDIRECTDRAWPALETTE) PURE;

2020

STDMETHOD(Unlock)(THIS_ LPRECT) PURE;

2021

STDMETHOD(UpdateOverlay)(THIS_ LPRECT, LPDIRECTDRAWSURFACE7,LPRECT,DWORD, LPDDOVERLAYFX) PURE;

2022

STDMETHOD(UpdateOverlayDisplay)(THIS_ DWORD) PURE;

2023

STDMETHOD(UpdateOverlayZOrder)(THIS_ DWORD, LPDIRECTDRAWSURFACE7) PURE;

2024

/*** Added in the v2 interface ***/

2025

STDMETHOD(GetDDInterface)(THIS_ LPVOID FAR *) PURE;

2026

STDMETHOD(PageLock)(THIS_ DWORD) PURE;

2027

STDMETHOD(PageUnlock)(THIS_ DWORD) PURE;

2028

/*** Added in the v3 interface ***/

2029

STDMETHOD(SetSurfaceDesc)(THIS_ LPDDSURFACEDESC2, DWORD) PURE;

2030

/*** Added in the v4 interface ***/

2031

STDMETHOD(SetPrivateData)(THIS_ REFGUID, LPVOID, DWORD, DWORD) PURE;

2032

STDMETHOD(GetPrivateData)(THIS_ REFGUID, LPVOID, LPDWORD) PURE;

2033

STDMETHOD(FreePrivateData)(THIS_ REFGUID) PURE;

2034

STDMETHOD(GetUniquenessValue)(THIS_ LPDWORD) PURE;

2035

STDMETHOD(ChangeUniquenessValue)(THIS) PURE;

2036

/*** Moved Texture7 methods here ***/

2037

STDMETHOD(SetPriority)(THIS_ DWORD) PURE;

2038

STDMETHOD(GetPriority)(THIS_ LPDWORD) PURE;

2039

STDMETHOD(SetLOD)(THIS_ DWORD) PURE;

2040

STDMETHOD(GetLOD)(THIS_ LPDWORD) PURE;

2041

};

2042

2043

#if !defined(__cplusplus) || defined(CINTERFACE)

2044

#define IDirectDrawSurface7_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)

2045

#define IDirectDrawSurface7_AddRef(p) (p)->lpVtbl->AddRef(p)

2046

#define IDirectDrawSurface7_Release(p) (p)->lpVtbl->Release(p)

2047

#define IDirectDrawSurface7_AddAttachedSurface(p,a) (p)->lpVtbl->AddAttachedSurface(p,a)

2048

#define IDirectDrawSurface7_AddOverlayDirtyRect(p,a) (p)->lpVtbl->AddOverlayDirtyRect(p,a)

2049

#define IDirectDrawSurface7_Blt(p,a,b,c,d,e) (p)->lpVtbl->Blt(p,a,b,c,d,e)

2050

#define IDirectDrawSurface7_BltBatch(p,a,b,c) (p)->lpVtbl->BltBatch(p,a,b,c)

2051

#define IDirectDrawSurface7_BltFast(p,a,b,c,d,e) (p)->lpVtbl->BltFast(p,a,b,c,d,e)

2052

#define IDirectDrawSurface7_DeleteAttachedSurface(p,a,b) (p)->lpVtbl->DeleteAttachedSurface(p,a,b)

2053

#define IDirectDrawSurface7_EnumAttachedSurfaces(p,a,b) (p)->lpVtbl->EnumAttachedSurfaces(p,a,b)

2054

#define IDirectDrawSurface7_EnumOverlayZOrders(p,a,b,c) (p)->lpVtbl->EnumOverlayZOrders(p,a,b,c)

2055

#define IDirectDrawSurface7_Flip(p,a,b) (p)->lpVtbl->Flip(p,a,b)

2056

#define IDirectDrawSurface7_GetAttachedSurface(p,a,b) (p)->lpVtbl->GetAttachedSurface(p,a,b)

2057

#define IDirectDrawSurface7_GetBltStatus(p,a) (p)->lpVtbl->GetBltStatus(p,a)

2058

#define IDirectDrawSurface7_GetCaps(p,b) (p)->lpVtbl->GetCaps(p,b)

2059

#define IDirectDrawSurface7_GetClipper(p,a) (p)->lpVtbl->GetClipper(p,a)

2060

#define IDirectDrawSurface7_GetColorKey(p,a,b) (p)->lpVtbl->GetColorKey(p,a,b)

2061

#define IDirectDrawSurface7_GetDC(p,a) (p)->lpVtbl->GetDC(p,a)

2062

#define IDirectDrawSurface7_GetFlipStatus(p,a) (p)->lpVtbl->GetFlipStatus(p,a)

2063

#define IDirectDrawSurface7_GetOverlayPosition(p,a,b) (p)->lpVtbl->GetOverlayPosition(p,a,b)

2064

#define IDirectDrawSurface7_GetPalette(p,a) (p)->lpVtbl->GetPalette(p,a)

2065

#define IDirectDrawSurface7_GetPixelFormat(p,a) (p)->lpVtbl->GetPixelFormat(p,a)

2066

#define IDirectDrawSurface7_GetSurfaceDesc(p,a) (p)->lpVtbl->GetSurfaceDesc(p,a)

2067

#define IDirectDrawSurface7_Initialize(p,a,b) (p)->lpVtbl->Initialize(p,a,b)

2068

#define IDirectDrawSurface7_IsLost(p) (p)->lpVtbl->IsLost(p)

2069

#define IDirectDrawSurface7_Lock(p,a,b,c,d) (p)->lpVtbl->Lock(p,a,b,c,d)

2070

#define IDirectDrawSurface7_ReleaseDC(p,a) (p)->lpVtbl->ReleaseDC(p,a)

2071

#define IDirectDrawSurface7_Restore(p) (p)->lpVtbl->Restore(p)

2072

#define IDirectDrawSurface7_SetClipper(p,a) (p)->lpVtbl->SetClipper(p,a)

2073

#define IDirectDrawSurface7_SetColorKey(p,a,b) (p)->lpVtbl->SetColorKey(p,a,b)

2074

#define IDirectDrawSurface7_SetOverlayPosition(p,a,b) (p)->lpVtbl->SetOverlayPosition(p,a,b)

2075

#define IDirectDrawSurface7_SetPalette(p,a) (p)->lpVtbl->SetPalette(p,a)

2076

#define IDirectDrawSurface7_Unlock(p,b) (p)->lpVtbl->Unlock(p,b)

2077

#define IDirectDrawSurface7_UpdateOverlay(p,a,b,c,d,e) (p)->lpVtbl->UpdateOverlay(p,a,b,c,d,e)

2078

#define IDirectDrawSurface7_UpdateOverlayDisplay(p,a) (p)->lpVtbl->UpdateOverlayDisplay(p,a)

2079

#define IDirectDrawSurface7_UpdateOverlayZOrder(p,a,b) (p)->lpVtbl->UpdateOverlayZOrder(p,a,b)

2080

#define IDirectDrawSurface7_GetDDInterface(p,a) (p)->lpVtbl->GetDDInterface(p,a)

2081

#define IDirectDrawSurface7_PageLock(p,a) (p)->lpVtbl->PageLock(p,a)

2082

#define IDirectDrawSurface7_PageUnlock(p,a) (p)->lpVtbl->PageUnlock(p,a)

2083

#define IDirectDrawSurface7_SetSurfaceDesc(p,a,b) (p)->lpVtbl->SetSurfaceDesc(p,a,b)

2084

#define IDirectDrawSurface7_SetPrivateData(p,a,b,c,d) (p)->lpVtbl->SetPrivateData(p,a,b,c,d)

2085

#define IDirectDrawSurface7_GetPrivateData(p,a,b,c) (p)->lpVtbl->GetPrivateData(p,a,b,c)

2086

#define IDirectDrawSurface7_FreePrivateData(p,a) (p)->lpVtbl->FreePrivateData(p,a)

2087

#define IDirectDrawSurface7_GetUniquenessValue(p, a) (p)->lpVtbl->GetUniquenessValue(p, a)

2088

#define IDirectDrawSurface7_ChangeUniquenessValue(p) (p)->lpVtbl->ChangeUniquenessValue(p)

2089

#define IDirectDrawSurface7_SetPriority(p,a) (p)->lpVtbl->SetPriority(p,a)

2090

#define IDirectDrawSurface7_GetPriority(p,a) (p)->lpVtbl->GetPriority(p,a)

2091

#define IDirectDrawSurface7_SetLOD(p,a) (p)->lpVtbl->SetLOD(p,a)

2092

#define IDirectDrawSurface7_GetLOD(p,a) (p)->lpVtbl->GetLOD(p,a)

2093

#else

2094

#define IDirectDrawSurface7_QueryInterface(p,a,b) (p)->QueryInterface(a,b)

2095

#define IDirectDrawSurface7_AddRef(p) (p)->AddRef()

2096

#define IDirectDrawSurface7_Release(p) (p)->Release()

2097

#define IDirectDrawSurface7_AddAttachedSurface(p,a) (p)->AddAttachedSurface(a)

2098

#define IDirectDrawSurface7_AddOverlayDirtyRect(p,a) (p)->AddOverlayDirtyRect(a)

2099

#define IDirectDrawSurface7_Blt(p,a,b,c,d,e) (p)->Blt(a,b,c,d,e)

2100

#define IDirectDrawSurface7_BltBatch(p,a,b,c) (p)->BltBatch(a,b,c)

2101

#define IDirectDrawSurface7_BltFast(p,a,b,c,d,e) (p)->BltFast(a,b,c,d,e)

2102

#define IDirectDrawSurface7_DeleteAttachedSurface(p,a,b) (p)->DeleteAttachedSurface(a,b)

2103

#define IDirectDrawSurface7_EnumAttachedSurfaces(p,a,b) (p)->EnumAttachedSurfaces(a,b)

2104

#define IDirectDrawSurface7_EnumOverlayZOrders(p,a,b,c) (p)->EnumOverlayZOrders(a,b,c)

2105

#define IDirectDrawSurface7_Flip(p,a,b) (p)->Flip(a,b)

2106

#define IDirectDrawSurface7_GetAttachedSurface(p,a,b) (p)->GetAttachedSurface(a,b)

2107

#define IDirectDrawSurface7_GetBltStatus(p,a) (p)->GetBltStatus(a)

2108

#define IDirectDrawSurface7_GetCaps(p,b) (p)->GetCaps(b)

2109

#define IDirectDrawSurface7_GetClipper(p,a) (p)->GetClipper(a)

2110

#define IDirectDrawSurface7_GetColorKey(p,a,b) (p)->GetColorKey(a,b)

2111

#define IDirectDrawSurface7_GetDC(p,a) (p)->GetDC(a)

2112

#define IDirectDrawSurface7_GetFlipStatus(p,a) (p)->GetFlipStatus(a)

2113

#define IDirectDrawSurface7_GetOverlayPosition(p,a,b) (p)->GetOverlayPosition(a,b)

2114

#define IDirectDrawSurface7_GetPalette(p,a) (p)->GetPalette(a)

2115

#define IDirectDrawSurface7_GetPixelFormat(p,a) (p)->GetPixelFormat(a)

2116

#define IDirectDrawSurface7_GetSurfaceDesc(p,a) (p)->GetSurfaceDesc(a)

2117

#define IDirectDrawSurface7_Initialize(p,a,b) (p)->Initialize(a,b)

2118

#define IDirectDrawSurface7_IsLost(p) (p)->IsLost()

2119

#define IDirectDrawSurface7_Lock(p,a,b,c,d) (p)->Lock(a,b,c,d)

2120

#define IDirectDrawSurface7_ReleaseDC(p,a) (p)->ReleaseDC(a)

2121

#define IDirectDrawSurface7_Restore(p) (p)->Restore()

2122

#define IDirectDrawSurface7_SetClipper(p,a) (p)->SetClipper(a)

2123

#define IDirectDrawSurface7_SetColorKey(p,a,b) (p)->SetColorKey(a,b)

2124

#define IDirectDrawSurface7_SetOverlayPosition(p,a,b) (p)->SetOverlayPosition(a,b)

2125

#define IDirectDrawSurface7_SetPalette(p,a) (p)->SetPalette(a)

2126

#define IDirectDrawSurface7_Unlock(p,b) (p)->Unlock(b)

2127

#define IDirectDrawSurface7_UpdateOverlay(p,a,b,c,d,e) (p)->UpdateOverlay(a,b,c,d,e)

2128

#define IDirectDrawSurface7_UpdateOverlayDisplay(p,a) (p)->UpdateOverlayDisplay(a)

2129

#define IDirectDrawSurface7_UpdateOverlayZOrder(p,a,b) (p)->UpdateOverlayZOrder(a,b)

2130

#define IDirectDrawSurface7_GetDDInterface(p,a) (p)->GetDDInterface(a)

2131

#define IDirectDrawSurface7_PageLock(p,a) (p)->PageLock(a)

2132

#define IDirectDrawSurface7_PageUnlock(p,a) (p)->PageUnlock(a)

2133

#define IDirectDrawSurface7_SetSurfaceDesc(p,a,b) (p)->SetSurfaceDesc(a,b)

2134

#define IDirectDrawSurface7_SetPrivateData(p,a,b,c,d) (p)->SetPrivateData(a,b,c,d)

2135

#define IDirectDrawSurface7_GetPrivateData(p,a,b,c) (p)->GetPrivateData(a,b,c)

2136

#define IDirectDrawSurface7_FreePrivateData(p,a) (p)->FreePrivateData(a)

2137

#define IDirectDrawSurface7_GetUniquenessValue(p, a) (p)->GetUniquenessValue(a)

2138

#define IDirectDrawSurface7_ChangeUniquenessValue(p) (p)->ChangeUniquenessValue()

2139

#define IDirectDrawSurface7_SetPriority(p,a) (p)->SetPriority(a)

2140

#define IDirectDrawSurface7_GetPriority(p,a) (p)->GetPriority(a)

2141

#define IDirectDrawSurface7_SetLOD(p,a) (p)->SetLOD(a)

2142

#define IDirectDrawSurface7_GetLOD(p,a) (p)->GetLOD(a)

2143

#endif

2144

2145

2146

/*

2147

* IDirectDrawColorControl

2148

*/

2149

#if defined( _WIN32 ) && !defined( _NO_COM )

2150

#undef INTERFACE

2151

#define INTERFACE IDirectDrawColorControl

2152

DECLARE_INTERFACE_( IDirectDrawColorControl, IUnknown )

2153

{

2154

/*** IUnknown methods ***/

2155

STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE;

2156

STDMETHOD_(ULONG,AddRef) (THIS) PURE;

2157

STDMETHOD_(ULONG,Release) (THIS) PURE;

2158

/*** IDirectDrawColorControl methods ***/

2159

STDMETHOD(GetColorControls)(THIS_ LPDDCOLORCONTROL) PURE;

2160

STDMETHOD(SetColorControls)(THIS_ LPDDCOLORCONTROL) PURE;

2161

};

2162

2163

#if !defined(__cplusplus) || defined(CINTERFACE)

2164

#define IDirectDrawColorControl_QueryInterface(p, a, b) (p)->lpVtbl->QueryInterface(p, a, b)

2165

#define IDirectDrawColorControl_AddRef(p) (p)->lpVtbl->AddRef(p)

2166

#define IDirectDrawColorControl_Release(p) (p)->lpVtbl->Release(p)

2167

#define IDirectDrawColorControl_GetColorControls(p, a) (p)->lpVtbl->GetColorControls(p, a)

2168

#define IDirectDrawColorControl_SetColorControls(p, a) (p)->lpVtbl->SetColorControls(p, a)

2169

#else

2170

#define IDirectDrawColorControl_QueryInterface(p, a, b) (p)->QueryInterface(a, b)

2171

#define IDirectDrawColorControl_AddRef(p) (p)->AddRef()

2172

#define IDirectDrawColorControl_Release(p) (p)->Release()

2173

#define IDirectDrawColorControl_GetColorControls(p, a) (p)->GetColorControls(a)

2174

#define IDirectDrawColorControl_SetColorControls(p, a) (p)->SetColorControls(a)

2175

#endif

2176

2177

#endif

2178

2179

2180

/*

2181

* IDirectDrawGammaControl

2182

*/

2183

#if defined( _WIN32 ) && !defined( _NO_COM )

2184

#undef INTERFACE

2185

#define INTERFACE IDirectDrawGammaControl

2186

DECLARE_INTERFACE_( IDirectDrawGammaControl, IUnknown )

2187

{

2188

/*** IUnknown methods ***/

2189

STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE;

2190

STDMETHOD_(ULONG,AddRef) (THIS) PURE;

2191

STDMETHOD_(ULONG,Release) (THIS) PURE;

2192

/*** IDirectDrawGammaControl methods ***/

2193

STDMETHOD(GetGammaRamp)(THIS_ DWORD, LPDDGAMMARAMP) PURE;

2194

STDMETHOD(SetGammaRamp)(THIS_ DWORD, LPDDGAMMARAMP) PURE;

2195

};

2196

2197

#if !defined(__cplusplus) || defined(CINTERFACE)

2198

#define IDirectDrawGammaControl_QueryInterface(p, a, b) (p)->lpVtbl->QueryInterface(p, a, b)

2199

#define IDirectDrawGammaControl_AddRef(p) (p)->lpVtbl->AddRef(p)

2200

#define IDirectDrawGammaControl_Release(p) (p)->lpVtbl->Release(p)

2201

#define IDirectDrawGammaControl_GetGammaRamp(p, a, b) (p)->lpVtbl->GetGammaRamp(p, a, b)

2202

#define IDirectDrawGammaControl_SetGammaRamp(p, a, b) (p)->lpVtbl->SetGammaRamp(p, a, b)

2203

#else

2204

#define IDirectDrawGammaControl_QueryInterface(p, a, b) (p)->QueryInterface(a, b)

2205

#define IDirectDrawGammaControl_AddRef(p) (p)->AddRef()

2206

#define IDirectDrawGammaControl_Release(p) (p)->Release()

2207

#define IDirectDrawGammaControl_GetGammaRamp(p, a, b) (p)->GetGammaRamp(a, b)

2208

#define IDirectDrawGammaControl_SetGammaRamp(p, a, b) (p)->SetGammaRamp(a, b)

2209

#endif

2210

2211

#endif

2212

2213

2214

2215

#endif

2216

2217

2218

/*

2219

* DDSURFACEDESC

2220

*/

2221

typedef struct _DDSURFACEDESC

2222

{

2223

DWORD dwSize; // size of the DDSURFACEDESC structure

2224

DWORD dwFlags; // determines what fields are valid

2225

DWORD dwHeight; // height of surface to be created

2226

DWORD dwWidth; // width of input surface

2227

union

2228

{

2229

LONG lPitch; // distance to start of next line (return value only)

2230

DWORD dwLinearSize; // Formless late-allocated optimized surface size

2231

} DUMMYUNIONNAMEN(1);

2232

DWORD dwBackBufferCount; // number of back buffers requested

2233

union

2234

{

2235

DWORD dwMipMapCount; // number of mip-map levels requested

2236

DWORD dwZBufferBitDepth; // depth of Z buffer requested

2237

DWORD dwRefreshRate; // refresh rate (used when display mode is described)

2238

} DUMMYUNIONNAMEN(2);

2239

DWORD dwAlphaBitDepth; // depth of alpha buffer requested

2240

DWORD dwReserved; // reserved

2241

LPVOID lpSurface; // pointer to the associated surface memory

2242

DDCOLORKEY ddckCKDestOverlay; // color key for destination overlay use

2243

DDCOLORKEY ddckCKDestBlt; // color key for destination blt use

2244

DDCOLORKEY ddckCKSrcOverlay; // color key for source overlay use

2245

DDCOLORKEY ddckCKSrcBlt; // color key for source blt use

2246

DDPIXELFORMAT ddpfPixelFormat; // pixel format description of the surface

2247

DDSCAPS ddsCaps; // direct draw surface capabilities

2248

} DDSURFACEDESC;

2249

2250

/*

2251

* DDSURFACEDESC2

2252

*/

2253

typedef struct _DDSURFACEDESC2

2254

{

2255

DWORD dwSize; // size of the DDSURFACEDESC structure

2256

DWORD dwFlags; // determines what fields are valid

2257

DWORD dwHeight; // height of surface to be created

2258

DWORD dwWidth; // width of input surface

2259

union

2260

{

2261

LONG lPitch; // distance to start of next line (return value only)

2262

DWORD dwLinearSize; // Formless late-allocated optimized surface size

2263

} DUMMYUNIONNAMEN(1);

2264

union

2265

{

2266

DWORD dwBackBufferCount; // number of back buffers requested

2267

DWORD dwDepth; // the depth if this is a volume texture

2268

} DUMMYUNIONNAMEN(5);

2269

union

2270

{

2271

DWORD dwMipMapCount; // number of mip-map levels requestde

2272

// dwZBufferBitDepth removed, use ddpfPixelFormat one instead

2273

DWORD dwRefreshRate; // refresh rate (used when display mode is described)

2274

DWORD dwSrcVBHandle; // The source used in VB::Optimize

2275

} DUMMYUNIONNAMEN(2);

2276

DWORD dwAlphaBitDepth; // depth of alpha buffer requested

2277

DWORD dwReserved; // reserved

2278

LPVOID lpSurface; // pointer to the associated surface memory

2279

union

2280

{

2281

DDCOLORKEY ddckCKDestOverlay; // color key for destination overlay use

2282

DWORD dwEmptyFaceColor; // Physical color for empty cubemap faces

2283

} DUMMYUNIONNAMEN(3);

2284

DDCOLORKEY ddckCKDestBlt; // color key for destination blt use

2285

DDCOLORKEY ddckCKSrcOverlay; // color key for source overlay use

2286

DDCOLORKEY ddckCKSrcBlt; // color key for source blt use

2287

union

2288

{

2289

DDPIXELFORMAT ddpfPixelFormat; // pixel format description of the surface

2290

DWORD dwFVF; // vertex format description of vertex buffers

2291

} DUMMYUNIONNAMEN(4);

2292

DDSCAPS2 ddsCaps; // direct draw surface capabilities

2293

DWORD dwTextureStage; // stage in multitexture cascade

2294

} DDSURFACEDESC2;

2295

2296

/*

2297

* ddsCaps field is valid.

2298

*/

2299

#define DDSD_CAPS 0x00000001l // default

2300

2301

/*

2302

* dwHeight field is valid.

2303

*/

2304

#define DDSD_HEIGHT 0x00000002l

2305

2306

/*

2307

* dwWidth field is valid.

2308

*/

2309

#define DDSD_WIDTH 0x00000004l

2310

2311

/*

2312

* lPitch is valid.

2313

*/

2314

#define DDSD_PITCH 0x00000008l

2315

2316

/*

2317

* dwBackBufferCount is valid.

2318

*/

2319

#define DDSD_BACKBUFFERCOUNT 0x00000020l

2320

2321

/*

2322

* dwZBufferBitDepth is valid. (shouldnt be used in DDSURFACEDESC2)

2323

*/

2324

#define DDSD_ZBUFFERBITDEPTH 0x00000040l

2325

2326

/*

2327

* dwAlphaBitDepth is valid.

2328

*/

2329

#define DDSD_ALPHABITDEPTH 0x00000080l

2330

2331

2332

/*

2333

* lpSurface is valid.

2334

*/

2335

#define DDSD_LPSURFACE 0x00000800l

2336

2337

/*

2338

* ddpfPixelFormat is valid.

2339

*/

2340

#define DDSD_PIXELFORMAT 0x00001000l

2341

2342

/*

2343

* ddckCKDestOverlay is valid.

2344

*/

2345

#define DDSD_CKDESTOVERLAY 0x00002000l

2346

2347

/*

2348

* ddckCKDestBlt is valid.

2349

*/

2350

#define DDSD_CKDESTBLT 0x00004000l

2351

2352

/*

2353

* ddckCKSrcOverlay is valid.

2354

*/

2355

#define DDSD_CKSRCOVERLAY 0x00008000l

2356

2357

/*

2358

* ddckCKSrcBlt is valid.

2359

*/

2360

#define DDSD_CKSRCBLT 0x00010000l

2361

2362

/*

2363

* dwMipMapCount is valid.

2364

*/

2365

#define DDSD_MIPMAPCOUNT 0x00020000l

2366

2367

/*

2368

* dwRefreshRate is valid

2369

*/

2370

#define DDSD_REFRESHRATE 0x00040000l

2371

2372

/*

2373

* dwLinearSize is valid

2374

*/

2375

#define DDSD_LINEARSIZE 0x00080000l

2376

2377

/*

2378

* dwTextureStage is valid

2379

*/

2380

#define DDSD_TEXTURESTAGE 0x00100000l

2381

/*

2382

* dwFVF is valid

2383

*/

2384

#define DDSD_FVF 0x00200000l

2385

/*

2386

* dwSrcVBHandle is valid

2387

*/

2388

#define DDSD_SRCVBHANDLE 0x00400000l

2389

2390

/*

2391

* dwDepth is valid

2392

*/

2393

#define DDSD_DEPTH 0x00800000l

2394

2395

/*

2396

* All input fields are valid.

2397

*/

2398

#define DDSD_ALL 0x00fff9eel

2399

2400

/*

2401

* DDOPTSURFACEDESC

2402

*/

2403

typedef struct _DDOPTSURFACEDESC

2404

{

2405

DWORD dwSize; // size of the DDOPTSURFACEDESC structure

2406

DWORD dwFlags; // determines what fields are valid

2407

DDSCAPS2 ddSCaps; // Common caps like: Memory type

2408

DDOSCAPS ddOSCaps; // Common caps like: Memory type

2409

GUID guid; // Compression technique GUID

2410

DWORD dwCompressionRatio; // Compression ratio

2411

} DDOPTSURFACEDESC;

2412

2413

/*

2414

* guid field is valid.

2415

*/

2416

#define DDOSD_GUID 0x00000001l

2417

2418

/*

2419

* dwCompressionRatio field is valid.

2420

*/

2421

#define DDOSD_COMPRESSION_RATIO 0x00000002l

2422

2423

/*

2424

* ddSCaps field is valid.

2425

*/

2426

#define DDOSD_SCAPS 0x00000004l

2427

2428

/*

2429

* ddOSCaps field is valid.

2430

*/

2431

#define DDOSD_OSCAPS 0x00000008l

2432

2433

/*

2434

* All input fields are valid.

2435

*/

2436

#define DDOSD_ALL 0x0000000fl

2437

2438

/*

2439

* The surface's optimized pixelformat is compressed

2440

*/

2441

#define DDOSDCAPS_OPTCOMPRESSED 0x00000001l

2442

2443

/*

2444

* The surface's optimized pixelformat is reordered

2445

*/

2446

#define DDOSDCAPS_OPTREORDERED 0x00000002l

2447

2448

/*

2449

* The opt surface is a monolithic mipmap

2450

*/

2451

#define DDOSDCAPS_MONOLITHICMIPMAP 0x00000004l

2452

2453

/*

2454

* The valid Surf caps:

2455

* #define DDSCAPS_SYSTEMMEMORY 0x00000800l

2456

* #define DDSCAPS_VIDEOMEMORY 0x00004000l

2457

* #define DDSCAPS_LOCALVIDMEM 0x10000000l

2458

* #define DDSCAPS_NONLOCALVIDMEM 0x20000000l

2459

*/

2460

#define DDOSDCAPS_VALIDSCAPS 0x30004800l

2461

2462

/*

2463

* The valid OptSurf caps

2464

*/

2465

#define DDOSDCAPS_VALIDOSCAPS 0x00000007l

2466

2467

2468

/*

2469

* DDCOLORCONTROL

2470

*/

2471

typedef struct _DDCOLORCONTROL

2472

{

2473

DWORD dwSize;

2474

DWORD dwFlags;

2475

LONG lBrightness;

2476

LONG lContrast;

2477

LONG lHue;

2478

LONG lSaturation;

2479

LONG lSharpness;

2480

LONG lGamma;

2481

LONG lColorEnable;

2482

DWORD dwReserved1;

2483

} DDCOLORCONTROL;

2484

2485

2486

/*

2487

* lBrightness field is valid.

2488

*/

2489

#define DDCOLOR_BRIGHTNESS 0x00000001l

2490

2491

/*

2492

* lContrast field is valid.

2493

*/

2494

#define DDCOLOR_CONTRAST 0x00000002l

2495

2496

/*

2497

* lHue field is valid.

2498

*/

2499

#define DDCOLOR_HUE 0x00000004l

2500

2501

/*

2502

* lSaturation field is valid.

2503

*/

2504

#define DDCOLOR_SATURATION 0x00000008l

2505

2506

/*

2507

* lSharpness field is valid.

2508

*/

2509

#define DDCOLOR_SHARPNESS 0x00000010l

2510

2511

/*

2512

* lGamma field is valid.

2513

*/

2514

#define DDCOLOR_GAMMA 0x00000020l

2515

2516

/*

2517

* lColorEnable field is valid.

2518

*/

2519

#define DDCOLOR_COLORENABLE 0x00000040l

2520

2521

2522

2523

/*============================================================================

2524

*

2525

* Direct Draw Capability Flags

2526

*

2527

* These flags are used to describe the capabilities of a given Surface.

2528

* All flags are bit flags.

2529

*

2530

*==========================================================================*/

2531

2532

/****************************************************************************

2533

*

2534

* DIRECTDRAWSURFACE CAPABILITY FLAGS

2535

*

2536

****************************************************************************/

2537

2538

/*

2539

* This bit is reserved. It should not be specified.

2540

*/

2541

#define DDSCAPS_RESERVED1 0x00000001l

2542

2543

/*

2544

* Indicates that this surface contains alpha-only information.

2545

* (To determine if a surface is RGBA/YUVA, the pixel format must be

2546

* interrogated.)

2547

*/

2548

#define DDSCAPS_ALPHA 0x00000002l

2549

2550

/*

2551

* Indicates that this surface is a backbuffer. It is generally

2552

* set by CreateSurface when the DDSCAPS_FLIP capability bit is set.

2553

* It indicates that this surface is THE back buffer of a surface

2554

* flipping structure. DirectDraw supports N surfaces in a

2555

* surface flipping structure. Only the surface that immediately

2556

* precedeces the DDSCAPS_FRONTBUFFER has this capability bit set.

2557

* The other surfaces are identified as back buffers by the presence

2558

* of the DDSCAPS_FLIP capability, their attachment order, and the

2559

* absence of the DDSCAPS_FRONTBUFFER and DDSCAPS_BACKBUFFER

2560

* capabilities. The bit is sent to CreateSurface when a standalone

2561

* back buffer is being created. This surface could be attached to

2562

* a front buffer and/or back buffers to form a flipping surface

2563

* structure after the CreateSurface call. See AddAttachments for

2564

* a detailed description of the behaviors in this case.

2565

*/

2566

#define DDSCAPS_BACKBUFFER 0x00000004l

2567

2568

/*

2569

* Indicates a complex surface structure is being described. A

2570

* complex surface structure results in the creation of more than

2571

* one surface. The additional surfaces are attached to the root

2572

* surface. The complex structure can only be destroyed by

2573

* destroying the root.

2574

*/

2575

#define DDSCAPS_COMPLEX 0x00000008l

2576

2577

/*

2578

* Indicates that this surface is a part of a surface flipping structure.

2579

* When it is passed to CreateSurface the DDSCAPS_FRONTBUFFER and

2580

* DDSCAP_BACKBUFFER bits are not set. They are set by CreateSurface

2581

* on the resulting creations. The dwBackBufferCount field in the

2582

* DDSURFACEDESC structure must be set to at least 1 in order for

2583

* the CreateSurface call to succeed. The DDSCAPS_COMPLEX capability

2584

* must always be set with creating multiple surfaces through CreateSurface.

2585

*/

2586

#define DDSCAPS_FLIP 0x00000010l

2587

2588

/*

2589

* Indicates that this surface is THE front buffer of a surface flipping

2590

* structure. It is generally set by CreateSurface when the DDSCAPS_FLIP

2591

* capability bit is set.

2592

* If this capability is sent to CreateSurface then a standalonw front buffer

2593

* is created. This surface will not have the DDSCAPS_FLIP capability.

2594

* It can be attached to other back buffers to form a flipping structure.

2595

* See AddAttachments for a detailed description of the behaviors in this

2596

* case.

2597

*/

2598

#define DDSCAPS_FRONTBUFFER 0x00000020l

2599

2600

/*

2601

* Indicates that this surface is any offscreen surface that is not an overlay,

2602

* texture, zbuffer, front buffer, back buffer, or alpha surface. It is used

2603

* to identify plain vanilla surfaces.

2604

*/

2605

#define DDSCAPS_OFFSCREENPLAIN 0x00000040l

2606

2607

/*

2608

* Indicates that this surface is an overlay. It may or may not be directly visible

2609

* depending on whether or not it is currently being overlayed onto the primary

2610

* surface. DDSCAPS_VISIBLE can be used to determine whether or not it is being

2611

* overlayed at the moment.

2612

*/

2613

#define DDSCAPS_OVERLAY 0x00000080l

2614

2615

/*

2616

* Indicates that unique DirectDrawPalette objects can be created and

2617

* attached to this surface.

2618

*/

2619

#define DDSCAPS_PALETTE 0x00000100l

2620

2621

/*

2622

* Indicates that this surface is the primary surface. The primary

2623

* surface represents what the user is seeing at the moment.

2624

*/

2625

#define DDSCAPS_PRIMARYSURFACE 0x00000200l

2626

2627

2628

/*

2629

* This flag used to be DDSCAPS_PRIMARYSURFACELEFT, which is now

2630

* obsolete.

2631

*/

2632

#define DDSCAPS_RESERVED3 0x00000400l

2633

#define DDSCAPS_PRIMARYSURFACELEFT 0x00000000l

2634

2635

/*

2636

* Indicates that this surface memory was allocated in system memory

2637

*/

2638

#define DDSCAPS_SYSTEMMEMORY 0x00000800l

2639

2640

/*

2641

* Indicates that this surface can be used as a 3D texture. It does not

2642

* indicate whether or not the surface is being used for that purpose.

2643

*/

2644

#define DDSCAPS_TEXTURE 0x00001000l

2645

2646

/*

2647

* Indicates that a surface may be a destination for 3D rendering. This

2648

* bit must be set in order to query for a Direct3D Device Interface

2649

* from this surface.

2650

*/

2651

#define DDSCAPS_3DDEVICE 0x00002000l

2652

2653

/*

2654

* Indicates that this surface exists in video memory.

2655

*/

2656

#define DDSCAPS_VIDEOMEMORY 0x00004000l

2657

2658

/*

2659

* Indicates that changes made to this surface are immediately visible.

2660

* It is always set for the primary surface and is set for overlays while

2661

* they are being overlayed and texture maps while they are being textured.

2662

*/

2663

#define DDSCAPS_VISIBLE 0x00008000l

2664

2665

/*

2666

* Indicates that only writes are permitted to the surface. Read accesses

2667

* from the surface may or may not generate a protection fault, but the

2668

* results of a read from this surface will not be meaningful. READ ONLY.

2669

*/

2670

#define DDSCAPS_WRITEONLY 0x00010000l

2671

2672

/*

2673

* Indicates that this surface is a z buffer. A z buffer does not contain

2674

* displayable information. Instead it contains bit depth information that is

2675

* used to determine which pixels are visible and which are obscured.

2676

*/

2677

#define DDSCAPS_ZBUFFER 0x00020000l

2678

2679

/*

2680

* Indicates surface will have a DC associated long term

2681

*/

2682

#define DDSCAPS_OWNDC 0x00040000l

2683

2684

/*

2685

* Indicates surface should be able to receive live video

2686

*/

2687

#define DDSCAPS_LIVEVIDEO 0x00080000l

2688

2689

/*

2690

* Indicates surface should be able to have a stream decompressed

2691

* to it by the hardware.

2692

*/

2693

#define DDSCAPS_HWCODEC 0x00100000l

2694

2695

/*

2696

* Surface is a ModeX surface.

2697

*

2698

*/

2699

#define DDSCAPS_MODEX 0x00200000l

2700

2701

/*

2702

* Indicates surface is one level of a mip-map. This surface will

2703

* be attached to other DDSCAPS_MIPMAP surfaces to form the mip-map.

2704

* This can be done explicitly, by creating a number of surfaces and

2705

* attaching them with AddAttachedSurface or by implicitly by CreateSurface.

2706

* If this bit is set then DDSCAPS_TEXTURE must also be set.

2707

*/

2708

#define DDSCAPS_MIPMAP 0x00400000l

2709

2710

/*

2711

* This bit is reserved. It should not be specified.

2712

*/

2713

#define DDSCAPS_RESERVED2 0x00800000l

2714

2715

2716

/*

2717

* Indicates that memory for the surface is not allocated until the surface

2718

* is loaded (via the Direct3D texture Load() function).

2719

*/

2720

#define DDSCAPS_ALLOCONLOAD 0x04000000l

2721

2722

/*

2723

* Indicates that the surface will recieve data from a video port.

2724

*/

2725

#define DDSCAPS_VIDEOPORT 0x08000000l

2726

2727

/*

2728

* Indicates that a video memory surface is resident in true, local video

2729

* memory rather than non-local video memory. If this flag is specified then

2730

* so must DDSCAPS_VIDEOMEMORY. This flag is mutually exclusive with

2731

* DDSCAPS_NONLOCALVIDMEM.

2732

*/

2733

#define DDSCAPS_LOCALVIDMEM 0x10000000l

2734

2735

/*

2736

* Indicates that a video memory surface is resident in non-local video

2737

* memory rather than true, local video memory. If this flag is specified

2738

* then so must DDSCAPS_VIDEOMEMORY. This flag is mutually exclusive with

2739

* DDSCAPS_LOCALVIDMEM.

2740

*/

2741

#define DDSCAPS_NONLOCALVIDMEM 0x20000000l

2742

2743

/*

2744

* Indicates that this surface is a standard VGA mode surface, and not a

2745

* ModeX surface. (This flag will never be set in combination with the

2746

* DDSCAPS_MODEX flag).

2747

*/

2748

#define DDSCAPS_STANDARDVGAMODE 0x40000000l

2749

2750

/*

2751

* Indicates that this surface will be an optimized surface. This flag is

2752

* currently only valid in conjunction with the DDSCAPS_TEXTURE flag. The surface

2753

* will be created without any underlying video memory until loaded.

2754

*/

2755

#define DDSCAPS_OPTIMIZED 0x80000000l

2756

2757

2758

2759

/*

2760

* This bit is reserved

2761

*/

2762

#define DDSCAPS2_RESERVED4 0x00000002L

2763

#define DDSCAPS2_HARDWAREDEINTERLACE 0x00000000L

2764

2765

/*

2766

* Indicates to the driver that this surface will be locked very frequently

2767

* (for procedural textures, dynamic lightmaps, etc). Surfaces with this cap

2768

* set must also have DDSCAPS_TEXTURE. This cap cannot be used with

2769

* DDSCAPS2_HINTSTATIC and DDSCAPS2_OPAQUE.

2770

*/

2771

#define DDSCAPS2_HINTDYNAMIC 0x00000004L

2772

2773

/*

2774

* Indicates to the driver that this surface can be re-ordered/retiled on

2775

* load. This operation will not change the size of the texture. It is

2776

* relatively fast and symmetrical, since the application may lock these

2777

* bits (although it will take a performance hit when doing so). Surfaces

2778

* with this cap set must also have DDSCAPS_TEXTURE. This cap cannot be

2779

* used with DDSCAPS2_HINTDYNAMIC and DDSCAPS2_OPAQUE.

2780

*/

2781

#define DDSCAPS2_HINTSTATIC 0x00000008L

2782

2783

/*

2784

* Indicates that the client would like this texture surface to be managed by the

2785

* DirectDraw/Direct3D runtime. Surfaces with this cap set must also have

2786

* DDSCAPS_TEXTURE set.

2787

*/

2788

#define DDSCAPS2_TEXTUREMANAGE 0x00000010L

2789

2790

/*

2791

* These bits are reserved for internal use */

2792

#define DDSCAPS2_RESERVED1 0x00000020L

2793

#define DDSCAPS2_RESERVED2 0x00000040L

2794

2795

/*

2796

* Indicates to the driver that this surface will never be locked again.

2797

* The driver is free to optimize this surface via retiling and actual compression.

2798

* All calls to Lock() or Blts from this surface will fail. Surfaces with this

2799

* cap set must also have DDSCAPS_TEXTURE. This cap cannot be used with

2800

* DDSCAPS2_HINTDYNAMIC and DDSCAPS2_HINTSTATIC.

2801

*/

2802

#define DDSCAPS2_OPAQUE 0x00000080L

2803

2804

/*

2805

* Applications should set this bit at CreateSurface time to indicate that they

2806

* intend to use antialiasing. Only valid if DDSCAPS_3DDEVICE is also set.

2807

*/

2808

#define DDSCAPS2_HINTANTIALIASING 0x00000100L

2809

2810

2811

/*

2812

* This flag is used at CreateSurface time to indicate that this set of

2813

* surfaces is a cubic environment map

2814

*/

2815

#define DDSCAPS2_CUBEMAP 0x00000200L

2816

2817

/*

2818

* These flags preform two functions:

2819

* - At CreateSurface time, they define which of the six cube faces are

2820

* required by the application.

2821

* - After creation, each face in the cubemap will have exactly one of these

2822

* bits set.

2823

*/

2824

#define DDSCAPS2_CUBEMAP_POSITIVEX 0x00000400L

2825

#define DDSCAPS2_CUBEMAP_NEGATIVEX 0x00000800L

2826

#define DDSCAPS2_CUBEMAP_POSITIVEY 0x00001000L

2827

#define DDSCAPS2_CUBEMAP_NEGATIVEY 0x00002000L

2828

#define DDSCAPS2_CUBEMAP_POSITIVEZ 0x00004000L

2829

#define DDSCAPS2_CUBEMAP_NEGATIVEZ 0x00008000L

2830

2831

/*

2832

* This macro may be used to specify all faces of a cube map at CreateSurface time

2833

*/

2834

#define DDSCAPS2_CUBEMAP_ALLFACES ( DDSCAPS2_CUBEMAP_POSITIVEX |\

2835

DDSCAPS2_CUBEMAP_NEGATIVEX |\

2836

DDSCAPS2_CUBEMAP_POSITIVEY |\

2837

DDSCAPS2_CUBEMAP_NEGATIVEY |\

2838

DDSCAPS2_CUBEMAP_POSITIVEZ |\

2839

DDSCAPS2_CUBEMAP_NEGATIVEZ )

2840

2841

2842

/*

2843

* This flag is an additional flag which is present on mipmap sublevels from DX7 onwards

2844

* It enables easier use of GetAttachedSurface rather than EnumAttachedSurfaces for surface

2845

* constructs such as Cube Maps, wherein there are more than one mipmap surface attached

2846

* to the root surface.

2847

* This caps bit is ignored by CreateSurface

2848

*/

2849

#define DDSCAPS2_MIPMAPSUBLEVEL 0x00010000L

2850

2851

/* This flag indicates that the texture should be managed by D3D only */

2852

#define DDSCAPS2_D3DTEXTUREMANAGE 0x00020000L

2853

2854

/* This flag indicates that the managed surface can be safely lost */

2855

#define DDSCAPS2_DONOTPERSIST 0x00040000L

2856

2857

/* indicates that this surface is part of a stereo flipping chain */

2858

#define DDSCAPS2_STEREOSURFACELEFT 0x00080000L

2859

2860

2861

/*

2862

* Indicates that the surface is a volume.

2863

* Can be combined with DDSCAPS_MIPMAP to indicate a multi-level volume

2864

*/

2865

#define DDSCAPS2_VOLUME 0x00200000L

2866

2867

/*

2868

* Indicates that the surface may be locked multiple times by the application.

2869

* This cap cannot be used with DDSCAPS2_OPAQUE.

2870

*/

2871

#define DDSCAPS2_NOTUSERLOCKABLE 0x00400000L

2872

2873

/*

2874

* Indicates that the vertex buffer data can be used to render points and

2875

* point sprites.

2876

*/

2877

#define DDSCAPS2_POINTS 0x00800000L

2878

2879

/*

2880

* Indicates that the vertex buffer data can be used to render rt pactches.

2881

*/

2882

#define DDSCAPS2_RTPATCHES 0x01000000L

2883

2884

/*

2885

* Indicates that the vertex buffer data can be used to render n patches.

2886

*/

2887

#define DDSCAPS2_NPATCHES 0x02000000L

2888

2889

/*

2890

* This bit is reserved for internal use

2891

*/

2892

#define DDSCAPS2_RESERVED3 0x04000000L

2893

2894

2895

/*

2896

* Indicates that the contents of the backbuffer do not have to be preserved

2897

* the contents of the backbuffer after they are presented.

2898

*/

2899

#define DDSCAPS2_DISCARDBACKBUFFER 0x10000000L

2900

2901

/*

2902

* This is a mask that indicates the set of bits that may be set

2903

* at createsurface time to indicate number of samples per pixel

2904

* when multisampling

2905

*/

2906

#define DDSCAPS3_MULTISAMPLE_MASK 0x0000001FL

2907

2908

2909

/****************************************************************************

2910

*

2911

* DIRECTDRAW DRIVER CAPABILITY FLAGS

2912

*

2913

****************************************************************************/

2914

2915

/*

2916

* Display hardware has 3D acceleration.

2917

*/

2918

#define DDCAPS_3D 0x00000001l

2919

2920

/*

2921

* Indicates that DirectDraw will support only dest rectangles that are aligned

2922

* on DIRECTDRAWCAPS.dwAlignBoundaryDest boundaries of the surface, respectively.

2923

* READ ONLY.

2924

*/

2925

#define DDCAPS_ALIGNBOUNDARYDEST 0x00000002l

2926

2927

/*

2928

* Indicates that DirectDraw will support only source rectangles whose sizes in

2929

* BYTEs are DIRECTDRAWCAPS.dwAlignSizeDest multiples, respectively. READ ONLY.

2930

*/

2931

#define DDCAPS_ALIGNSIZEDEST 0x00000004l

2932

/*

2933

* Indicates that DirectDraw will support only source rectangles that are aligned

2934

* on DIRECTDRAWCAPS.dwAlignBoundarySrc boundaries of the surface, respectively.

2935

* READ ONLY.

2936

*/

2937

#define DDCAPS_ALIGNBOUNDARYSRC 0x00000008l

2938

2939

/*

2940

* Indicates that DirectDraw will support only source rectangles whose sizes in

2941

* BYTEs are DIRECTDRAWCAPS.dwAlignSizeSrc multiples, respectively. READ ONLY.

2942

*/

2943

#define DDCAPS_ALIGNSIZESRC 0x00000010l

2944

2945

/*

2946

* Indicates that DirectDraw will create video memory surfaces that have a stride

2947

* alignment equal to DIRECTDRAWCAPS.dwAlignStride. READ ONLY.

2948

*/

2949

#define DDCAPS_ALIGNSTRIDE 0x00000020l

2950

2951

/*

2952

* Display hardware is capable of blt operations.

2953

*/

2954

#define DDCAPS_BLT 0x00000040l

2955

2956

/*

2957

* Display hardware is capable of asynchronous blt operations.

2958

*/

2959

#define DDCAPS_BLTQUEUE 0x00000080l

2960

2961

/*

2962

* Display hardware is capable of color space conversions during the blt operation.

2963

*/

2964

#define DDCAPS_BLTFOURCC 0x00000100l

2965

2966

/*

2967

* Display hardware is capable of stretching during blt operations.

2968

*/

2969

#define DDCAPS_BLTSTRETCH 0x00000200l

2970

2971

/*

2972

* Display hardware is shared with GDI.

2973

*/

2974

#define DDCAPS_GDI 0x00000400l

2975

2976

/*

2977

* Display hardware can overlay.

2978

*/

2979

#define DDCAPS_OVERLAY 0x00000800l

2980

2981

/*

2982

* Set if display hardware supports overlays but can not clip them.

2983

*/

2984

#define DDCAPS_OVERLAYCANTCLIP 0x00001000l

2985

2986

/*

2987

* Indicates that overlay hardware is capable of color space conversions during

2988

* the overlay operation.

2989

*/

2990

#define DDCAPS_OVERLAYFOURCC 0x00002000l

2991

2992

/*

2993

* Indicates that stretching can be done by the overlay hardware.

2994

*/

2995

#define DDCAPS_OVERLAYSTRETCH 0x00004000l

2996

2997

/*

2998

* Indicates that unique DirectDrawPalettes can be created for DirectDrawSurfaces

2999

* other than the primary surface.

3000

*/

3001

#define DDCAPS_PALETTE 0x00008000l

3002

3003

/*

3004

* Indicates that palette changes can be syncd with the veritcal refresh.

3005

*/

3006

#define DDCAPS_PALETTEVSYNC 0x00010000l

3007

3008

/*

3009

* Display hardware can return the current scan line.

3010

*/

3011

#define DDCAPS_READSCANLINE 0x00020000l

3012

3013

3014

/*

3015

* This flag used to bo DDCAPS_STEREOVIEW, which is now obsolete

3016

*/

3017

#define DDCAPS_RESERVED1 0x00040000l

3018

3019

/*

3020

* Display hardware is capable of generating a vertical blank interrupt.

3021

*/

3022

#define DDCAPS_VBI 0x00080000l

3023

3024

/*

3025

* Supports the use of z buffers with blt operations.

3026

*/

3027

#define DDCAPS_ZBLTS 0x00100000l

3028

3029

/*

3030

* Supports Z Ordering of overlays.

3031

*/

3032

#define DDCAPS_ZOVERLAYS 0x00200000l

3033

3034

/*

3035

* Supports color key

3036

*/

3037

#define DDCAPS_COLORKEY 0x00400000l

3038

3039

/*

3040

* Supports alpha surfaces

3041

*/

3042

#define DDCAPS_ALPHA 0x00800000l

3043

3044

/*

3045

* colorkey is hardware assisted(DDCAPS_COLORKEY will also be set)

3046

*/

3047

#define DDCAPS_COLORKEYHWASSIST 0x01000000l

3048

3049

/*

3050

* no hardware support at all

3051

*/

3052

#define DDCAPS_NOHARDWARE 0x02000000l

3053

3054

/*

3055

* Display hardware is capable of color fill with bltter

3056

*/

3057

#define DDCAPS_BLTCOLORFILL 0x04000000l

3058

3059

/*

3060

* Display hardware is bank switched, and potentially very slow at

3061

* random access to VRAM.

3062

*/

3063

#define DDCAPS_BANKSWITCHED 0x08000000l

3064

3065

/*

3066

* Display hardware is capable of depth filling Z-buffers with bltter

3067

*/

3068

#define DDCAPS_BLTDEPTHFILL 0x10000000l

3069

3070

/*

3071

* Display hardware is capable of clipping while bltting.

3072

*/

3073

#define DDCAPS_CANCLIP 0x20000000l

3074

3075

/*

3076

* Display hardware is capable of clipping while stretch bltting.

3077

*/

3078

#define DDCAPS_CANCLIPSTRETCHED 0x40000000l

3079

3080

/*

3081

* Display hardware is capable of bltting to or from system memory

3082

*/

3083

#define DDCAPS_CANBLTSYSMEM 0x80000000l

3084

3085

3086

/****************************************************************************

3087

*

3088

* MORE DIRECTDRAW DRIVER CAPABILITY FLAGS (dwCaps2)

3089

*

3090

****************************************************************************/

3091

3092

/*

3093

* Display hardware is certified

3094

*/

3095

#define DDCAPS2_CERTIFIED 0x00000001l

3096

3097

/*

3098

* Driver cannot interleave 2D operations (lock and blt) to surfaces with

3099

* Direct3D rendering operations between calls to BeginScene() and EndScene()

3100

*/

3101

#define DDCAPS2_NO2DDURING3DSCENE 0x00000002l

3102

3103

/*

3104

* Display hardware contains a video port

3105

*/

3106

#define DDCAPS2_VIDEOPORT 0x00000004l

3107

3108

/*

3109

* The overlay can be automatically flipped according to the video port

3110

* VSYNCs, providing automatic doubled buffered display of video port

3111

* data using an overlay

3112

*/

3113

#define DDCAPS2_AUTOFLIPOVERLAY 0x00000008l

3114

3115

/*

3116

* Overlay can display each field of interlaced data individually while

3117

* it is interleaved in memory without causing jittery artifacts.

3118

*/

3119

#define DDCAPS2_CANBOBINTERLEAVED 0x00000010l

3120

3121

/*

3122

* Overlay can display each field of interlaced data individually while

3123

* it is not interleaved in memory without causing jittery artifacts.

3124

*/

3125

#define DDCAPS2_CANBOBNONINTERLEAVED 0x00000020l

3126

3127

/*

3128

* The overlay surface contains color controls (brightness, sharpness, etc.)

3129

*/

3130

#define DDCAPS2_COLORCONTROLOVERLAY 0x00000040l

3131

3132

/*

3133

* The primary surface contains color controls (gamma, etc.)

3134

*/

3135

#define DDCAPS2_COLORCONTROLPRIMARY 0x00000080l

3136

3137

/*

3138

* RGBZ -> RGB supported for 16:16 RGB:Z

3139

*/

3140

#define DDCAPS2_CANDROPZ16BIT 0x00000100l

3141

3142

/*

3143

* Driver supports non-local video memory.

3144

*/

3145

#define DDCAPS2_NONLOCALVIDMEM 0x00000200l

3146

3147

/*

3148

* Dirver supports non-local video memory but has different capabilities for

3149

* non-local video memory surfaces. If this bit is set then so must

3150

* DDCAPS2_NONLOCALVIDMEM.

3151

*/

3152

#define DDCAPS2_NONLOCALVIDMEMCAPS 0x00000400l

3153

3154

/*

3155

* Driver neither requires nor prefers surfaces to be pagelocked when performing

3156

* blts involving system memory surfaces

3157

*/

3158

#define DDCAPS2_NOPAGELOCKREQUIRED 0x00000800l

3159

3160

/*

3161

* Driver can create surfaces which are wider than the primary surface

3162

*/

3163

#define DDCAPS2_WIDESURFACES 0x00001000l

3164

3165

/*

3166

* Driver supports bob without using a video port by handling the

3167

* DDFLIP_ODD and DDFLIP_EVEN flags specified in Flip.

3168

*/

3169

#define DDCAPS2_CANFLIPODDEVEN 0x00002000l

3170

3171

/*

3172

* Driver supports bob using hardware

3173

*/

3174

#define DDCAPS2_CANBOBHARDWARE 0x00004000l

3175

3176

/*

3177

* Driver supports bltting any FOURCC surface to another surface of the same FOURCC

3178

*/

3179

#define DDCAPS2_COPYFOURCC 0x00008000l

3180

3181

3182

/*

3183

* Driver supports loadable gamma ramps for the primary surface

3184

*/

3185

#define DDCAPS2_PRIMARYGAMMA 0x00020000l

3186

3187

/*

3188

* Driver can render in windowed mode.

3189

*/

3190

#define DDCAPS2_CANRENDERWINDOWED 0x00080000l

3191

3192

/*

3193

* A calibrator is available to adjust the gamma ramp according to the

3194

* physical display properties so that the result will be identical on

3195

* all calibrated systems.

3196

*/

3197

#define DDCAPS2_CANCALIBRATEGAMMA 0x00100000l

3198

3199

/*

3200

* Indicates that the driver will respond to DDFLIP_INTERVALn flags

3201

*/

3202

#define DDCAPS2_FLIPINTERVAL 0x00200000l

3203

3204

/*

3205

* Indicates that the driver will respond to DDFLIP_NOVSYNC

3206

*/

3207

#define DDCAPS2_FLIPNOVSYNC 0x00400000l

3208

3209

/*

3210

* Driver supports management of video memory, if this flag is ON,

3211

* driver manages the texture if requested with DDSCAPS2_TEXTUREMANAGE on

3212

* DirectX manages the texture if this flag is OFF and surface has DDSCAPS2_TEXTUREMANAGE on

3213

*/

3214

#define DDCAPS2_CANMANAGETEXTURE 0x00800000l

3215

3216

/*

3217

* The Direct3D texture manager uses this cap to decide whether to put managed

3218

* surfaces in non-local video memory. If the cap is set, the texture manager will

3219

* put managed surfaces in non-local vidmem. Drivers that cannot texture from

3220

* local vidmem SHOULD NOT set this cap.

3221

*/

3222

#define DDCAPS2_TEXMANINNONLOCALVIDMEM 0x01000000l

3223

3224

/*

3225

* Indicates that the driver supports DX7 type of stereo in at least one mode (which may

3226

* not necessarily be the current mode). Applications should use IDirectDraw7 (or higher)

3227

* ::EnumDisplayModes and check the DDSURFACEDESC.ddsCaps.dwCaps2 field for the presence of

3228

* DDSCAPS2_STEREOSURFACELEFT to check if a particular mode supports stereo. The application

3229

* can also use IDirectDraw7(or higher)::GetDisplayMode to check the current mode.

3230

*/

3231

#define DDCAPS2_STEREO 0x02000000L

3232

3233

/*

3234

* This caps bit is intended for internal DirectDraw use.

3235

* -It is only valid if DDCAPS2_NONLOCALVIDMEMCAPS is set.

3236

* -If this bit is set, then DDCAPS_CANBLTSYSMEM MUST be set by the driver (and

3237

* all the assoicated system memory blt caps must be correct).

3238

* -It implies that the system->video blt caps in DDCAPS also apply to system to

3239

* nonlocal blts. I.e. the dwSVBCaps, dwSVBCKeyCaps, dwSVBFXCaps and dwSVBRops

3240

* members of DDCAPS (DDCORECAPS) are filled in correctly.

3241

* -Any blt from system to nonlocal memory that matches these caps bits will

3242

* be passed to the driver.

3243

*

3244

* NOTE: This is intended to enable the driver itself to do efficient reordering

3245

* of textures. This is NOT meant to imply that hardware can write into AGP memory.

3246

* This operation is not currently supported.

3247

*/

3248

#define DDCAPS2_SYSTONONLOCAL_AS_SYSTOLOCAL 0x04000000L

3249

3250

/*

3251

* Indicates that the driver can support PUREHAL.

3252

*/

3253

#define DDCAPS2_PUREHAL 0x08000000L

3254

3255

3256

/****************************************************************************

3257

*

3258

* DIRECTDRAW FX ALPHA CAPABILITY FLAGS

3259

*

3260

****************************************************************************/

3261

3262

/*

3263

* Supports alpha blending around the edge of a source color keyed surface.

3264

* For Blt.

3265

*/

3266

#define DDFXALPHACAPS_BLTALPHAEDGEBLEND 0x00000001l

3267

3268

/*

3269

* Supports alpha information in the pixel format. The bit depth of alpha

3270

* information in the pixel format can be 1,2,4, or 8. The alpha value becomes

3271

* more opaque as the alpha value increases. (0 is transparent.)

3272

* For Blt.

3273

*/

3274

#define DDFXALPHACAPS_BLTALPHAPIXELS 0x00000002l

3275

3276

/*

3277

* Supports alpha information in the pixel format. The bit depth of alpha

3278

* information in the pixel format can be 1,2,4, or 8. The alpha value

3279

* becomes more transparent as the alpha value increases. (0 is opaque.)

3280

* This flag can only be set if DDCAPS_ALPHA is set.

3281

* For Blt.

3282

*/

3283

#define DDFXALPHACAPS_BLTALPHAPIXELSNEG 0x00000004l

3284

3285

/*

3286

* Supports alpha only surfaces. The bit depth of an alpha only surface can be

3287

* 1,2,4, or 8. The alpha value becomes more opaque as the alpha value increases.

3288

* (0 is transparent.)

3289

* For Blt.

3290

*/

3291

#define DDFXALPHACAPS_BLTALPHASURFACES 0x00000008l

3292

3293

/*

3294

* The depth of the alpha channel data can range can be 1,2,4, or 8.

3295

* The NEG suffix indicates that this alpha channel becomes more transparent

3296

* as the alpha value increases. (0 is opaque.) This flag can only be set if

3297

* DDCAPS_ALPHA is set.

3298

* For Blt.

3299

*/

3300

#define DDFXALPHACAPS_BLTALPHASURFACESNEG 0x00000010l

3301

3302

/*

3303

* Supports alpha blending around the edge of a source color keyed surface.

3304

* For Overlays.

3305

*/

3306

#define DDFXALPHACAPS_OVERLAYALPHAEDGEBLEND 0x00000020l

3307

3308

/*

3309

* Supports alpha information in the pixel format. The bit depth of alpha

3310

* information in the pixel format can be 1,2,4, or 8. The alpha value becomes

3311

* more opaque as the alpha value increases. (0 is transparent.)

3312

* For Overlays.

3313

*/

3314

#define DDFXALPHACAPS_OVERLAYALPHAPIXELS 0x00000040l

3315

3316

/*

3317

* Supports alpha information in the pixel format. The bit depth of alpha

3318

* information in the pixel format can be 1,2,4, or 8. The alpha value

3319

* becomes more transparent as the alpha value increases. (0 is opaque.)

3320

* This flag can only be set if DDCAPS_ALPHA is set.

3321

* For Overlays.

3322

*/

3323

#define DDFXALPHACAPS_OVERLAYALPHAPIXELSNEG 0x00000080l

3324

3325

/*

3326

* Supports alpha only surfaces. The bit depth of an alpha only surface can be

3327

* 1,2,4, or 8. The alpha value becomes more opaque as the alpha value increases.

3328

* (0 is transparent.)

3329

* For Overlays.

3330

*/

3331

#define DDFXALPHACAPS_OVERLAYALPHASURFACES 0x00000100l

3332

3333

/*

3334

* The depth of the alpha channel data can range can be 1,2,4, or 8.

3335

* The NEG suffix indicates that this alpha channel becomes more transparent

3336

* as the alpha value increases. (0 is opaque.) This flag can only be set if

3337

* DDCAPS_ALPHA is set.

3338

* For Overlays.

3339

*/

3340

#define DDFXALPHACAPS_OVERLAYALPHASURFACESNEG 0x00000200l

3341

3342

#if DIRECTDRAW_VERSION < 0x0600

3343

#endif //DIRECTDRAW_VERSION

3344

3345

3346

/****************************************************************************

3347

*

3348

* DIRECTDRAW FX CAPABILITY FLAGS

3349

*

3350

****************************************************************************/

3351

3352

/*

3353

* Uses arithmetic operations to stretch and shrink surfaces during blt

3354

* rather than pixel doubling techniques. Along the Y axis.

3355

*/

3356

#define DDFXCAPS_BLTARITHSTRETCHY 0x00000020l

3357

3358

/*

3359

* Uses arithmetic operations to stretch during blt

3360

* rather than pixel doubling techniques. Along the Y axis. Only

3361

* works for x1, x2, etc.

3362

*/

3363

#define DDFXCAPS_BLTARITHSTRETCHYN 0x00000010l

3364

3365

/*

3366

* Supports mirroring left to right in blt.

3367

*/

3368

#define DDFXCAPS_BLTMIRRORLEFTRIGHT 0x00000040l

3369

3370

/*

3371

* Supports mirroring top to bottom in blt.

3372

*/

3373

#define DDFXCAPS_BLTMIRRORUPDOWN 0x00000080l

3374

3375

/*

3376

* Supports arbitrary rotation for blts.

3377

*/

3378

#define DDFXCAPS_BLTROTATION 0x00000100l

3379

3380

/*

3381

* Supports 90 degree rotations for blts.

3382

*/

3383

#define DDFXCAPS_BLTROTATION90 0x00000200l

3384

3385

/*

3386

* DirectDraw supports arbitrary shrinking of a surface along the

3387

* x axis (horizontal direction) for blts.

3388

*/

3389

#define DDFXCAPS_BLTSHRINKX 0x00000400l

3390

3391

/*

3392

* DirectDraw supports integer shrinking (1x,2x,) of a surface

3393

* along the x axis (horizontal direction) for blts.

3394

*/

3395

#define DDFXCAPS_BLTSHRINKXN 0x00000800l

3396

3397

/*

3398

* DirectDraw supports arbitrary shrinking of a surface along the

3399

* y axis (horizontal direction) for blts.

3400

*/

3401

#define DDFXCAPS_BLTSHRINKY 0x00001000l

3402

3403

/*

3404

* DirectDraw supports integer shrinking (1x,2x,) of a surface

3405

* along the y axis (vertical direction) for blts.

3406

*/

3407

#define DDFXCAPS_BLTSHRINKYN 0x00002000l

3408

3409

/*

3410

* DirectDraw supports arbitrary stretching of a surface along the

3411

* x axis (horizontal direction) for blts.

3412

*/

3413

#define DDFXCAPS_BLTSTRETCHX 0x00004000l

3414

3415

/*

3416

* DirectDraw supports integer stretching (1x,2x,) of a surface

3417

* along the x axis (horizontal direction) for blts.

3418

*/

3419

#define DDFXCAPS_BLTSTRETCHXN 0x00008000l

3420

3421

/*

3422

* DirectDraw supports arbitrary stretching of a surface along the

3423

* y axis (horizontal direction) for blts.

3424

*/

3425

#define DDFXCAPS_BLTSTRETCHY 0x00010000l

3426

3427

/*

3428

* DirectDraw supports integer stretching (1x,2x,) of a surface

3429

* along the y axis (vertical direction) for blts.

3430

*/

3431

#define DDFXCAPS_BLTSTRETCHYN 0x00020000l

3432

3433

/*

3434

* Uses arithmetic operations to stretch and shrink surfaces during

3435

* overlay rather than pixel doubling techniques. Along the Y axis

3436

* for overlays.

3437

*/

3438

#define DDFXCAPS_OVERLAYARITHSTRETCHY 0x00040000l

3439

3440

/*

3441

* Uses arithmetic operations to stretch surfaces during

3442

* overlay rather than pixel doubling techniques. Along the Y axis

3443

* for overlays. Only works for x1, x2, etc.

3444

*/

3445

#define DDFXCAPS_OVERLAYARITHSTRETCHYN 0x00000008l

3446

3447

/*

3448

* DirectDraw supports arbitrary shrinking of a surface along the

3449

* x axis (horizontal direction) for overlays.

3450

*/

3451

#define DDFXCAPS_OVERLAYSHRINKX 0x00080000l

3452

3453

/*

3454

* DirectDraw supports integer shrinking (1x,2x,) of a surface

3455

* along the x axis (horizontal direction) for overlays.

3456

*/

3457

#define DDFXCAPS_OVERLAYSHRINKXN 0x00100000l

3458

3459

/*

3460

* DirectDraw supports arbitrary shrinking of a surface along the

3461

* y axis (horizontal direction) for overlays.

3462

*/

3463

#define DDFXCAPS_OVERLAYSHRINKY 0x00200000l

3464

3465

/*

3466

* DirectDraw supports integer shrinking (1x,2x,) of a surface

3467

* along the y axis (vertical direction) for overlays.

3468

*/

3469

#define DDFXCAPS_OVERLAYSHRINKYN 0x00400000l

3470

3471

/*

3472

* DirectDraw supports arbitrary stretching of a surface along the

3473

* x axis (horizontal direction) for overlays.

3474

*/

3475

#define DDFXCAPS_OVERLAYSTRETCHX 0x00800000l

3476

3477

/*

3478

* DirectDraw supports integer stretching (1x,2x,) of a surface

3479

* along the x axis (horizontal direction) for overlays.

3480

*/

3481

#define DDFXCAPS_OVERLAYSTRETCHXN 0x01000000l

3482

3483

/*

3484

* DirectDraw supports arbitrary stretching of a surface along the

3485

* y axis (horizontal direction) for overlays.

3486

*/

3487

#define DDFXCAPS_OVERLAYSTRETCHY 0x02000000l

3488

3489

/*

3490

* DirectDraw supports integer stretching (1x,2x,) of a surface

3491

* along the y axis (vertical direction) for overlays.

3492

*/

3493

#define DDFXCAPS_OVERLAYSTRETCHYN 0x04000000l

3494

3495

/*

3496

* DirectDraw supports mirroring of overlays across the vertical axis

3497

*/

3498

#define DDFXCAPS_OVERLAYMIRRORLEFTRIGHT 0x08000000l

3499

3500

/*

3501

* DirectDraw supports mirroring of overlays across the horizontal axis

3502

*/

3503

#define DDFXCAPS_OVERLAYMIRRORUPDOWN 0x10000000l

3504

3505

/*

3506

* DirectDraw supports deinterlacing of overlay surfaces

3507

*/

3508

#define DDFXCAPS_OVERLAYDEINTERLACE 0x20000000l

3509

3510

/*

3511

* Driver can do alpha blending for blits.

3512

*/

3513

#define DDFXCAPS_BLTALPHA 0x00000001l

3514

3515

3516

/*

3517

* Driver can do surface-reconstruction filtering for warped blits.

3518

*/

3519

#define DDFXCAPS_BLTFILTER DDFXCAPS_BLTARITHSTRETCHY

3520

3521

/*

3522

* Driver can do alpha blending for overlays.

3523

*/

3524

#define DDFXCAPS_OVERLAYALPHA 0x00000004l

3525

3526

3527

/*

3528

* Driver can do surface-reconstruction filtering for warped overlays.

3529

*/

3530

#define DDFXCAPS_OVERLAYFILTER DDFXCAPS_OVERLAYARITHSTRETCHY

3531

3532

/****************************************************************************

3533

*

3534

* DIRECTDRAW STEREO VIEW CAPABILITIES

3535

*

3536

****************************************************************************/

3537

3538

/*

3539

* This flag used to be DDSVCAPS_ENIGMA, which is now obsolete

3540

*/

3541

3542

#define DDSVCAPS_RESERVED1 0x00000001l

3543

3544

/*

3545

* This flag used to be DDSVCAPS_FLICKER, which is now obsolete

3546

*/

3547

#define DDSVCAPS_RESERVED2 0x00000002l

3548

3549

/*

3550

* This flag used to be DDSVCAPS_REDBLUE, which is now obsolete

3551

*/

3552

#define DDSVCAPS_RESERVED3 0x00000004l

3553

3554

/*

3555

* This flag used to be DDSVCAPS_SPLIT, which is now obsolete

3556

*/

3557

#define DDSVCAPS_RESERVED4 0x00000008l

3558

3559

/*

3560

* The stereo view is accomplished with switching technology

3561

*/

3562

3563

#define DDSVCAPS_STEREOSEQUENTIAL 0x00000010L

3564

3565

3566

3567

3568

/****************************************************************************

3569

*

3570

* DIRECTDRAWPALETTE CAPABILITIES

3571

*

3572

****************************************************************************/

3573

3574

/*

3575

* Index is 4 bits. There are sixteen color entries in the palette table.

3576

*/

3577

#define DDPCAPS_4BIT 0x00000001l

3578

3579

/*

3580

* Index is onto a 8 bit color index. This field is only valid with the

3581

* DDPCAPS_1BIT, DDPCAPS_2BIT or DDPCAPS_4BIT capability and the target

3582

* surface is in 8bpp. Each color entry is one byte long and is an index

3583

* into destination surface's 8bpp palette.

3584

*/

3585

#define DDPCAPS_8BITENTRIES 0x00000002l

3586

3587

/*

3588

* Index is 8 bits. There are 256 color entries in the palette table.

3589

*/

3590

#define DDPCAPS_8BIT 0x00000004l

3591

3592

/*

3593

* Indicates that this DIRECTDRAWPALETTE should use the palette color array

3594

* passed into the lpDDColorArray parameter to initialize the DIRECTDRAWPALETTE

3595

* object.

3596

* This flag is obsolete. DirectDraw always initializes the color array from

3597

* the lpDDColorArray parameter. The definition remains for source-level

3598

* compatibility.

3599

*/

3600

#define DDPCAPS_INITIALIZE 0x00000000l

3601

3602

/*

3603

* This palette is the one attached to the primary surface. Changing this

3604

* table has immediate effect on the display unless DDPSETPAL_VSYNC is specified

3605

* and supported.

3606

*/

3607

#define DDPCAPS_PRIMARYSURFACE 0x00000010l

3608

3609

/*

3610

* This palette is the one attached to the primary surface left. Changing

3611

* this table has immediate effect on the display for the left eye unless

3612

* DDPSETPAL_VSYNC is specified and supported.

3613

*/

3614

#define DDPCAPS_PRIMARYSURFACELEFT 0x00000020l

3615

3616

/*

3617

* This palette can have all 256 entries defined

3618

*/

3619

#define DDPCAPS_ALLOW256 0x00000040l

3620

3621

/*

3622

* This palette can have modifications to it synced with the monitors

3623

* refresh rate.

3624

*/

3625

#define DDPCAPS_VSYNC 0x00000080l

3626

3627

/*

3628

* Index is 1 bit. There are two color entries in the palette table.

3629

*/

3630

#define DDPCAPS_1BIT 0x00000100l

3631

3632

/*

3633

* Index is 2 bit. There are four color entries in the palette table.

3634

*/

3635

#define DDPCAPS_2BIT 0x00000200l

3636

3637

/*

3638

* The peFlags member of PALETTEENTRY denotes an 8 bit alpha value

3639

*/

3640

#define DDPCAPS_ALPHA 0x00000400l

3641

3642

3643

/****************************************************************************

3644

*

3645

* DIRECTDRAWPALETTE SETENTRY CONSTANTS

3646

*

3647

****************************************************************************/

3648

3649

3650

/****************************************************************************

3651

*

3652

* DIRECTDRAWPALETTE GETENTRY CONSTANTS

3653

*

3654

****************************************************************************/

3655

3656

/* 0 is the only legal value */

3657

3658

/****************************************************************************

3659

*

3660

* DIRECTDRAWSURFACE SETPRIVATEDATA CONSTANTS

3661

*

3662

****************************************************************************/

3663

3664

/*

3665

* The passed pointer is an IUnknown ptr. The cbData argument to SetPrivateData

3666

* must be set to sizeof(IUnknown*). DirectDraw will call AddRef through this

3667

* pointer and Release when the private data is destroyed. This includes when

3668

* the surface or palette is destroyed before such priovate data is destroyed.

3669

*/

3670

#define DDSPD_IUNKNOWNPOINTER 0x00000001L

3671

3672

/*

3673

* Private data is only valid for the current state of the object,

3674

* as determined by the uniqueness value.

3675

*/

3676

#define DDSPD_VOLATILE 0x00000002L

3677

3678

3679

/****************************************************************************

3680

*

3681

* DIRECTDRAWSURFACE SETPALETTE CONSTANTS

3682

*

3683

****************************************************************************/

3684

3685

3686

/****************************************************************************

3687

*

3688

* DIRECTDRAW BITDEPTH CONSTANTS

3689

*

3690

* NOTE: These are only used to indicate supported bit depths. These

3691

* are flags only, they are not to be used as an actual bit depth. The

3692

* absolute numbers 1, 2, 4, 8, 16, 24 and 32 are used to indicate actual

3693

* bit depths in a surface or for changing the display mode.

3694

*

3695

****************************************************************************/

3696

3697

/*

3698

* 1 bit per pixel.

3699

*/

3700

#define DDBD_1 0x00004000l

3701

3702

/*

3703

* 2 bits per pixel.

3704

*/

3705

#define DDBD_2 0x00002000l

3706

3707

/*

3708

* 4 bits per pixel.

3709

*/

3710

#define DDBD_4 0x00001000l

3711

3712

/*

3713

* 8 bits per pixel.

3714

*/

3715

#define DDBD_8 0x00000800l

3716

3717

/*

3718

* 16 bits per pixel.

3719

*/

3720

#define DDBD_16 0x00000400l

3721

3722

/*

3723

* 24 bits per pixel.

3724

*/

3725

#define DDBD_24 0X00000200l

3726

3727

/*

3728

* 32 bits per pixel.

3729

*/

3730

#define DDBD_32 0x00000100l

3731

3732

/****************************************************************************

3733

*

3734

* DIRECTDRAWSURFACE SET/GET COLOR KEY FLAGS

3735

*

3736

****************************************************************************/

3737

3738

/*

3739

* Set if the structure contains a color space. Not set if the structure

3740

* contains a single color key.

3741

*/

3742

#define DDCKEY_COLORSPACE 0x00000001l

3743

3744

/*

3745

* Set if the structure specifies a color key or color space which is to be

3746

* used as a destination color key for blt operations.

3747

*/

3748

#define DDCKEY_DESTBLT 0x00000002l

3749

3750

/*

3751

* Set if the structure specifies a color key or color space which is to be

3752

* used as a destination color key for overlay operations.

3753

*/

3754

#define DDCKEY_DESTOVERLAY 0x00000004l

3755

3756

/*

3757

* Set if the structure specifies a color key or color space which is to be

3758

* used as a source color key for blt operations.

3759

*/

3760

#define DDCKEY_SRCBLT 0x00000008l

3761

3762

/*

3763

* Set if the structure specifies a color key or color space which is to be

3764

* used as a source color key for overlay operations.

3765

*/

3766

#define DDCKEY_SRCOVERLAY 0x00000010l

3767

3768

3769

/****************************************************************************

3770

*

3771

* DIRECTDRAW COLOR KEY CAPABILITY FLAGS

3772

*

3773

****************************************************************************/

3774

3775

/*

3776

* Supports transparent blting using a color key to identify the replaceable

3777

* bits of the destination surface for RGB colors.

3778

*/

3779

#define DDCKEYCAPS_DESTBLT 0x00000001l

3780

3781

/*

3782

* Supports transparent blting using a color space to identify the replaceable

3783

* bits of the destination surface for RGB colors.

3784

*/

3785

#define DDCKEYCAPS_DESTBLTCLRSPACE 0x00000002l

3786

3787

/*

3788

* Supports transparent blting using a color space to identify the replaceable

3789

* bits of the destination surface for YUV colors.

3790

*/

3791

#define DDCKEYCAPS_DESTBLTCLRSPACEYUV 0x00000004l

3792

3793

/*

3794

* Supports transparent blting using a color key to identify the replaceable

3795

* bits of the destination surface for YUV colors.

3796

*/

3797

#define DDCKEYCAPS_DESTBLTYUV 0x00000008l

3798

3799

/*

3800

* Supports overlaying using colorkeying of the replaceable bits of the surface

3801

* being overlayed for RGB colors.

3802

*/

3803

#define DDCKEYCAPS_DESTOVERLAY 0x00000010l

3804

3805

/*

3806

* Supports a color space as the color key for the destination for RGB colors.

3807

*/

3808

#define DDCKEYCAPS_DESTOVERLAYCLRSPACE 0x00000020l

3809

3810

/*

3811

* Supports a color space as the color key for the destination for YUV colors.

3812

*/

3813

#define DDCKEYCAPS_DESTOVERLAYCLRSPACEYUV 0x00000040l

3814

3815

/*

3816

* Supports only one active destination color key value for visible overlay

3817

* surfaces.

3818

*/

3819

#define DDCKEYCAPS_DESTOVERLAYONEACTIVE 0x00000080l

3820

3821

/*

3822

* Supports overlaying using colorkeying of the replaceable bits of the

3823

* surface being overlayed for YUV colors.

3824

*/

3825

#define DDCKEYCAPS_DESTOVERLAYYUV 0x00000100l

3826

3827

/*

3828

* Supports transparent blting using the color key for the source with

3829

* this surface for RGB colors.

3830

*/

3831

#define DDCKEYCAPS_SRCBLT 0x00000200l

3832

3833

/*

3834

* Supports transparent blting using a color space for the source with

3835

* this surface for RGB colors.

3836

*/

3837

#define DDCKEYCAPS_SRCBLTCLRSPACE 0x00000400l

3838

3839

/*

3840

* Supports transparent blting using a color space for the source with

3841

* this surface for YUV colors.

3842

*/

3843

#define DDCKEYCAPS_SRCBLTCLRSPACEYUV 0x00000800l

3844

3845

/*

3846

* Supports transparent blting using the color key for the source with

3847

* this surface for YUV colors.

3848

*/

3849

#define DDCKEYCAPS_SRCBLTYUV 0x00001000l

3850

3851

/*

3852

* Supports overlays using the color key for the source with this

3853

* overlay surface for RGB colors.

3854

*/

3855

#define DDCKEYCAPS_SRCOVERLAY 0x00002000l

3856

3857

/*

3858

* Supports overlays using a color space as the source color key for

3859

* the overlay surface for RGB colors.

3860

*/

3861

#define DDCKEYCAPS_SRCOVERLAYCLRSPACE 0x00004000l

3862

3863

/*

3864

* Supports overlays using a color space as the source color key for

3865

* the overlay surface for YUV colors.

3866

*/

3867

#define DDCKEYCAPS_SRCOVERLAYCLRSPACEYUV 0x00008000l

3868

3869

/*

3870

* Supports only one active source color key value for visible

3871

* overlay surfaces.

3872

*/

3873

#define DDCKEYCAPS_SRCOVERLAYONEACTIVE 0x00010000l

3874

3875

/*

3876

* Supports overlays using the color key for the source with this

3877

* overlay surface for YUV colors.

3878

*/

3879

#define DDCKEYCAPS_SRCOVERLAYYUV 0x00020000l

3880

3881

/*

3882

* there are no bandwidth trade-offs for using colorkey with an overlay

3883

*/

3884

#define DDCKEYCAPS_NOCOSTOVERLAY 0x00040000l

3885

3886

3887

/****************************************************************************

3888

*

3889

* DIRECTDRAW PIXELFORMAT FLAGS

3890

*

3891

****************************************************************************/

3892

3893

/*

3894

* The surface has alpha channel information in the pixel format.

3895

*/

3896

#define DDPF_ALPHAPIXELS 0x00000001l

3897

3898

/*

3899

* The pixel format contains alpha only information

3900

*/

3901

#define DDPF_ALPHA 0x00000002l

3902

3903

/*

3904

* The FourCC code is valid.

3905

*/

3906

#define DDPF_FOURCC 0x00000004l

3907

3908

/*

3909

* The surface is 4-bit color indexed.

3910

*/

3911

#define DDPF_PALETTEINDEXED4 0x00000008l

3912

3913

/*

3914

* The surface is indexed into a palette which stores indices

3915

* into the destination surface's 8-bit palette.

3916

*/

3917

#define DDPF_PALETTEINDEXEDTO8 0x00000010l

3918

3919

/*

3920

* The surface is 8-bit color indexed.

3921

*/

3922

#define DDPF_PALETTEINDEXED8 0x00000020l

3923

3924

/*

3925

* The RGB data in the pixel format structure is valid.

3926

*/

3927

#define DDPF_RGB 0x00000040l

3928

3929

/*

3930

* The surface will accept pixel data in the format specified

3931

* and compress it during the write.

3932

*/

3933

#define DDPF_COMPRESSED 0x00000080l

3934

3935

/*

3936

* The surface will accept RGB data and translate it during

3937

* the write to YUV data. The format of the data to be written

3938

* will be contained in the pixel format structure. The DDPF_RGB

3939

* flag will be set.

3940

*/

3941

#define DDPF_RGBTOYUV 0x00000100l

3942

3943

/*

3944

* pixel format is YUV - YUV data in pixel format struct is valid

3945

*/

3946

#define DDPF_YUV 0x00000200l

3947

3948

/*

3949

* pixel format is a z buffer only surface

3950

*/

3951

#define DDPF_ZBUFFER 0x00000400l

3952

3953

/*

3954

* The surface is 1-bit color indexed.

3955

*/

3956

#define DDPF_PALETTEINDEXED1 0x00000800l

3957

3958

/*

3959

* The surface is 2-bit color indexed.

3960

*/

3961

#define DDPF_PALETTEINDEXED2 0x00001000l

3962

3963

/*

3964

* The surface contains Z information in the pixels

3965

*/

3966

#define DDPF_ZPIXELS 0x00002000l

3967

3968

/*

3969

* The surface contains stencil information along with Z

3970

*/

3971

#define DDPF_STENCILBUFFER 0x00004000l

3972

3973

/*

3974

* Premultiplied alpha format -- the color components have been

3975

* premultiplied by the alpha component.

3976

*/

3977

#define DDPF_ALPHAPREMULT 0x00008000l

3978

3979

3980

/*

3981

* Luminance data in the pixel format is valid.

3982

* Use this flag for luminance-only or luminance+alpha surfaces,

3983

* the bit depth is then ddpf.dwLuminanceBitCount.

3984

*/

3985

#define DDPF_LUMINANCE 0x00020000l

3986

3987

/*

3988

* Luminance data in the pixel format is valid.

3989

* Use this flag when hanging luminance off bumpmap surfaces,

3990

* the bit mask for the luminance portion of the pixel is then

3991

* ddpf.dwBumpLuminanceBitMask

3992

*/

3993

#define DDPF_BUMPLUMINANCE 0x00040000l

3994

3995

/*

3996

* Bump map dUdV data in the pixel format is valid.

3997

*/

3998

#define DDPF_BUMPDUDV 0x00080000l

3999

4000

4001

/*===========================================================================

4002

*

4003

*

4004

* DIRECTDRAW CALLBACK FLAGS

4005

*

4006

*

4007

*==========================================================================*/

4008

4009

/****************************************************************************

4010

*

4011

* DIRECTDRAW ENUMSURFACES FLAGS

4012

*

4013

****************************************************************************/

4014

4015

/*

4016

* Enumerate all of the surfaces that meet the search criterion.

4017

*/

4018

#define DDENUMSURFACES_ALL 0x00000001l

4019

4020

/*

4021

* A search hit is a surface that matches the surface description.

4022

*/

4023

#define DDENUMSURFACES_MATCH 0x00000002l

4024

4025

/*

4026

* A search hit is a surface that does not match the surface description.

4027

*/

4028

#define DDENUMSURFACES_NOMATCH 0x00000004l

4029

4030

/*

4031

* Enumerate the first surface that can be created which meets the search criterion.

4032

*/

4033

#define DDENUMSURFACES_CANBECREATED 0x00000008l

4034

4035

/*

4036

* Enumerate the surfaces that already exist that meet the search criterion.

4037

*/

4038

#define DDENUMSURFACES_DOESEXIST 0x00000010l

4039

4040

4041

/****************************************************************************

4042

*

4043

* DIRECTDRAW SETDISPLAYMODE FLAGS

4044

*

4045

****************************************************************************/

4046

4047

/*

4048

* The desired mode is a standard VGA mode

4049

*/

4050

#define DDSDM_STANDARDVGAMODE 0x00000001l

4051

4052

4053

/****************************************************************************

4054

*

4055

* DIRECTDRAW ENUMDISPLAYMODES FLAGS

4056

*

4057

****************************************************************************/

4058

4059

/*

4060

* Enumerate Modes with different refresh rates. EnumDisplayModes guarantees

4061

* that a particular mode will be enumerated only once. This flag specifies whether

4062

* the refresh rate is taken into account when determining if a mode is unique.

4063

*/

4064

#define DDEDM_REFRESHRATES 0x00000001l

4065

4066

/*

4067

* Enumerate VGA modes. Specify this flag if you wish to enumerate supported VGA

4068

* modes such as mode 0x13 in addition to the usual ModeX modes (which are always

4069

* enumerated if the application has previously called SetCooperativeLevel with the

4070

* DDSCL_ALLOWMODEX flag set).

4071

*/

4072

#define DDEDM_STANDARDVGAMODES 0x00000002L

4073

4074

4075

/****************************************************************************

4076

*

4077

* DIRECTDRAW SETCOOPERATIVELEVEL FLAGS

4078

*

4079

****************************************************************************/

4080

4081

/*

4082

* Exclusive mode owner will be responsible for the entire primary surface.

4083

* GDI can be ignored. used with DD

4084

*/

4085

#define DDSCL_FULLSCREEN 0x00000001l

4086

4087

/*

4088

* allow CTRL_ALT_DEL to work while in fullscreen exclusive mode

4089

*/

4090

#define DDSCL_ALLOWREBOOT 0x00000002l

4091

4092

/*

4093

* prevents DDRAW from modifying the application window.

4094

* prevents DDRAW from minimize/restore the application window on activation.

4095

*/

4096

#define DDSCL_NOWINDOWCHANGES 0x00000004l

4097

4098

/*

4099

* app wants to work as a regular Windows application

4100

*/

4101

#define DDSCL_NORMAL 0x00000008l

4102

4103

/*

4104

* app wants exclusive access

4105

*/

4106

#define DDSCL_EXCLUSIVE 0x00000010l

4107

4108

4109

/*

4110

* app can deal with non-windows display modes

4111

*/

4112

#define DDSCL_ALLOWMODEX 0x00000040l

4113

4114

/*

4115

* this window will receive the focus messages

4116

*/

4117

#define DDSCL_SETFOCUSWINDOW 0x00000080l

4118

4119

/*

4120

* this window is associated with the DDRAW object and will

4121

* cover the screen in fullscreen mode

4122

*/

4123

#define DDSCL_SETDEVICEWINDOW 0x00000100l

4124

4125

/*

4126

* app wants DDRAW to create a window to be associated with the

4127

* DDRAW object

4128

*/

4129

#define DDSCL_CREATEDEVICEWINDOW 0x00000200l

4130

4131

/*

4132

* App explicitly asks DDRAW/D3D to be multithread safe. This makes D3D

4133

* take the global crtisec more frequently.

4134

*/

4135

#define DDSCL_MULTITHREADED 0x00000400l

4136

4137

/*

4138

* App specifies that it would like to keep the FPU set up for optimal Direct3D

4139

* performance (single precision and exceptions disabled) so Direct3D

4140

* does not need to explicitly set the FPU each time. This is assumed by

4141

* default in DirectX 7. See also DDSCL_FPUPRESERVE

4142

*/

4143

#define DDSCL_FPUSETUP 0x00000800l

4144

4145

/*

4146

* App specifies that it needs either double precision FPU or FPU exceptions

4147

* enabled. This makes Direct3D explicitly set the FPU state eah time it is

4148

* called. Setting the flag will reduce Direct3D performance. The flag is

4149

* assumed by default in DirectX 6 and earlier. See also DDSCL_FPUSETUP

4150

*/

4151

#define DDSCL_FPUPRESERVE 0x00001000l

4152

4153

4154

/****************************************************************************

4155

*

4156

* DIRECTDRAW BLT FLAGS

4157

*

4158

****************************************************************************/

4159

4160

/*

4161

* Use the alpha information in the pixel format or the alpha channel surface

4162

* attached to the destination surface as the alpha channel for this blt.

4163

*/

4164

#define DDBLT_ALPHADEST 0x00000001l

4165

4166

/*

4167

* Use the dwConstAlphaDest field in the DDBLTFX structure as the alpha channel

4168

* for the destination surface for this blt.

4169

*/

4170

#define DDBLT_ALPHADESTCONSTOVERRIDE 0x00000002l

4171

4172

/*

4173

* The NEG suffix indicates that the destination surface becomes more

4174

* transparent as the alpha value increases. (0 is opaque)

4175

*/

4176

#define DDBLT_ALPHADESTNEG 0x00000004l

4177

4178

/*

4179

* Use the lpDDSAlphaDest field in the DDBLTFX structure as the alpha

4180

* channel for the destination for this blt.

4181

*/

4182

#define DDBLT_ALPHADESTSURFACEOVERRIDE 0x00000008l

4183

4184

/*

4185

* Use the dwAlphaEdgeBlend field in the DDBLTFX structure as the alpha channel

4186

* for the edges of the image that border the color key colors.

4187

*/

4188

#define DDBLT_ALPHAEDGEBLEND 0x00000010l

4189

4190

/*

4191

* Use the alpha information in the pixel format or the alpha channel surface

4192

* attached to the source surface as the alpha channel for this blt.

4193

*/

4194

#define DDBLT_ALPHASRC 0x00000020l

4195

4196

/*

4197

* Use the dwConstAlphaSrc field in the DDBLTFX structure as the alpha channel

4198

* for the source for this blt.

4199

*/

4200

#define DDBLT_ALPHASRCCONSTOVERRIDE 0x00000040l

4201

4202

/*

4203

* The NEG suffix indicates that the source surface becomes more transparent

4204

* as the alpha value increases. (0 is opaque)

4205

*/

4206

#define DDBLT_ALPHASRCNEG 0x00000080l

4207

4208

/*

4209

* Use the lpDDSAlphaSrc field in the DDBLTFX structure as the alpha channel

4210

* for the source for this blt.

4211

*/

4212

#define DDBLT_ALPHASRCSURFACEOVERRIDE 0x00000100l

4213

4214

/*

4215

* Do this blt asynchronously through the FIFO in the order received. If

4216

* there is no room in the hardware FIFO fail the call.

4217

*/

4218

#define DDBLT_ASYNC 0x00000200l

4219

4220

/*

4221

* Uses the dwFillColor field in the DDBLTFX structure as the RGB color

4222

* to fill the destination rectangle on the destination surface with.

4223

*/

4224

#define DDBLT_COLORFILL 0x00000400l

4225

4226

/*

4227

* Uses the dwDDFX field in the DDBLTFX structure to specify the effects

4228

* to use for the blt.

4229

*/

4230

#define DDBLT_DDFX 0x00000800l

4231

4232

/*

4233

* Uses the dwDDROPS field in the DDBLTFX structure to specify the ROPS

4234

* that are not part of the Win32 API.

4235

*/

4236

#define DDBLT_DDROPS 0x00001000l

4237

4238

/*

4239

* Use the color key associated with the destination surface.

4240

*/

4241

#define DDBLT_KEYDEST 0x00002000l

4242

4243

/*

4244

* Use the dckDestColorkey field in the DDBLTFX structure as the color key

4245

* for the destination surface.

4246

*/

4247

#define DDBLT_KEYDESTOVERRIDE 0x00004000l

4248

4249

/*

4250

* Use the color key associated with the source surface.

4251

*/

4252

#define DDBLT_KEYSRC 0x00008000l

4253

4254

/*

4255

* Use the dckSrcColorkey field in the DDBLTFX structure as the color key

4256

* for the source surface.

4257

*/

4258

#define DDBLT_KEYSRCOVERRIDE 0x00010000l

4259

4260

/*

4261

* Use the dwROP field in the DDBLTFX structure for the raster operation

4262

* for this blt. These ROPs are the same as the ones defined in the Win32 API.

4263

*/

4264

#define DDBLT_ROP 0x00020000l

4265

4266

/*

4267

* Use the dwRotationAngle field in the DDBLTFX structure as the angle

4268

* (specified in 1/100th of a degree) to rotate the surface.

4269

*/

4270

#define DDBLT_ROTATIONANGLE 0x00040000l

4271

4272

/*

4273

* Z-buffered blt using the z-buffers attached to the source and destination

4274

* surfaces and the dwZBufferOpCode field in the DDBLTFX structure as the

4275

* z-buffer opcode.

4276

*/

4277

#define DDBLT_ZBUFFER 0x00080000l

4278

4279

/*

4280

* Z-buffered blt using the dwConstDest Zfield and the dwZBufferOpCode field

4281

* in the DDBLTFX structure as the z-buffer and z-buffer opcode respectively

4282

* for the destination.

4283

*/

4284

#define DDBLT_ZBUFFERDESTCONSTOVERRIDE 0x00100000l

4285

4286

/*

4287

* Z-buffered blt using the lpDDSDestZBuffer field and the dwZBufferOpCode

4288

* field in the DDBLTFX structure as the z-buffer and z-buffer opcode

4289

* respectively for the destination.

4290

*/

4291

#define DDBLT_ZBUFFERDESTOVERRIDE 0x00200000l

4292

4293

/*

4294

* Z-buffered blt using the dwConstSrcZ field and the dwZBufferOpCode field

4295

* in the DDBLTFX structure as the z-buffer and z-buffer opcode respectively

4296

* for the source.

4297

*/

4298

#define DDBLT_ZBUFFERSRCCONSTOVERRIDE 0x00400000l

4299

4300

/*

4301

* Z-buffered blt using the lpDDSSrcZBuffer field and the dwZBufferOpCode

4302

* field in the DDBLTFX structure as the z-buffer and z-buffer opcode

4303

* respectively for the source.

4304

*/

4305

#define DDBLT_ZBUFFERSRCOVERRIDE 0x00800000l

4306

4307

/*

4308

* wait until the device is ready to handle the blt

4309

* this will cause blt to not return DDERR_WASSTILLDRAWING

4310

*/

4311

#define DDBLT_WAIT 0x01000000l

4312

4313

/*

4314

* Uses the dwFillDepth field in the DDBLTFX structure as the depth value

4315

* to fill the destination rectangle on the destination Z-buffer surface

4316

* with.

4317

*/

4318

#define DDBLT_DEPTHFILL 0x02000000l

4319

4320

4321

/*

4322

* wait until the device is ready to handle the blt

4323

* this will cause blt to not return DDERR_WASSTILLDRAWING

4324

*/

4325

#define DDBLT_DONOTWAIT 0x08000000l

4326

4327

/*

4328

* These flags indicate a presentation blt (i.e. a blt

4329

* that moves surface contents from an offscreen back buffer to the primary

4330

* surface). The driver is not allowed to "queue" more than three such blts.

4331

* The "end" of the presentation blt is indicated, since the

4332

* blt may be clipped, in which case the runtime will call the driver with

4333

* several blts. All blts (even if not clipped) are tagged with DDBLT_PRESENTATION

4334

* and the last (even if not clipped) additionally with DDBLT_LAST_PRESENTATION.

4335

* Thus the true rule is that the driver must not schedule a DDBLT_PRESENTATION

4336

* blt if there are 3 or more DDBLT_PRESENTLAST blts in the hardware pipe.

4337

* If there are such blts in the pipe, the driver should return DDERR_WASSTILLDRAWING

4338

* until the oldest queued DDBLT_LAST_PRESENTATION blts has been retired (i.e. the

4339

* pixels have been actually written to the primary surface). Once the oldest blt

4340

* has been retired, the driver is free to schedule the current blt.

4341

* The goal is to provide a mechanism whereby the device's hardware queue never

4342

* gets more than 3 frames ahead of the frames being generated by the application.

4343

* When excessive queueing occurs, applications become unusable because the application

4344

* visibly lags user input, and such problems make windowed interactive applications impossible.

4345

* Some drivers may not have sufficient knowledge of their hardware's FIFO to know

4346

* when a certain blt has been retired. Such drivers should code cautiously, and

4347

* simply not allow any frames to be queued at all. DDBLT_LAST_PRESENTATION should cause

4348

* such drivers to return DDERR_WASSTILLDRAWING until the accelerator is completely

4349

* finished- exactly as if the application had called Lock on the source surface

4350

* before calling Blt.

4351

* In other words, the driver is allowed and encouraged to

4352

* generate as much latency as it can, but never more than 3 frames worth.

4353

* Implementation detail: Drivers should count blts against the SOURCE surface, not

4354

* against the primary surface. This enables multiple parallel windowed application

4355

* to function more optimally.

4356

* This flag is passed only to DX8 or higher drivers.

4357

*

4358

* APPLICATIONS DO NOT SET THESE FLAGS. THEY ARE SET BY THE DIRECTDRAW RUNTIME.

4359

*

4360

*/

4361

#define DDBLT_PRESENTATION 0x10000000l

4362

#define DDBLT_LAST_PRESENTATION 0x20000000l

4363

4364

4365

4366

/****************************************************************************

4367

*

4368

* BLTFAST FLAGS

4369

*

4370

****************************************************************************/

4371

4372

#define DDBLTFAST_NOCOLORKEY 0x00000000

4373

#define DDBLTFAST_SRCCOLORKEY 0x00000001

4374

#define DDBLTFAST_DESTCOLORKEY 0x00000002

4375

#define DDBLTFAST_WAIT 0x00000010

4376

#define DDBLTFAST_DONOTWAIT 0x00000020

4377

4378

/****************************************************************************

4379

*

4380

* FLIP FLAGS

4381

*

4382

****************************************************************************/

4383

4384

#define DDFLIP_WAIT 0x00000001L

4385

4386

/*

4387

* Indicates that the target surface contains the even field of video data.

4388

* This flag is only valid with an overlay surface.

4389

*/

4390

#define DDFLIP_EVEN 0x00000002L

4391

4392

/*

4393

* Indicates that the target surface contains the odd field of video data.

4394

* This flag is only valid with an overlay surface.

4395

*/

4396

#define DDFLIP_ODD 0x00000004L

4397

4398

/*

4399

* Causes DirectDraw to perform the physical flip immediately and return

4400

* to the application. Typically, what was the front buffer but is now the back

4401

* buffer will still be visible (depending on timing) until the next vertical

4402

* retrace. Subsequent operations involving the two flipped surfaces will

4403

* not check to see if the physical flip has finished (i.e. will not return

4404

* DDERR_WASSTILLDRAWING for that reason (but may for other reasons)).

4405

* This allows an application to perform Flips at a higher frequency than the

4406

* monitor refresh rate, but may introduce visible artifacts.

4407

* Only effective if DDCAPS2_FLIPNOVSYNC is set. If that bit is not set,

4408

* DDFLIP_NOVSYNC has no effect.

4409

*/

4410

#define DDFLIP_NOVSYNC 0x00000008L

4411

4412

4413

/*

4414

* Flip Interval Flags. These flags indicate how many vertical retraces to wait between

4415

* each flip. The default is one. DirectDraw will return DDERR_WASSTILLDRAWING for each

4416

* surface involved in the flip until the specified number of vertical retraces has

4417

* ocurred. Only effective if DDCAPS2_FLIPINTERVAL is set. If that bit is not set,

4418

* DDFLIP_INTERVALn has no effect.

4419

*/

4420

4421

/*

4422

* DirectDraw will flip on every other vertical sync

4423

*/

4424

#define DDFLIP_INTERVAL2 0x02000000L

4425

4426

4427

/*

4428

* DirectDraw will flip on every third vertical sync

4429

*/

4430

#define DDFLIP_INTERVAL3 0x03000000L

4431

4432

4433

/*

4434

* DirectDraw will flip on every fourth vertical sync

4435

*/

4436

#define DDFLIP_INTERVAL4 0x04000000L

4437

4438

/*

4439

* DirectDraw will flip and display a main stereo surface

4440

*/

4441

#define DDFLIP_STEREO 0x00000010L

4442

4443

/*

4444

* On IDirectDrawSurface7 and higher interfaces, the default is DDFLIP_WAIT. If you wish

4445

* to override the default and use time when the accelerator is busy (as denoted by

4446

* the DDERR_WASSTILLDRAWING return code) then use DDFLIP_DONOTWAIT.

4447

*/

4448

#define DDFLIP_DONOTWAIT 0x00000020L

4449

4450

4451

/****************************************************************************

4452

*

4453

* DIRECTDRAW SURFACE OVERLAY FLAGS

4454

*

4455

****************************************************************************/

4456

4457

/*

4458

* Use the alpha information in the pixel format or the alpha channel surface

4459

* attached to the destination surface as the alpha channel for the

4460

* destination overlay.

4461

*/

4462

#define DDOVER_ALPHADEST 0x00000001l

4463

4464

/*

4465

* Use the dwConstAlphaDest field in the DDOVERLAYFX structure as the

4466

* destination alpha channel for this overlay.

4467

*/

4468

#define DDOVER_ALPHADESTCONSTOVERRIDE 0x00000002l

4469

4470

/*

4471

* The NEG suffix indicates that the destination surface becomes more

4472

* transparent as the alpha value increases.

4473

*/

4474

#define DDOVER_ALPHADESTNEG 0x00000004l

4475

4476

/*

4477

* Use the lpDDSAlphaDest field in the DDOVERLAYFX structure as the alpha

4478

* channel destination for this overlay.

4479

*/

4480

#define DDOVER_ALPHADESTSURFACEOVERRIDE 0x00000008l

4481

4482

/*

4483

* Use the dwAlphaEdgeBlend field in the DDOVERLAYFX structure as the alpha

4484

* channel for the edges of the image that border the color key colors.

4485

*/

4486

#define DDOVER_ALPHAEDGEBLEND 0x00000010l

4487

4488

/*

4489

* Use the alpha information in the pixel format or the alpha channel surface

4490

* attached to the source surface as the source alpha channel for this overlay.

4491

*/

4492

#define DDOVER_ALPHASRC 0x00000020l

4493

4494

/*

4495

* Use the dwConstAlphaSrc field in the DDOVERLAYFX structure as the source

4496

* alpha channel for this overlay.

4497

*/

4498

#define DDOVER_ALPHASRCCONSTOVERRIDE 0x00000040l

4499

4500

/*

4501

* The NEG suffix indicates that the source surface becomes more transparent

4502

* as the alpha value increases.

4503

*/

4504

#define DDOVER_ALPHASRCNEG 0x00000080l

4505

4506

/*

4507

* Use the lpDDSAlphaSrc field in the DDOVERLAYFX structure as the alpha channel

4508

* source for this overlay.

4509

*/

4510

#define DDOVER_ALPHASRCSURFACEOVERRIDE 0x00000100l

4511

4512

/*

4513

* Turn this overlay off.

4514

*/

4515

#define DDOVER_HIDE 0x00000200l

4516

4517

/*

4518

* Use the color key associated with the destination surface.

4519

*/

4520

#define DDOVER_KEYDEST 0x00000400l

4521

4522

/*

4523

* Use the dckDestColorkey field in the DDOVERLAYFX structure as the color key

4524

* for the destination surface

4525

*/

4526

#define DDOVER_KEYDESTOVERRIDE 0x00000800l

4527

4528

/*

4529

* Use the color key associated with the source surface.

4530

*/

4531

#define DDOVER_KEYSRC 0x00001000l

4532

4533

/*

4534

* Use the dckSrcColorkey field in the DDOVERLAYFX structure as the color key

4535

* for the source surface.

4536

*/

4537

#define DDOVER_KEYSRCOVERRIDE 0x00002000l

4538

4539

/*

4540

* Turn this overlay on.

4541

*/

4542

#define DDOVER_SHOW 0x00004000l

4543

4544

/*

4545

* Add a dirty rect to an emulated overlayed surface.

4546

*/

4547

#define DDOVER_ADDDIRTYRECT 0x00008000l

4548

4549

/*

4550

* Redraw all dirty rects on an emulated overlayed surface.

4551

*/

4552

#define DDOVER_REFRESHDIRTYRECTS 0x00010000l

4553

4554

/*

4555

* Redraw the entire surface on an emulated overlayed surface.

4556

*/

4557

#define DDOVER_REFRESHALL 0x00020000l

4558

4559

4560

/*

4561

* Use the overlay FX flags to define special overlay FX

4562

*/

4563

#define DDOVER_DDFX 0x00080000l

4564

4565

/*

4566

* Autoflip the overlay when ever the video port autoflips

4567

*/

4568

#define DDOVER_AUTOFLIP 0x00100000l

4569

4570

/*

4571

* Display each field of video port data individually without

4572

* causing any jittery artifacts

4573

*/

4574

#define DDOVER_BOB 0x00200000l

4575

4576

/*

4577

* Indicates that bob/weave decisions should not be overridden by other

4578

* interfaces.

4579

*/

4580

#define DDOVER_OVERRIDEBOBWEAVE 0x00400000l

4581

4582

/*

4583

* Indicates that the surface memory is composed of interleaved fields.

4584

*/

4585

#define DDOVER_INTERLEAVED 0x00800000l

4586

4587

/*

4588

* Indicates that bob will be performed using hardware rather than

4589

* software or emulated.

4590

*/

4591

#define DDOVER_BOBHARDWARE 0x01000000l

4592

4593

/*

4594

* Indicates that overlay FX structure contains valid ARGB scaling factors.

4595

*/

4596

#define DDOVER_ARGBSCALEFACTORS 0x02000000l

4597

4598

/*

4599

* Indicates that ARGB scaling factors can be degraded to fit driver capabilities.

4600

*/

4601

#define DDOVER_DEGRADEARGBSCALING 0x04000000l

4602

4603

4604

/****************************************************************************

4605

*

4606

* DIRECTDRAWSURFACE LOCK FLAGS

4607

*

4608

****************************************************************************/

4609

4610

/*

4611

* The default. Set to indicate that Lock should return a valid memory pointer

4612

* to the top of the specified rectangle. If no rectangle is specified then a

4613

* pointer to the top of the surface is returned.

4614

*/

4615

#define DDLOCK_SURFACEMEMORYPTR 0x00000000L // default

4616

4617

/*

4618

* Set to indicate that Lock should wait until it can obtain a valid memory

4619

* pointer before returning. If this bit is set, Lock will never return

4620

* DDERR_WASSTILLDRAWING.

4621

*/

4622

#define DDLOCK_WAIT 0x00000001L

4623

4624

/*

4625

* Set if an event handle is being passed to Lock. Lock will trigger the event

4626

* when it can return the surface memory pointer requested.

4627

*/

4628

#define DDLOCK_EVENT 0x00000002L

4629

4630

/*

4631

* Indicates that the surface being locked will only be read from.

4632

*/

4633

#define DDLOCK_READONLY 0x00000010L

4634

4635

/*

4636

* Indicates that the surface being locked will only be written to

4637

*/

4638

#define DDLOCK_WRITEONLY 0x00000020L

4639

4640

4641

/*

4642

* Indicates that a system wide lock should not be taken when this surface

4643

* is locked. This has several advantages (cursor responsiveness, ability

4644

* to call more Windows functions, easier debugging) when locking video

4645

* memory surfaces. However, an application specifying this flag must

4646

* comply with a number of conditions documented in the help file.

4647

* Furthermore, this flag cannot be specified when locking the primary.

4648

*/

4649

#define DDLOCK_NOSYSLOCK 0x00000800L

4650

4651

/*

4652

* Used only with Direct3D Vertex Buffer Locks. Indicates that no vertices

4653

* that were referred to in Draw*PrimtiveVB calls since the start of the

4654

* frame (or the last lock without this flag) will be modified during the

4655

* lock. This can be useful when one is only appending data to the vertex

4656

* buffer

4657

*/

4658

#define DDLOCK_NOOVERWRITE 0x00001000L

4659

4660

/*

4661

* Indicates that no assumptions will be made about the contents of the

4662

* surface or vertex buffer during this lock.

4663

* This enables two things:

4664

* - Direct3D or the driver may provide an alternative memory

4665

* area as the vertex buffer. This is useful when one plans to clear the

4666

* contents of the vertex buffer and fill in new data.

4667

* - Drivers sometimes store surface data in a re-ordered format.

4668

* When the application locks the surface, the driver is forced to un-re-order

4669

* the surface data before allowing the application to see the surface contents.

4670

* This flag is a hint to the driver that it can skip the un-re-ordering process

4671

* since the application plans to overwrite every single pixel in the surface

4672

* or locked rectangle (and so erase any un-re-ordered pixels anyway).

4673

* Applications should always set this flag when they intend to overwrite the entire

4674

* surface or locked rectangle.

4675

*/

4676

#define DDLOCK_DISCARDCONTENTS 0x00002000L

4677

/*

4678

* DDLOCK_OKTOSWAP is an older, less informative name for DDLOCK_DISCARDCONTENTS

4679

*/

4680

#define DDLOCK_OKTOSWAP 0x00002000L

4681

4682

/*

4683

* On IDirectDrawSurface7 and higher interfaces, the default is DDLOCK_WAIT. If you wish

4684

* to override the default and use time when the accelerator is busy (as denoted by

4685

* the DDERR_WASSTILLDRAWING return code) then use DDLOCK_DONOTWAIT.

4686

*/

4687

#define DDLOCK_DONOTWAIT 0x00004000L

4688

4689

4690

4691

/****************************************************************************

4692

*

4693

* DIRECTDRAWSURFACE PAGELOCK FLAGS

4694

*

4695

****************************************************************************/

4696

4697

/*

4698

* No flags defined at present

4699

*/

4700

4701

4702

/****************************************************************************

4703

*

4704

* DIRECTDRAWSURFACE PAGEUNLOCK FLAGS

4705

*

4706

****************************************************************************/

4707

4708

/*

4709

* No flags defined at present

4710

*/

4711

4712

4713

/****************************************************************************

4714

*

4715

* DIRECTDRAWSURFACE BLT FX FLAGS

4716

*

4717

****************************************************************************/

4718

4719

/*

4720

* If stretching, use arithmetic stretching along the Y axis for this blt.

4721

*/

4722

#define DDBLTFX_ARITHSTRETCHY 0x00000001l

4723

4724

/*

4725

* Do this blt mirroring the surface left to right. Spin the

4726

* surface around its y-axis.

4727

*/

4728

#define DDBLTFX_MIRRORLEFTRIGHT 0x00000002l

4729

4730

/*

4731

* Do this blt mirroring the surface up and down. Spin the surface

4732

* around its x-axis.

4733

*/

4734

#define DDBLTFX_MIRRORUPDOWN 0x00000004l

4735

4736

/*

4737

* Schedule this blt to avoid tearing.

4738

*/

4739

#define DDBLTFX_NOTEARING 0x00000008l

4740

4741

/*

4742

* Do this blt rotating the surface one hundred and eighty degrees.

4743

*/

4744

#define DDBLTFX_ROTATE180 0x00000010l

4745

4746

/*

4747

* Do this blt rotating the surface two hundred and seventy degrees.

4748

*/

4749

#define DDBLTFX_ROTATE270 0x00000020l

4750

4751

/*

4752

* Do this blt rotating the surface ninety degrees.

4753

*/

4754

#define DDBLTFX_ROTATE90 0x00000040l

4755

4756

/*

4757

* Do this z blt using dwZBufferLow and dwZBufferHigh as range values

4758

* specified to limit the bits copied from the source surface.

4759

*/

4760

#define DDBLTFX_ZBUFFERRANGE 0x00000080l

4761

4762

/*

4763

* Do this z blt adding the dwZBufferBaseDest to each of the sources z values

4764

* before comparing it with the desting z values.

4765

*/

4766

#define DDBLTFX_ZBUFFERBASEDEST 0x00000100l

4767

4768

/****************************************************************************

4769

*

4770

* DIRECTDRAWSURFACE OVERLAY FX FLAGS

4771

*

4772

****************************************************************************/

4773

4774

/*

4775

* If stretching, use arithmetic stretching along the Y axis for this overlay.

4776

*/

4777

#define DDOVERFX_ARITHSTRETCHY 0x00000001l

4778

4779

/*

4780

* Mirror the overlay across the vertical axis

4781

*/

4782

#define DDOVERFX_MIRRORLEFTRIGHT 0x00000002l

4783

4784

/*

4785

* Mirror the overlay across the horizontal axis

4786

*/

4787

#define DDOVERFX_MIRRORUPDOWN 0x00000004l

4788

4789

/*

4790

* Deinterlace the overlay, if possible

4791

*/

4792

#define DDOVERFX_DEINTERLACE 0x00000008l

4793

4794

4795

/****************************************************************************

4796

*

4797

* DIRECTDRAW WAITFORVERTICALBLANK FLAGS

4798

*

4799

****************************************************************************/

4800

4801

/*

4802

* return when the vertical blank interval begins

4803

*/

4804

#define DDWAITVB_BLOCKBEGIN 0x00000001l

4805

4806

/*

4807

* set up an event to trigger when the vertical blank begins

4808

*/

4809

#define DDWAITVB_BLOCKBEGINEVENT 0x00000002l

4810

4811

/*

4812

* return when the vertical blank interval ends and display begins

4813

*/

4814

#define DDWAITVB_BLOCKEND 0x00000004l

4815

4816

/****************************************************************************

4817

*

4818

* DIRECTDRAW GETFLIPSTATUS FLAGS

4819

*

4820

****************************************************************************/

4821

4822

/*

4823

* is it OK to flip now?

4824

*/

4825

#define DDGFS_CANFLIP 0x00000001l

4826

4827

/*

4828

* is the last flip finished?

4829

*/

4830

#define DDGFS_ISFLIPDONE 0x00000002l

4831

4832

/****************************************************************************

4833

*

4834

* DIRECTDRAW GETBLTSTATUS FLAGS

4835

*

4836

****************************************************************************/

4837

4838

/*

4839

* is it OK to blt now?

4840

*/

4841

#define DDGBS_CANBLT 0x00000001l

4842

4843

/*

4844

* is the blt to the surface finished?

4845

*/

4846

#define DDGBS_ISBLTDONE 0x00000002l

4847

4848

4849

/****************************************************************************

4850

*

4851

* DIRECTDRAW ENUMOVERLAYZORDER FLAGS

4852

*

4853

****************************************************************************/

4854

4855

/*

4856

* Enumerate overlays back to front.

4857

*/

4858

#define DDENUMOVERLAYZ_BACKTOFRONT 0x00000000l

4859

4860

/*

4861

* Enumerate overlays front to back

4862

*/

4863

#define DDENUMOVERLAYZ_FRONTTOBACK 0x00000001l

4864

4865

/****************************************************************************

4866

*

4867

* DIRECTDRAW UPDATEOVERLAYZORDER FLAGS

4868

*

4869

****************************************************************************/

4870

4871

/*

4872

* Send overlay to front

4873

*/

4874

#define DDOVERZ_SENDTOFRONT 0x00000000l

4875

4876

/*

4877

* Send overlay to back

4878

*/

4879

#define DDOVERZ_SENDTOBACK 0x00000001l

4880

4881

/*

4882

* Move Overlay forward

4883

*/

4884

#define DDOVERZ_MOVEFORWARD 0x00000002l

4885

4886

/*

4887

* Move Overlay backward

4888

*/

4889

#define DDOVERZ_MOVEBACKWARD 0x00000003l

4890

4891

/*

4892

* Move Overlay in front of relative surface

4893

*/

4894

#define DDOVERZ_INSERTINFRONTOF 0x00000004l

4895

4896

/*

4897

* Move Overlay in back of relative surface

4898

*/

4899

#define DDOVERZ_INSERTINBACKOF 0x00000005l

4900

4901

4902

/****************************************************************************

4903

*

4904

* DIRECTDRAW SETGAMMARAMP FLAGS

4905

*

4906

****************************************************************************/

4907

4908

/*

4909

* Request calibrator to adjust the gamma ramp according to the physical

4910

* properties of the display so that the result should appear identical

4911

* on all systems.

4912

*/

4913

#define DDSGR_CALIBRATE 0x00000001L

4914

4915

4916

/****************************************************************************

4917

*

4918

* DIRECTDRAW STARTMODETEST FLAGS

4919

*

4920

****************************************************************************/

4921

4922

/*

4923

* Indicates that the mode being tested has passed

4924

*/

4925

#define DDSMT_ISTESTREQUIRED 0x00000001L

4926

4927

4928

/****************************************************************************

4929

*

4930

* DIRECTDRAW EVALUATEMODE FLAGS

4931

*

4932

****************************************************************************/

4933

4934

/*

4935

* Indicates that the mode being tested has passed

4936

*/

4937

#define DDEM_MODEPASSED 0x00000001L

4938

4939

/*

4940

* Indicates that the mode being tested has failed

4941

*/

4942

#define DDEM_MODEFAILED 0x00000002L

4943

4944

4945

/*===========================================================================

4946

*

4947

*

4948

* DIRECTDRAW RETURN CODES

4949

*

4950

* The return values from DirectDraw Commands and Surface that return an HRESULT

4951

* are codes from DirectDraw concerning the results of the action

4952

* requested by DirectDraw.

4953

*

4954

*==========================================================================*/

4955

4956

/*

4957

* Status is OK

4958

*

4959

* Issued by: DirectDraw Commands and all callbacks

4960

*/

4961

#define DD_OK 0

4962

#define DD_FALSE S_FALSE

4963

4964

/****************************************************************************

4965

*

4966

* DIRECTDRAW ENUMCALLBACK RETURN VALUES

4967

*

4968

* EnumCallback returns are used to control the flow of the DIRECTDRAW and

4969

* DIRECTDRAWSURFACE object enumerations. They can only be returned by

4970

* enumeration callback routines.

4971

*

4972

****************************************************************************/

4973

4974

/*

4975

* stop the enumeration

4976

*/

4977

#define DDENUMRET_CANCEL 0

4978

4979

/*

4980

* continue the enumeration

4981

*/

4982

#define DDENUMRET_OK 1

4983

4984

/****************************************************************************

4985

*

4986

* DIRECTDRAW ERRORS

4987

*

4988

* Errors are represented by negative values and cannot be combined.

4989

*

4990

****************************************************************************/

4991

4992

/*

4993

* This object is already initialized

4994

*/

4995

#define DDERR_ALREADYINITIALIZED MAKE_DDHRESULT( 5 )

4996

4997

/*

4998

* This surface can not be attached to the requested surface.

4999

*/

5000

#define DDERR_CANNOTATTACHSURFACE MAKE_DDHRESULT( 10 )

5001

5002

/*

5003

* This surface can not be detached from the requested surface.

5004

*/

5005

#define DDERR_CANNOTDETACHSURFACE MAKE_DDHRESULT( 20 )

5006

5007

/*

5008

* Support is currently not available.

5009

*/

5010

#define DDERR_CURRENTLYNOTAVAIL MAKE_DDHRESULT( 40 )

5011

5012

/*

5013

* An exception was encountered while performing the requested operation

5014

*/

5015

#define DDERR_EXCEPTION MAKE_DDHRESULT( 55 )

5016

5017

/*

5018

* Generic failure.

5019

*/

5020

#define DDERR_GENERIC E_FAIL

5021

5022

/*

5023

* Height of rectangle provided is not a multiple of reqd alignment

5024

*/

5025

#define DDERR_HEIGHTALIGN MAKE_DDHRESULT( 90 )

5026

5027

/*

5028

* Unable to match primary surface creation request with existing

5029

* primary surface.

5030

*/

5031

#define DDERR_INCOMPATIBLEPRIMARY MAKE_DDHRESULT( 95 )

5032

5033

/*

5034

* One or more of the caps bits passed to the callback are incorrect.

5035

*/

5036

#define DDERR_INVALIDCAPS MAKE_DDHRESULT( 100 )

5037

5038

/*

5039

* DirectDraw does not support provided Cliplist.

5040

*/

5041

#define DDERR_INVALIDCLIPLIST MAKE_DDHRESULT( 110 )

5042

5043

/*

5044

* DirectDraw does not support the requested mode

5045

*/

5046

#define DDERR_INVALIDMODE MAKE_DDHRESULT( 120 )

5047

5048

/*

5049

* DirectDraw received a pointer that was an invalid DIRECTDRAW object.

5050

*/

5051

#define DDERR_INVALIDOBJECT MAKE_DDHRESULT( 130 )

5052

5053

/*

5054

* One or more of the parameters passed to the callback function are

5055

* incorrect.

5056

*/

5057

#define DDERR_INVALIDPARAMS E_INVALIDARG

5058

5059

/*

5060

* pixel format was invalid as specified

5061

*/

5062

#define DDERR_INVALIDPIXELFORMAT MAKE_DDHRESULT( 145 )

5063

5064

/*

5065

* Rectangle provided was invalid.

5066

*/

5067

#define DDERR_INVALIDRECT MAKE_DDHRESULT( 150 )

5068

5069

/*

5070

* Operation could not be carried out because one or more surfaces are locked

5071

*/

5072

#define DDERR_LOCKEDSURFACES MAKE_DDHRESULT( 160 )

5073

5074

/*

5075

* There is no 3D present.

5076

*/

5077

#define DDERR_NO3D MAKE_DDHRESULT( 170 )

5078

5079

/*

5080

* Operation could not be carried out because there is no alpha accleration

5081

* hardware present or available.

5082

*/

5083

#define DDERR_NOALPHAHW MAKE_DDHRESULT( 180 )

5084

5085

/*

5086

* Operation could not be carried out because there is no stereo

5087

* hardware present or available.

5088

*/

5089

#define DDERR_NOSTEREOHARDWARE MAKE_DDHRESULT( 181 )

5090

5091

/*

5092

* Operation could not be carried out because there is no hardware

5093

* present which supports stereo surfaces

5094

*/

5095

#define DDERR_NOSURFACELEFT MAKE_DDHRESULT( 182 )

5096

5097

5098

5099

/*

5100

* no clip list available

5101

*/

5102

#define DDERR_NOCLIPLIST MAKE_DDHRESULT( 205 )

5103

5104

/*

5105

* Operation could not be carried out because there is no color conversion

5106

* hardware present or available.

5107

*/

5108

#define DDERR_NOCOLORCONVHW MAKE_DDHRESULT( 210 )

5109

5110

/*

5111

* Create function called without DirectDraw object method SetCooperativeLevel

5112

* being called.

5113

*/

5114

#define DDERR_NOCOOPERATIVELEVELSET MAKE_DDHRESULT( 212 )

5115

5116

/*

5117

* Surface doesn't currently have a color key

5118

*/

5119

#define DDERR_NOCOLORKEY MAKE_DDHRESULT( 215 )

5120

5121

/*

5122

* Operation could not be carried out because there is no hardware support

5123

* of the dest color key.

5124

*/

5125

#define DDERR_NOCOLORKEYHW MAKE_DDHRESULT( 220 )

5126

5127

/*

5128

* No DirectDraw support possible with current display driver

5129

*/

5130

#define DDERR_NODIRECTDRAWSUPPORT MAKE_DDHRESULT( 222 )

5131

5132

/*

5133

* Operation requires the application to have exclusive mode but the

5134

* application does not have exclusive mode.

5135

*/

5136

#define DDERR_NOEXCLUSIVEMODE MAKE_DDHRESULT( 225 )

5137

5138

/*

5139

* Flipping visible surfaces is not supported.

5140

*/

5141

#define DDERR_NOFLIPHW MAKE_DDHRESULT( 230 )

5142

5143

/*

5144

* There is no GDI present.

5145

*/

5146

#define DDERR_NOGDI MAKE_DDHRESULT( 240 )

5147

5148

/*

5149

* Operation could not be carried out because there is no hardware present

5150

* or available.

5151

*/

5152

#define DDERR_NOMIRRORHW MAKE_DDHRESULT( 250 )

5153

5154

/*

5155

* Requested item was not found

5156

*/

5157

#define DDERR_NOTFOUND MAKE_DDHRESULT( 255 )

5158

5159

/*

5160

* Operation could not be carried out because there is no overlay hardware

5161

* present or available.

5162

*/

5163

#define DDERR_NOOVERLAYHW MAKE_DDHRESULT( 260 )

5164

5165

/*

5166

* Operation could not be carried out because the source and destination

5167

* rectangles are on the same surface and overlap each other.

5168

*/

5169

#define DDERR_OVERLAPPINGRECTS MAKE_DDHRESULT( 270 )

5170

5171

/*

5172

* Operation could not be carried out because there is no appropriate raster

5173

* op hardware present or available.

5174

*/

5175

#define DDERR_NORASTEROPHW MAKE_DDHRESULT( 280 )

5176

5177

/*

5178

* Operation could not be carried out because there is no rotation hardware

5179

* present or available.

5180

*/

5181

#define DDERR_NOROTATIONHW MAKE_DDHRESULT( 290 )

5182

5183

/*

5184

* Operation could not be carried out because there is no hardware support

5185

* for stretching

5186

*/

5187

#define DDERR_NOSTRETCHHW MAKE_DDHRESULT( 310 )

5188

5189

/*

5190

* DirectDrawSurface is not in 4 bit color palette and the requested operation

5191

* requires 4 bit color palette.

5192

*/

5193

#define DDERR_NOT4BITCOLOR MAKE_DDHRESULT( 316 )

5194

5195

/*

5196

* DirectDrawSurface is not in 4 bit color index palette and the requested

5197

* operation requires 4 bit color index palette.

5198

*/

5199

#define DDERR_NOT4BITCOLORINDEX MAKE_DDHRESULT( 317 )

5200

5201

/*

5202

* DirectDraw Surface is not in 8 bit color mode and the requested operation

5203

* requires 8 bit color.

5204

*/

5205

#define DDERR_NOT8BITCOLOR MAKE_DDHRESULT( 320 )

5206

5207

/*

5208

* Operation could not be carried out because there is no texture mapping

5209

* hardware present or available.

5210

*/

5211

#define DDERR_NOTEXTUREHW MAKE_DDHRESULT( 330 )

5212

5213

/*

5214

* Operation could not be carried out because there is no hardware support

5215

* for vertical blank synchronized operations.

5216

*/

5217

#define DDERR_NOVSYNCHW MAKE_DDHRESULT( 335 )

5218

5219

/*

5220

* Operation could not be carried out because there is no hardware support

5221

* for zbuffer blting.

5222

*/

5223

#define DDERR_NOZBUFFERHW MAKE_DDHRESULT( 340 )

5224

5225

/*

5226

* Overlay surfaces could not be z layered based on their BltOrder because

5227

* the hardware does not support z layering of overlays.

5228

*/

5229

#define DDERR_NOZOVERLAYHW MAKE_DDHRESULT( 350 )

5230

5231

/*

5232

* The hardware needed for the requested operation has already been

5233

* allocated.

5234

*/

5235

#define DDERR_OUTOFCAPS MAKE_DDHRESULT( 360 )

5236

5237

/*

5238

* DirectDraw does not have enough memory to perform the operation.

5239

*/

5240

#define DDERR_OUTOFMEMORY E_OUTOFMEMORY

5241

5242

/*

5243

* DirectDraw does not have enough memory to perform the operation.

5244

*/

5245

#define DDERR_OUTOFVIDEOMEMORY MAKE_DDHRESULT( 380 )

5246

5247

/*

5248

* hardware does not support clipped overlays

5249

*/

5250

#define DDERR_OVERLAYCANTCLIP MAKE_DDHRESULT( 382 )

5251

5252

/*

5253

* Can only have ony color key active at one time for overlays

5254

*/

5255

#define DDERR_OVERLAYCOLORKEYONLYONEACTIVE MAKE_DDHRESULT( 384 )

5256

5257

/*

5258

* Access to this palette is being refused because the palette is already

5259

* locked by another thread.

5260

*/

5261

#define DDERR_PALETTEBUSY MAKE_DDHRESULT( 387 )

5262

5263

/*

5264

* No src color key specified for this operation.

5265

*/

5266

#define DDERR_COLORKEYNOTSET MAKE_DDHRESULT( 400 )

5267

5268

/*

5269

* This surface is already attached to the surface it is being attached to.

5270

*/

5271

#define DDERR_SURFACEALREADYATTACHED MAKE_DDHRESULT( 410 )

5272

5273

/*

5274

* This surface is already a dependency of the surface it is being made a

5275

* dependency of.

5276

*/

5277

#define DDERR_SURFACEALREADYDEPENDENT MAKE_DDHRESULT( 420 )

5278

5279

/*

5280

* Access to this surface is being refused because the surface is already

5281

* locked by another thread.

5282

*/

5283

#define DDERR_SURFACEBUSY MAKE_DDHRESULT( 430 )

5284

5285

/*

5286

* Access to this surface is being refused because no driver exists

5287

* which can supply a pointer to the surface.

5288

* This is most likely to happen when attempting to lock the primary

5289

* surface when no DCI provider is present.

5290

* Will also happen on attempts to lock an optimized surface.

5291

*/

5292

#define DDERR_CANTLOCKSURFACE MAKE_DDHRESULT( 435 )

5293

5294

/*

5295

* Access to Surface refused because Surface is obscured.

5296

*/

5297

#define DDERR_SURFACEISOBSCURED MAKE_DDHRESULT( 440 )

5298

5299

/*

5300

* Access to this surface is being refused because the surface is gone.

5301

* The DIRECTDRAWSURFACE object representing this surface should

5302

* have Restore called on it.

5303

*/

5304

#define DDERR_SURFACELOST MAKE_DDHRESULT( 450 )

5305

5306

/*

5307

* The requested surface is not attached.

5308

*/

5309

#define DDERR_SURFACENOTATTACHED MAKE_DDHRESULT( 460 )

5310

5311

/*

5312

* Height requested by DirectDraw is too large.

5313

*/

5314

#define DDERR_TOOBIGHEIGHT MAKE_DDHRESULT( 470 )

5315

5316

/*

5317

* Size requested by DirectDraw is too large -- The individual height and

5318

* width are OK.

5319

*/

5320

#define DDERR_TOOBIGSIZE MAKE_DDHRESULT( 480 )

5321

5322

/*

5323

* Width requested by DirectDraw is too large.

5324

*/

5325

#define DDERR_TOOBIGWIDTH MAKE_DDHRESULT( 490 )

5326

5327

/*

5328

* Action not supported.

5329

*/

5330

#define DDERR_UNSUPPORTED E_NOTIMPL

5331

5332

/*

5333

* Pixel format requested is unsupported by DirectDraw

5334

*/

5335

#define DDERR_UNSUPPORTEDFORMAT MAKE_DDHRESULT( 510 )

5336

5337

/*

5338

* Bitmask in the pixel format requested is unsupported by DirectDraw

5339

*/

5340

#define DDERR_UNSUPPORTEDMASK MAKE_DDHRESULT( 520 )

5341

5342

/*

5343

* The specified stream contains invalid data

5344

*/

5345

#define DDERR_INVALIDSTREAM MAKE_DDHRESULT( 521 )

5346

5347

/*

5348

* vertical blank is in progress

5349

*/

5350

#define DDERR_VERTICALBLANKINPROGRESS MAKE_DDHRESULT( 537 )

5351

5352

/*

5353

* Informs DirectDraw that the previous Blt which is transfering information

5354

* to or from this Surface is incomplete.

5355

*/

5356

#define DDERR_WASSTILLDRAWING MAKE_DDHRESULT( 540 )

5357

5358

5359

/*

5360

* The specified surface type requires specification of the COMPLEX flag

5361

*/

5362

#define DDERR_DDSCAPSCOMPLEXREQUIRED MAKE_DDHRESULT( 542 )

5363

5364

5365

/*

5366

* Rectangle provided was not horizontally aligned on reqd. boundary

5367

*/

5368

#define DDERR_XALIGN MAKE_DDHRESULT( 560 )

5369

5370

/*

5371

* The GUID passed to DirectDrawCreate is not a valid DirectDraw driver

5372

* identifier.

5373

*/

5374

#define DDERR_INVALIDDIRECTDRAWGUID MAKE_DDHRESULT( 561 )

5375

5376

/*

5377

* A DirectDraw object representing this driver has already been created

5378

* for this process.

5379

*/

5380

#define DDERR_DIRECTDRAWALREADYCREATED MAKE_DDHRESULT( 562 )

5381

5382

/*

5383

* A hardware only DirectDraw object creation was attempted but the driver

5384

* did not support any hardware.

5385

*/

5386

#define DDERR_NODIRECTDRAWHW MAKE_DDHRESULT( 563 )

5387

5388

/*

5389

* this process already has created a primary surface

5390

*/

5391

#define DDERR_PRIMARYSURFACEALREADYEXISTS MAKE_DDHRESULT( 564 )

5392

5393

/*

5394

* software emulation not available.

5395

*/

5396

#define DDERR_NOEMULATION MAKE_DDHRESULT( 565 )

5397

5398

/*

5399

* region passed to Clipper::GetClipList is too small.

5400

*/

5401

#define DDERR_REGIONTOOSMALL MAKE_DDHRESULT( 566 )

5402

5403

/*

5404

* an attempt was made to set a clip list for a clipper objec that

5405

* is already monitoring an hwnd.

5406

*/

5407

#define DDERR_CLIPPERISUSINGHWND MAKE_DDHRESULT( 567 )

5408

5409

/*

5410

* No clipper object attached to surface object

5411

*/

5412

#define DDERR_NOCLIPPERATTACHED MAKE_DDHRESULT( 568 )

5413

5414

/*

5415

* Clipper notification requires an HWND or

5416

* no HWND has previously been set as the CooperativeLevel HWND.

5417

*/

5418

#define DDERR_NOHWND MAKE_DDHRESULT( 569 )

5419

5420

/*

5421

* HWND used by DirectDraw CooperativeLevel has been subclassed,

5422

* this prevents DirectDraw from restoring state.

5423

*/

5424

#define DDERR_HWNDSUBCLASSED MAKE_DDHRESULT( 570 )

5425

5426

/*

5427

* The CooperativeLevel HWND has already been set.

5428

* It can not be reset while the process has surfaces or palettes created.

5429

*/

5430

#define DDERR_HWNDALREADYSET MAKE_DDHRESULT( 571 )

5431

5432

/*

5433

* No palette object attached to this surface.

5434

*/

5435

#define DDERR_NOPALETTEATTACHED MAKE_DDHRESULT( 572 )

5436

5437

/*

5438

* No hardware support for 16 or 256 color palettes.

5439

*/

5440

#define DDERR_NOPALETTEHW MAKE_DDHRESULT( 573 )

5441

5442

/*

5443

* If a clipper object is attached to the source surface passed into a

5444

* BltFast call.

5445

*/

5446

#define DDERR_BLTFASTCANTCLIP MAKE_DDHRESULT( 574 )

5447

5448

/*

5449

* No blter.

5450

*/

5451

#define DDERR_NOBLTHW MAKE_DDHRESULT( 575 )

5452

5453

/*

5454

* No DirectDraw ROP hardware.

5455

*/

5456

#define DDERR_NODDROPSHW MAKE_DDHRESULT( 576 )

5457

5458

/*

5459

* returned when GetOverlayPosition is called on a hidden overlay

5460

*/

5461

#define DDERR_OVERLAYNOTVISIBLE MAKE_DDHRESULT( 577 )

5462

5463

/*

5464

* returned when GetOverlayPosition is called on a overlay that UpdateOverlay

5465

* has never been called on to establish a destionation.

5466

*/

5467

#define DDERR_NOOVERLAYDEST MAKE_DDHRESULT( 578 )

5468

5469

/*

5470

* returned when the position of the overlay on the destionation is no longer

5471

* legal for that destionation.

5472

*/

5473

#define DDERR_INVALIDPOSITION MAKE_DDHRESULT( 579 )

5474

5475

/*

5476

* returned when an overlay member is called for a non-overlay surface

5477

*/

5478

#define DDERR_NOTAOVERLAYSURFACE MAKE_DDHRESULT( 580 )

5479

5480

/*

5481

* An attempt was made to set the cooperative level when it was already

5482

* set to exclusive.

5483

*/

5484

#define DDERR_EXCLUSIVEMODEALREADYSET MAKE_DDHRESULT( 581 )

5485

5486

/*

5487

* An attempt has been made to flip a surface that is not flippable.

5488

*/

5489

#define DDERR_NOTFLIPPABLE MAKE_DDHRESULT( 582 )

5490

5491

/*

5492

* Can't duplicate primary & 3D surfaces, or surfaces that are implicitly

5493

* created.

5494

*/

5495

#define DDERR_CANTDUPLICATE MAKE_DDHRESULT( 583 )

5496

5497

/*

5498

* Surface was not locked. An attempt to unlock a surface that was not

5499

* locked at all, or by this process, has been attempted.

5500

*/

5501

#define DDERR_NOTLOCKED MAKE_DDHRESULT( 584 )

5502

5503

/*

5504

* Windows can not create any more DCs, or a DC was requested for a paltte-indexed

5505

* surface when the surface had no palette AND the display mode was not palette-indexed

5506

* (in this case DirectDraw cannot select a proper palette into the DC)

5507

*/

5508

#define DDERR_CANTCREATEDC MAKE_DDHRESULT( 585 )

5509

5510

/*

5511

* No DC was ever created for this surface.

5512

*/

5513

#define DDERR_NODC MAKE_DDHRESULT( 586 )

5514

5515

/*

5516

* This surface can not be restored because it was created in a different

5517

* mode.

5518

*/

5519

#define DDERR_WRONGMODE MAKE_DDHRESULT( 587 )

5520

5521

/*

5522

* This surface can not be restored because it is an implicitly created

5523

* surface.

5524

*/

5525

#define DDERR_IMPLICITLYCREATED MAKE_DDHRESULT( 588 )

5526

5527

/*

5528

* The surface being used is not a palette-based surface

5529

*/

5530

#define DDERR_NOTPALETTIZED MAKE_DDHRESULT( 589 )

5531

5532

5533

/*

5534

* The display is currently in an unsupported mode

5535

*/

5536

#define DDERR_UNSUPPORTEDMODE MAKE_DDHRESULT( 590 )

5537

5538

/*

5539

* Operation could not be carried out because there is no mip-map

5540

* texture mapping hardware present or available.

5541

*/

5542

#define DDERR_NOMIPMAPHW MAKE_DDHRESULT( 591 )

5543

5544

/*

5545

* The requested action could not be performed because the surface was of

5546

* the wrong type.

5547

*/

5548

#define DDERR_INVALIDSURFACETYPE MAKE_DDHRESULT( 592 )

5549

5550

5551

/*

5552

* Device does not support optimized surfaces, therefore no video memory optimized surfaces

5553

*/

5554

#define DDERR_NOOPTIMIZEHW MAKE_DDHRESULT( 600 )

5555

5556

/*

5557

* Surface is an optimized surface, but has not yet been allocated any memory

5558

*/

5559

#define DDERR_NOTLOADED MAKE_DDHRESULT( 601 )

5560

5561

/*

5562

* Attempt was made to create or set a device window without first setting

5563

* the focus window

5564

*/

5565

#define DDERR_NOFOCUSWINDOW MAKE_DDHRESULT( 602 )

5566

5567

/*

5568

* Attempt was made to set a palette on a mipmap sublevel

5569

*/

5570

#define DDERR_NOTONMIPMAPSUBLEVEL MAKE_DDHRESULT( 603 )

5571

5572

/*

5573

* A DC has already been returned for this surface. Only one DC can be

5574

* retrieved per surface.

5575

*/

5576

#define DDERR_DCALREADYCREATED MAKE_DDHRESULT( 620 )

5577

5578

/*

5579

* An attempt was made to allocate non-local video memory from a device

5580

* that does not support non-local video memory.

5581

*/

5582

#define DDERR_NONONLOCALVIDMEM MAKE_DDHRESULT( 630 )

5583

5584

/*

5585

* The attempt to page lock a surface failed.

5586

*/

5587

#define DDERR_CANTPAGELOCK MAKE_DDHRESULT( 640 )

5588

5589

5590

/*

5591

* The attempt to page unlock a surface failed.

5592

*/

5593

#define DDERR_CANTPAGEUNLOCK MAKE_DDHRESULT( 660 )

5594

5595

/*

5596

* An attempt was made to page unlock a surface with no outstanding page locks.

5597

*/

5598

#define DDERR_NOTPAGELOCKED MAKE_DDHRESULT( 680 )

5599

5600

/*

5601

* There is more data available than the specified buffer size could hold

5602

*/

5603

#define DDERR_MOREDATA MAKE_DDHRESULT( 690 )

5604

5605

/*

5606

* The data has expired and is therefore no longer valid.

5607

*/

5608

#define DDERR_EXPIRED MAKE_DDHRESULT( 691 )

5609

5610

/*

5611

* The mode test has finished executing.

5612

*/

5613

#define DDERR_TESTFINISHED MAKE_DDHRESULT( 692 )

5614

5615

/*

5616

* The mode test has switched to a new mode.

5617

*/

5618

#define DDERR_NEWMODE MAKE_DDHRESULT( 693 )

5619

5620

/*

5621

* D3D has not yet been initialized.

5622

*/

5623

#define DDERR_D3DNOTINITIALIZED MAKE_DDHRESULT( 694 )

5624

5625

/*

5626

* The video port is not active

5627

*/

5628

#define DDERR_VIDEONOTACTIVE MAKE_DDHRESULT( 695 )

5629

5630

/*

5631

* The monitor does not have EDID data.

5632

*/

5633

#define DDERR_NOMONITORINFORMATION MAKE_DDHRESULT( 696 )

5634

5635

/*

5636

* The driver does not enumerate display mode refresh rates.

5637

*/

5638

#define DDERR_NODRIVERSUPPORT MAKE_DDHRESULT( 697 )

5639

5640

/*

5641

* Surfaces created by one direct draw device cannot be used directly by

5642

* another direct draw device.

5643

*/

5644

#define DDERR_DEVICEDOESNTOWNSURFACE MAKE_DDHRESULT( 699 )

5645

5646

5647

5648

/*

5649

* An attempt was made to invoke an interface member of a DirectDraw object

5650

* created by CoCreateInstance() before it was initialized.

5651

*/

5652

#define DDERR_NOTINITIALIZED CO_E_NOTINITIALIZED

5653

5654

5655

/* Alpha bit depth constants */

5656

5657

5658

#ifdef __cplusplus

5659

};

5660

#endif

5661

5662

#ifdef ENABLE_NAMELESS_UNION_PRAGMA

5663

#pragma warning(default:4201)

5664

#endif

5665

5666

#endif //__DDRAW_INCLUDED__

5667

5668