From 12f8804bc1fb61b3322c61a2ae5f328a80e8afc2 Mon Sep 17 00:00:00 2001 From: Spoike Date: Tue, 14 Sep 2004 07:12:17 +0000 Subject: [PATCH] minimal set of dx7 sdk. git-svn-id: https://svn.code.sf.net/p/fteqw/code/trunk@210 fc73d0e0-1445-4013-8a0c-d673dee63da5 --- engine/libs/dxsdk7/include/d3d.h | 1683 +++++++ engine/libs/dxsdk7/include/d3dcaps.h | 593 +++ engine/libs/dxsdk7/include/d3dtypes.h | 1820 ++++++++ engine/libs/dxsdk7/include/d3dx.h | 26 + engine/libs/dxsdk7/include/d3dxcore.h | 1027 +++++ engine/libs/dxsdk7/include/d3dxerr.h | 407 ++ engine/libs/dxsdk7/include/d3dxmath.h | 1085 +++++ engine/libs/dxsdk7/include/d3dxmath.inl | 1809 ++++++++ engine/libs/dxsdk7/include/d3dxshapes.h | 209 + engine/libs/dxsdk7/include/d3dxsprite.h | 321 ++ engine/libs/dxsdk7/include/ddraw.h | 5561 +++++++++++++++++++++++ engine/libs/dxsdk7/lib/d3dx.lib | Bin 0 -> 563186 bytes engine/libs/dxsdk7/lib/ddraw.lib | Bin 0 -> 28000 bytes engine/libs/dxsdk7/lib/dxguid.lib | Bin 0 -> 78714 bytes 14 files changed, 14541 insertions(+) create mode 100644 engine/libs/dxsdk7/include/d3d.h create mode 100644 engine/libs/dxsdk7/include/d3dcaps.h create mode 100644 engine/libs/dxsdk7/include/d3dtypes.h create mode 100644 engine/libs/dxsdk7/include/d3dx.h create mode 100644 engine/libs/dxsdk7/include/d3dxcore.h create mode 100644 engine/libs/dxsdk7/include/d3dxerr.h create mode 100644 engine/libs/dxsdk7/include/d3dxmath.h create mode 100644 engine/libs/dxsdk7/include/d3dxmath.inl create mode 100644 engine/libs/dxsdk7/include/d3dxshapes.h create mode 100644 engine/libs/dxsdk7/include/d3dxsprite.h create mode 100644 engine/libs/dxsdk7/include/ddraw.h create mode 100644 engine/libs/dxsdk7/lib/d3dx.lib create mode 100644 engine/libs/dxsdk7/lib/ddraw.lib create mode 100644 engine/libs/dxsdk7/lib/dxguid.lib diff --git a/engine/libs/dxsdk7/include/d3d.h b/engine/libs/dxsdk7/include/d3d.h new file mode 100644 index 000000000..ae69335b8 --- /dev/null +++ b/engine/libs/dxsdk7/include/d3d.h @@ -0,0 +1,1683 @@ +/*==========================================================================; + * + * + * File: d3d.h + * Content: Direct3D include file + * + ****************************************************************************/ + +#ifndef _D3D_H_ +#define _D3D_H_ + + +#include + +#define COM_NO_WINDOWS_H +#include + +#define D3DAPI WINAPI + +#ifndef DIRECT3D_VERSION +#define DIRECT3D_VERSION 0x0700 +#endif + +/* + * Interface IID's + */ +#if defined( _WIN32 ) && !defined( _NO_COM) +DEFINE_GUID( IID_IDirect3D, 0x3BBA0080,0x2421,0x11CF,0xA3,0x1A,0x00,0xAA,0x00,0xB9,0x33,0x56 ); +#if(DIRECT3D_VERSION >= 0x0500) +DEFINE_GUID( IID_IDirect3D2, 0x6aae1ec1,0x662a,0x11d0,0x88,0x9d,0x00,0xaa,0x00,0xbb,0xb7,0x6a); +#endif /* DIRECT3D_VERSION >= 0x0500 */ +#if(DIRECT3D_VERSION >= 0x0600) +DEFINE_GUID( IID_IDirect3D3, 0xbb223240,0xe72b,0x11d0,0xa9,0xb4,0x00,0xaa,0x00,0xc0,0x99,0x3e); +#endif /* DIRECT3D_VERSION >= 0x0600 */ +#if(DIRECT3D_VERSION >= 0x0700) +DEFINE_GUID( IID_IDirect3D7, 0xf5049e77,0x4861,0x11d2,0xa4,0x7,0x0,0xa0,0xc9,0x6,0x29,0xa8); +#endif /* DIRECT3D_VERSION >= 0x0700 */ + +#if(DIRECT3D_VERSION >= 0x0500) +DEFINE_GUID( IID_IDirect3DRampDevice, 0xF2086B20,0x259F,0x11CF,0xA3,0x1A,0x00,0xAA,0x00,0xB9,0x33,0x56 ); +DEFINE_GUID( IID_IDirect3DRGBDevice, 0xA4665C60,0x2673,0x11CF,0xA3,0x1A,0x00,0xAA,0x00,0xB9,0x33,0x56 ); +DEFINE_GUID( IID_IDirect3DHALDevice, 0x84E63dE0,0x46AA,0x11CF,0x81,0x6F,0x00,0x00,0xC0,0x20,0x15,0x6E ); +DEFINE_GUID( IID_IDirect3DMMXDevice, 0x881949a1,0xd6f3,0x11d0,0x89,0xab,0x00,0xa0,0xc9,0x05,0x41,0x29 ); +#endif /* DIRECT3D_VERSION >= 0x0500 */ + +#if(DIRECT3D_VERSION >= 0x0600) +DEFINE_GUID( IID_IDirect3DRefDevice, 0x50936643, 0x13e9, 0x11d1, 0x89, 0xaa, 0x0, 0xa0, 0xc9, 0x5, 0x41, 0x29); +DEFINE_GUID( IID_IDirect3DNullDevice, 0x8767df22, 0xbacc, 0x11d1, 0x89, 0x69, 0x0, 0xa0, 0xc9, 0x6, 0x29, 0xa8); +#endif /* DIRECT3D_VERSION >= 0x0600 */ +#if(DIRECT3D_VERSION >= 0x0700) +DEFINE_GUID( IID_IDirect3DTnLHalDevice, 0xf5049e78, 0x4861, 0x11d2, 0xa4, 0x7, 0x0, 0xa0, 0xc9, 0x6, 0x29, 0xa8); +#endif /* DIRECT3D_VERSION >= 0x0700 */ + +/* + * Internal Guid to distinguish requested MMX from MMX being used as an RGB rasterizer + */ + +DEFINE_GUID( IID_IDirect3DDevice, 0x64108800,0x957d,0X11d0,0x89,0xab,0x00,0xa0,0xc9,0x05,0x41,0x29 ); +#if(DIRECT3D_VERSION >= 0x0500) +DEFINE_GUID( IID_IDirect3DDevice2, 0x93281501, 0x8cf8, 0x11d0, 0x89, 0xab, 0x0, 0xa0, 0xc9, 0x5, 0x41, 0x29); +#endif /* DIRECT3D_VERSION >= 0x0500 */ +#if(DIRECT3D_VERSION >= 0x0600) +DEFINE_GUID( IID_IDirect3DDevice3, 0xb0ab3b60, 0x33d7, 0x11d1, 0xa9, 0x81, 0x0, 0xc0, 0x4f, 0xd7, 0xb1, 0x74); +#endif /* DIRECT3D_VERSION >= 0x0600 */ +#if(DIRECT3D_VERSION >= 0x0700) +DEFINE_GUID( IID_IDirect3DDevice7, 0xf5049e79, 0x4861, 0x11d2, 0xa4, 0x7, 0x0, 0xa0, 0xc9, 0x6, 0x29, 0xa8); +#endif /* DIRECT3D_VERSION >= 0x0700 */ + +DEFINE_GUID( IID_IDirect3DTexture, 0x2CDCD9E0,0x25A0,0x11CF,0xA3,0x1A,0x00,0xAA,0x00,0xB9,0x33,0x56 ); +#if(DIRECT3D_VERSION >= 0x0500) +DEFINE_GUID( IID_IDirect3DTexture2, 0x93281502, 0x8cf8, 0x11d0, 0x89, 0xab, 0x0, 0xa0, 0xc9, 0x5, 0x41, 0x29); +#endif /* DIRECT3D_VERSION >= 0x0500 */ + +DEFINE_GUID( IID_IDirect3DLight, 0x4417C142,0x33AD,0x11CF,0x81,0x6F,0x00,0x00,0xC0,0x20,0x15,0x6E ); + +DEFINE_GUID( IID_IDirect3DMaterial, 0x4417C144,0x33AD,0x11CF,0x81,0x6F,0x00,0x00,0xC0,0x20,0x15,0x6E ); +#if(DIRECT3D_VERSION >= 0x0500) +DEFINE_GUID( IID_IDirect3DMaterial2, 0x93281503, 0x8cf8, 0x11d0, 0x89, 0xab, 0x0, 0xa0, 0xc9, 0x5, 0x41, 0x29); +#endif /* DIRECT3D_VERSION >= 0x0500 */ +#if(DIRECT3D_VERSION >= 0x0600) +DEFINE_GUID( IID_IDirect3DMaterial3, 0xca9c46f4, 0xd3c5, 0x11d1, 0xb7, 0x5a, 0x0, 0x60, 0x8, 0x52, 0xb3, 0x12); +#endif /* DIRECT3D_VERSION >= 0x0600 */ + +DEFINE_GUID( IID_IDirect3DExecuteBuffer,0x4417C145,0x33AD,0x11CF,0x81,0x6F,0x00,0x00,0xC0,0x20,0x15,0x6E ); +DEFINE_GUID( IID_IDirect3DViewport, 0x4417C146,0x33AD,0x11CF,0x81,0x6F,0x00,0x00,0xC0,0x20,0x15,0x6E ); +#if(DIRECT3D_VERSION >= 0x0500) +DEFINE_GUID( IID_IDirect3DViewport2, 0x93281500, 0x8cf8, 0x11d0, 0x89, 0xab, 0x0, 0xa0, 0xc9, 0x5, 0x41, 0x29); +#endif /* DIRECT3D_VERSION >= 0x0500 */ +#if(DIRECT3D_VERSION >= 0x0600) +DEFINE_GUID( IID_IDirect3DViewport3, 0xb0ab3b61, 0x33d7, 0x11d1, 0xa9, 0x81, 0x0, 0xc0, 0x4f, 0xd7, 0xb1, 0x74); +#endif /* DIRECT3D_VERSION >= 0x0600 */ +#if(DIRECT3D_VERSION >= 0x0600) +DEFINE_GUID( IID_IDirect3DVertexBuffer, 0x7a503555, 0x4a83, 0x11d1, 0xa5, 0xdb, 0x0, 0xa0, 0xc9, 0x3, 0x67, 0xf8); +#endif /* DIRECT3D_VERSION >= 0x0600 */ +#if(DIRECT3D_VERSION >= 0x0700) +DEFINE_GUID( IID_IDirect3DVertexBuffer7, 0xf5049e7d, 0x4861, 0x11d2, 0xa4, 0x7, 0x0, 0xa0, 0xc9, 0x6, 0x29, 0xa8); +#endif /* DIRECT3D_VERSION >= 0x0700 */ +#endif + +#ifdef __cplusplus +struct IDirect3D; +struct IDirect3DDevice; +struct IDirect3DLight; +struct IDirect3DMaterial; +struct IDirect3DExecuteBuffer; +struct IDirect3DTexture; +struct IDirect3DViewport; +typedef struct IDirect3D *LPDIRECT3D; +typedef struct IDirect3DDevice *LPDIRECT3DDEVICE; +typedef struct IDirect3DExecuteBuffer *LPDIRECT3DEXECUTEBUFFER; +typedef struct IDirect3DLight *LPDIRECT3DLIGHT; +typedef struct IDirect3DMaterial *LPDIRECT3DMATERIAL; +typedef struct IDirect3DTexture *LPDIRECT3DTEXTURE; +typedef struct IDirect3DViewport *LPDIRECT3DVIEWPORT; + +#if(DIRECT3D_VERSION >= 0x0500) +struct IDirect3D2; +struct IDirect3DDevice2; +struct IDirect3DMaterial2; +struct IDirect3DTexture2; +struct IDirect3DViewport2; +typedef struct IDirect3D2 *LPDIRECT3D2; +typedef struct IDirect3DDevice2 *LPDIRECT3DDEVICE2; +typedef struct IDirect3DMaterial2 *LPDIRECT3DMATERIAL2; +typedef struct IDirect3DTexture2 *LPDIRECT3DTEXTURE2; +typedef struct IDirect3DViewport2 *LPDIRECT3DVIEWPORT2; +#endif /* DIRECT3D_VERSION >= 0x0500 */ + +#if(DIRECT3D_VERSION >= 0x0600) +struct IDirect3D3; +struct IDirect3DDevice3; +struct IDirect3DMaterial3; +struct IDirect3DViewport3; +struct IDirect3DVertexBuffer; +typedef struct IDirect3D3 *LPDIRECT3D3; +typedef struct IDirect3DDevice3 *LPDIRECT3DDEVICE3; +typedef struct IDirect3DMaterial3 *LPDIRECT3DMATERIAL3; +typedef struct IDirect3DViewport3 *LPDIRECT3DVIEWPORT3; +typedef struct IDirect3DVertexBuffer *LPDIRECT3DVERTEXBUFFER; +#endif /* DIRECT3D_VERSION >= 0x0600 */ + +#if(DIRECT3D_VERSION >= 0x0700) +struct IDirect3D7; +struct IDirect3DDevice7; +struct IDirect3DVertexBuffer7; +typedef struct IDirect3D7 *LPDIRECT3D7; +typedef struct IDirect3DDevice7 *LPDIRECT3DDEVICE7; +typedef struct IDirect3DVertexBuffer7 *LPDIRECT3DVERTEXBUFFER7; +#endif /* DIRECT3D_VERSION >= 0x0700 */ + +#else + +typedef struct IDirect3D *LPDIRECT3D; +typedef struct IDirect3DDevice *LPDIRECT3DDEVICE; +typedef struct IDirect3DExecuteBuffer *LPDIRECT3DEXECUTEBUFFER; +typedef struct IDirect3DLight *LPDIRECT3DLIGHT; +typedef struct IDirect3DMaterial *LPDIRECT3DMATERIAL; +typedef struct IDirect3DTexture *LPDIRECT3DTEXTURE; +typedef struct IDirect3DViewport *LPDIRECT3DVIEWPORT; + +#if(DIRECT3D_VERSION >= 0x0500) +typedef struct IDirect3D2 *LPDIRECT3D2; +typedef struct IDirect3DDevice2 *LPDIRECT3DDEVICE2; +typedef struct IDirect3DMaterial2 *LPDIRECT3DMATERIAL2; +typedef struct IDirect3DTexture2 *LPDIRECT3DTEXTURE2; +typedef struct IDirect3DViewport2 *LPDIRECT3DVIEWPORT2; +#endif /* DIRECT3D_VERSION >= 0x0500 */ + +#if(DIRECT3D_VERSION >= 0x0600) +typedef struct IDirect3D3 *LPDIRECT3D3; +typedef struct IDirect3DDevice3 *LPDIRECT3DDEVICE3; +typedef struct IDirect3DMaterial3 *LPDIRECT3DMATERIAL3; +typedef struct IDirect3DViewport3 *LPDIRECT3DVIEWPORT3; +typedef struct IDirect3DVertexBuffer *LPDIRECT3DVERTEXBUFFER; +#endif /* DIRECT3D_VERSION >= 0x0600 */ + +#if(DIRECT3D_VERSION >= 0x0700) +typedef struct IDirect3D7 *LPDIRECT3D7; +typedef struct IDirect3DDevice7 *LPDIRECT3DDEVICE7; +typedef struct IDirect3DVertexBuffer7 *LPDIRECT3DVERTEXBUFFER7; +#endif /* DIRECT3D_VERSION >= 0x0700 */ + +#endif + +#include "d3dtypes.h" +#include "d3dcaps.h" + + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * Direct3D interfaces + */ +#undef INTERFACE +#define INTERFACE IDirect3D + +DECLARE_INTERFACE_(IDirect3D, IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + + /*** IDirect3D methods ***/ + STDMETHOD(Initialize)(THIS_ REFCLSID) PURE; + STDMETHOD(EnumDevices)(THIS_ LPD3DENUMDEVICESCALLBACK,LPVOID) PURE; + STDMETHOD(CreateLight)(THIS_ LPDIRECT3DLIGHT*,IUnknown*) PURE; + STDMETHOD(CreateMaterial)(THIS_ LPDIRECT3DMATERIAL*,IUnknown*) PURE; + STDMETHOD(CreateViewport)(THIS_ LPDIRECT3DVIEWPORT*,IUnknown*) PURE; + STDMETHOD(FindDevice)(THIS_ LPD3DFINDDEVICESEARCH,LPD3DFINDDEVICERESULT) PURE; +}; + +typedef struct IDirect3D *LPDIRECT3D; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirect3D_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3D_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3D_Release(p) (p)->lpVtbl->Release(p) +#define IDirect3D_Initialize(p,a) (p)->lpVtbl->Initialize(p,a) +#define IDirect3D_EnumDevices(p,a,b) (p)->lpVtbl->EnumDevices(p,a,b) +#define IDirect3D_CreateLight(p,a,b) (p)->lpVtbl->CreateLight(p,a,b) +#define IDirect3D_CreateMaterial(p,a,b) (p)->lpVtbl->CreateMaterial(p,a,b) +#define IDirect3D_CreateViewport(p,a,b) (p)->lpVtbl->CreateViewport(p,a,b) +#define IDirect3D_FindDevice(p,a,b) (p)->lpVtbl->FindDevice(p,a,b) +#else +#define IDirect3D_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3D_AddRef(p) (p)->AddRef() +#define IDirect3D_Release(p) (p)->Release() +#define IDirect3D_Initialize(p,a) (p)->Initialize(a) +#define IDirect3D_EnumDevices(p,a,b) (p)->EnumDevices(a,b) +#define IDirect3D_CreateLight(p,a,b) (p)->CreateLight(a,b) +#define IDirect3D_CreateMaterial(p,a,b) (p)->CreateMaterial(a,b) +#define IDirect3D_CreateViewport(p,a,b) (p)->CreateViewport(a,b) +#define IDirect3D_FindDevice(p,a,b) (p)->FindDevice(a,b) +#endif + +#if(DIRECT3D_VERSION >= 0x0500) +#undef INTERFACE +#define INTERFACE IDirect3D2 + +DECLARE_INTERFACE_(IDirect3D2, IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + + /*** IDirect3D2 methods ***/ + STDMETHOD(EnumDevices)(THIS_ LPD3DENUMDEVICESCALLBACK,LPVOID) PURE; + STDMETHOD(CreateLight)(THIS_ LPDIRECT3DLIGHT*,IUnknown*) PURE; + STDMETHOD(CreateMaterial)(THIS_ LPDIRECT3DMATERIAL2*,IUnknown*) PURE; + STDMETHOD(CreateViewport)(THIS_ LPDIRECT3DVIEWPORT2*,IUnknown*) PURE; + STDMETHOD(FindDevice)(THIS_ LPD3DFINDDEVICESEARCH,LPD3DFINDDEVICERESULT) PURE; + STDMETHOD(CreateDevice)(THIS_ REFCLSID,LPDIRECTDRAWSURFACE,LPDIRECT3DDEVICE2*) PURE; +}; + +typedef struct IDirect3D2 *LPDIRECT3D2; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirect3D2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3D2_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3D2_Release(p) (p)->lpVtbl->Release(p) +#define IDirect3D2_EnumDevices(p,a,b) (p)->lpVtbl->EnumDevices(p,a,b) +#define IDirect3D2_CreateLight(p,a,b) (p)->lpVtbl->CreateLight(p,a,b) +#define IDirect3D2_CreateMaterial(p,a,b) (p)->lpVtbl->CreateMaterial(p,a,b) +#define IDirect3D2_CreateViewport(p,a,b) (p)->lpVtbl->CreateViewport(p,a,b) +#define IDirect3D2_FindDevice(p,a,b) (p)->lpVtbl->FindDevice(p,a,b) +#define IDirect3D2_CreateDevice(p,a,b,c) (p)->lpVtbl->CreateDevice(p,a,b,c) +#else +#define IDirect3D2_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3D2_AddRef(p) (p)->AddRef() +#define IDirect3D2_Release(p) (p)->Release() +#define IDirect3D2_EnumDevices(p,a,b) (p)->EnumDevices(a,b) +#define IDirect3D2_CreateLight(p,a,b) (p)->CreateLight(a,b) +#define IDirect3D2_CreateMaterial(p,a,b) (p)->CreateMaterial(a,b) +#define IDirect3D2_CreateViewport(p,a,b) (p)->CreateViewport(a,b) +#define IDirect3D2_FindDevice(p,a,b) (p)->FindDevice(a,b) +#define IDirect3D2_CreateDevice(p,a,b,c) (p)->CreateDevice(a,b,c) +#endif +#endif /* DIRECT3D_VERSION >= 0x0500 */ + +#if(DIRECT3D_VERSION >= 0x0600) +#undef INTERFACE +#define INTERFACE IDirect3D3 + +DECLARE_INTERFACE_(IDirect3D3, IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + + /*** IDirect3D3 methods ***/ + STDMETHOD(EnumDevices)(THIS_ LPD3DENUMDEVICESCALLBACK,LPVOID) PURE; + STDMETHOD(CreateLight)(THIS_ LPDIRECT3DLIGHT*,LPUNKNOWN) PURE; + STDMETHOD(CreateMaterial)(THIS_ LPDIRECT3DMATERIAL3*,LPUNKNOWN) PURE; + STDMETHOD(CreateViewport)(THIS_ LPDIRECT3DVIEWPORT3*,LPUNKNOWN) PURE; + STDMETHOD(FindDevice)(THIS_ LPD3DFINDDEVICESEARCH,LPD3DFINDDEVICERESULT) PURE; + STDMETHOD(CreateDevice)(THIS_ REFCLSID,LPDIRECTDRAWSURFACE4,LPDIRECT3DDEVICE3*,LPUNKNOWN) PURE; + STDMETHOD(CreateVertexBuffer)(THIS_ LPD3DVERTEXBUFFERDESC,LPDIRECT3DVERTEXBUFFER*,DWORD,LPUNKNOWN) PURE; + STDMETHOD(EnumZBufferFormats)(THIS_ REFCLSID,LPD3DENUMPIXELFORMATSCALLBACK,LPVOID) PURE; + STDMETHOD(EvictManagedTextures)(THIS) PURE; +}; + +typedef struct IDirect3D3 *LPDIRECT3D3; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirect3D3_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3D3_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3D3_Release(p) (p)->lpVtbl->Release(p) +#define IDirect3D3_EnumDevices(p,a,b) (p)->lpVtbl->EnumDevices(p,a,b) +#define IDirect3D3_CreateLight(p,a,b) (p)->lpVtbl->CreateLight(p,a,b) +#define IDirect3D3_CreateMaterial(p,a,b) (p)->lpVtbl->CreateMaterial(p,a,b) +#define IDirect3D3_CreateViewport(p,a,b) (p)->lpVtbl->CreateViewport(p,a,b) +#define IDirect3D3_FindDevice(p,a,b) (p)->lpVtbl->FindDevice(p,a,b) +#define IDirect3D3_CreateDevice(p,a,b,c,d) (p)->lpVtbl->CreateDevice(p,a,b,c,d) +#define IDirect3D3_CreateVertexBuffer(p,a,b,c,d) (p)->lpVtbl->CreateVertexBuffer(p,a,b,c,d) +#define IDirect3D3_EnumZBufferFormats(p,a,b,c) (p)->lpVtbl->EnumZBufferFormats(p,a,b,c) +#define IDirect3D3_EvictManagedTextures(p) (p)->lpVtbl->EvictManagedTextures(p) +#else +#define IDirect3D3_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3D3_AddRef(p) (p)->AddRef() +#define IDirect3D3_Release(p) (p)->Release() +#define IDirect3D3_EnumDevices(p,a,b) (p)->EnumDevices(a,b) +#define IDirect3D3_CreateLight(p,a,b) (p)->CreateLight(a,b) +#define IDirect3D3_CreateMaterial(p,a,b) (p)->CreateMaterial(a,b) +#define IDirect3D3_CreateViewport(p,a,b) (p)->CreateViewport(a,b) +#define IDirect3D3_FindDevice(p,a,b) (p)->FindDevice(a,b) +#define IDirect3D3_CreateDevice(p,a,b,c,d) (p)->CreateDevice(a,b,c,d) +#define IDirect3D3_CreateVertexBuffer(p,a,b,c,d) (p)->CreateVertexBuffer(a,b,c,d) +#define IDirect3D3_EnumZBufferFormats(p,a,b,c) (p)->EnumZBufferFormats(a,b,c) +#define IDirect3D3_EvictManagedTextures(p) (p)->EvictManagedTextures() +#endif +#endif /* DIRECT3D_VERSION >= 0x0600 */ + +#if(DIRECT3D_VERSION >= 0x0700) +#undef INTERFACE +#define INTERFACE IDirect3D7 + +DECLARE_INTERFACE_(IDirect3D7, IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + + /*** IDirect3D7 methods ***/ + STDMETHOD(EnumDevices)(THIS_ LPD3DENUMDEVICESCALLBACK7,LPVOID) PURE; + STDMETHOD(CreateDevice)(THIS_ REFCLSID,LPDIRECTDRAWSURFACE7,LPDIRECT3DDEVICE7*) PURE; + STDMETHOD(CreateVertexBuffer)(THIS_ LPD3DVERTEXBUFFERDESC,LPDIRECT3DVERTEXBUFFER7*,DWORD) PURE; + STDMETHOD(EnumZBufferFormats)(THIS_ REFCLSID,LPD3DENUMPIXELFORMATSCALLBACK,LPVOID) PURE; + STDMETHOD(EvictManagedTextures)(THIS) PURE; +}; + +typedef struct IDirect3D7 *LPDIRECT3D7; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirect3D7_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3D7_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3D7_Release(p) (p)->lpVtbl->Release(p) +#define IDirect3D7_EnumDevices(p,a,b) (p)->lpVtbl->EnumDevices(p,a,b) +#define IDirect3D7_CreateDevice(p,a,b,c) (p)->lpVtbl->CreateDevice(p,a,b,c) +#define IDirect3D7_CreateVertexBuffer(p,a,b,c) (p)->lpVtbl->CreateVertexBuffer(p,a,b,c) +#define IDirect3D7_EnumZBufferFormats(p,a,b,c) (p)->lpVtbl->EnumZBufferFormats(p,a,b,c) +#define IDirect3D7_EvictManagedTextures(p) (p)->lpVtbl->EvictManagedTextures(p) +#else +#define IDirect3D7_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3D7_AddRef(p) (p)->AddRef() +#define IDirect3D7_Release(p) (p)->Release() +#define IDirect3D7_EnumDevices(p,a,b) (p)->EnumDevices(a,b) +#define IDirect3D7_CreateDevice(p,a,b,c) (p)->CreateDevice(a,b,c) +#define IDirect3D7_CreateVertexBuffer(p,a,b,c) (p)->CreateVertexBuffer(a,b,c) +#define IDirect3D7_EnumZBufferFormats(p,a,b,c) (p)->EnumZBufferFormats(a,b,c) +#define IDirect3D7_EvictManagedTextures(p) (p)->EvictManagedTextures() +#endif +#endif /* DIRECT3D_VERSION >= 0x0700 */ +/* + * Direct3D Device interfaces + */ +#undef INTERFACE +#define INTERFACE IDirect3DDevice + +DECLARE_INTERFACE_(IDirect3DDevice, IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + + /*** IDirect3DDevice methods ***/ + STDMETHOD(Initialize)(THIS_ LPDIRECT3D,LPGUID,LPD3DDEVICEDESC) PURE; + STDMETHOD(GetCaps)(THIS_ LPD3DDEVICEDESC,LPD3DDEVICEDESC) PURE; + STDMETHOD(SwapTextureHandles)(THIS_ LPDIRECT3DTEXTURE,LPDIRECT3DTEXTURE) PURE; + STDMETHOD(CreateExecuteBuffer)(THIS_ LPD3DEXECUTEBUFFERDESC,LPDIRECT3DEXECUTEBUFFER*,IUnknown*) PURE; + STDMETHOD(GetStats)(THIS_ LPD3DSTATS) PURE; + STDMETHOD(Execute)(THIS_ LPDIRECT3DEXECUTEBUFFER,LPDIRECT3DVIEWPORT,DWORD) PURE; + STDMETHOD(AddViewport)(THIS_ LPDIRECT3DVIEWPORT) PURE; + STDMETHOD(DeleteViewport)(THIS_ LPDIRECT3DVIEWPORT) PURE; + STDMETHOD(NextViewport)(THIS_ LPDIRECT3DVIEWPORT,LPDIRECT3DVIEWPORT*,DWORD) PURE; + STDMETHOD(Pick)(THIS_ LPDIRECT3DEXECUTEBUFFER,LPDIRECT3DVIEWPORT,DWORD,LPD3DRECT) PURE; + STDMETHOD(GetPickRecords)(THIS_ LPDWORD,LPD3DPICKRECORD) PURE; + STDMETHOD(EnumTextureFormats)(THIS_ LPD3DENUMTEXTUREFORMATSCALLBACK,LPVOID) PURE; + STDMETHOD(CreateMatrix)(THIS_ LPD3DMATRIXHANDLE) PURE; + STDMETHOD(SetMatrix)(THIS_ D3DMATRIXHANDLE,const LPD3DMATRIX) PURE; + STDMETHOD(GetMatrix)(THIS_ D3DMATRIXHANDLE,LPD3DMATRIX) PURE; + STDMETHOD(DeleteMatrix)(THIS_ D3DMATRIXHANDLE) PURE; + STDMETHOD(BeginScene)(THIS) PURE; + STDMETHOD(EndScene)(THIS) PURE; + STDMETHOD(GetDirect3D)(THIS_ LPDIRECT3D*) PURE; +}; + +typedef struct IDirect3DDevice *LPDIRECT3DDEVICE; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirect3DDevice_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DDevice_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DDevice_Release(p) (p)->lpVtbl->Release(p) +#define IDirect3DDevice_Initialize(p,a,b,c) (p)->lpVtbl->Initialize(p,a,b,c) +#define IDirect3DDevice_GetCaps(p,a,b) (p)->lpVtbl->GetCaps(p,a,b) +#define IDirect3DDevice_SwapTextureHandles(p,a,b) (p)->lpVtbl->SwapTextureHandles(p,a,b) +#define IDirect3DDevice_CreateExecuteBuffer(p,a,b,c) (p)->lpVtbl->CreateExecuteBuffer(p,a,b,c) +#define IDirect3DDevice_GetStats(p,a) (p)->lpVtbl->GetStats(p,a) +#define IDirect3DDevice_Execute(p,a,b,c) (p)->lpVtbl->Execute(p,a,b,c) +#define IDirect3DDevice_AddViewport(p,a) (p)->lpVtbl->AddViewport(p,a) +#define IDirect3DDevice_DeleteViewport(p,a) (p)->lpVtbl->DeleteViewport(p,a) +#define IDirect3DDevice_NextViewport(p,a,b,c) (p)->lpVtbl->NextViewport(p,a,b,c) +#define IDirect3DDevice_Pick(p,a,b,c,d) (p)->lpVtbl->Pick(p,a,b,c,d) +#define IDirect3DDevice_GetPickRecords(p,a,b) (p)->lpVtbl->GetPickRecords(p,a,b) +#define IDirect3DDevice_EnumTextureFormats(p,a,b) (p)->lpVtbl->EnumTextureFormats(p,a,b) +#define IDirect3DDevice_CreateMatrix(p,a) (p)->lpVtbl->CreateMatrix(p,a) +#define IDirect3DDevice_SetMatrix(p,a,b) (p)->lpVtbl->SetMatrix(p,a,b) +#define IDirect3DDevice_GetMatrix(p,a,b) (p)->lpVtbl->GetMatrix(p,a,b) +#define IDirect3DDevice_DeleteMatrix(p,a) (p)->lpVtbl->DeleteMatrix(p,a) +#define IDirect3DDevice_BeginScene(p) (p)->lpVtbl->BeginScene(p) +#define IDirect3DDevice_EndScene(p) (p)->lpVtbl->EndScene(p) +#define IDirect3DDevice_GetDirect3D(p,a) (p)->lpVtbl->GetDirect3D(p,a) +#else +#define IDirect3DDevice_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DDevice_AddRef(p) (p)->AddRef() +#define IDirect3DDevice_Release(p) (p)->Release() +#define IDirect3DDevice_Initialize(p,a,b,c) (p)->Initialize(a,b,c) +#define IDirect3DDevice_GetCaps(p,a,b) (p)->GetCaps(a,b) +#define IDirect3DDevice_SwapTextureHandles(p,a,b) (p)->SwapTextureHandles(a,b) +#define IDirect3DDevice_CreateExecuteBuffer(p,a,b,c) (p)->CreateExecuteBuffer(a,b,c) +#define IDirect3DDevice_GetStats(p,a) (p)->GetStats(a) +#define IDirect3DDevice_Execute(p,a,b,c) (p)->Execute(a,b,c) +#define IDirect3DDevice_AddViewport(p,a) (p)->AddViewport(a) +#define IDirect3DDevice_DeleteViewport(p,a) (p)->DeleteViewport(a) +#define IDirect3DDevice_NextViewport(p,a,b,c) (p)->NextViewport(a,b,c) +#define IDirect3DDevice_Pick(p,a,b,c,d) (p)->Pick(a,b,c,d) +#define IDirect3DDevice_GetPickRecords(p,a,b) (p)->GetPickRecords(a,b) +#define IDirect3DDevice_EnumTextureFormats(p,a,b) (p)->EnumTextureFormats(a,b) +#define IDirect3DDevice_CreateMatrix(p,a) (p)->CreateMatrix(a) +#define IDirect3DDevice_SetMatrix(p,a,b) (p)->SetMatrix(a,b) +#define IDirect3DDevice_GetMatrix(p,a,b) (p)->GetMatrix(a,b) +#define IDirect3DDevice_DeleteMatrix(p,a) (p)->DeleteMatrix(a) +#define IDirect3DDevice_BeginScene(p) (p)->BeginScene() +#define IDirect3DDevice_EndScene(p) (p)->EndScene() +#define IDirect3DDevice_GetDirect3D(p,a) (p)->GetDirect3D(a) +#endif + +#if(DIRECT3D_VERSION >= 0x0500) +#undef INTERFACE +#define INTERFACE IDirect3DDevice2 + +DECLARE_INTERFACE_(IDirect3DDevice2, IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + + /*** IDirect3DDevice2 methods ***/ + STDMETHOD(GetCaps)(THIS_ LPD3DDEVICEDESC,LPD3DDEVICEDESC) PURE; + STDMETHOD(SwapTextureHandles)(THIS_ LPDIRECT3DTEXTURE2,LPDIRECT3DTEXTURE2) PURE; + STDMETHOD(GetStats)(THIS_ LPD3DSTATS) PURE; + STDMETHOD(AddViewport)(THIS_ LPDIRECT3DVIEWPORT2) PURE; + STDMETHOD(DeleteViewport)(THIS_ LPDIRECT3DVIEWPORT2) PURE; + STDMETHOD(NextViewport)(THIS_ LPDIRECT3DVIEWPORT2,LPDIRECT3DVIEWPORT2*,DWORD) PURE; + STDMETHOD(EnumTextureFormats)(THIS_ LPD3DENUMTEXTUREFORMATSCALLBACK,LPVOID) PURE; + STDMETHOD(BeginScene)(THIS) PURE; + STDMETHOD(EndScene)(THIS) PURE; + STDMETHOD(GetDirect3D)(THIS_ LPDIRECT3D2*) PURE; + STDMETHOD(SetCurrentViewport)(THIS_ LPDIRECT3DVIEWPORT2) PURE; + STDMETHOD(GetCurrentViewport)(THIS_ LPDIRECT3DVIEWPORT2 *) PURE; + STDMETHOD(SetRenderTarget)(THIS_ LPDIRECTDRAWSURFACE,DWORD) PURE; + STDMETHOD(GetRenderTarget)(THIS_ LPDIRECTDRAWSURFACE *) PURE; + STDMETHOD(Begin)(THIS_ D3DPRIMITIVETYPE,D3DVERTEXTYPE,DWORD) PURE; + STDMETHOD(BeginIndexed)(THIS_ D3DPRIMITIVETYPE,D3DVERTEXTYPE,LPVOID,DWORD,DWORD) PURE; + STDMETHOD(Vertex)(THIS_ LPVOID) PURE; + STDMETHOD(Index)(THIS_ WORD) PURE; + STDMETHOD(End)(THIS_ DWORD) PURE; + STDMETHOD(GetRenderState)(THIS_ D3DRENDERSTATETYPE,LPDWORD) PURE; + STDMETHOD(SetRenderState)(THIS_ D3DRENDERSTATETYPE,DWORD) PURE; + STDMETHOD(GetLightState)(THIS_ D3DLIGHTSTATETYPE,LPDWORD) PURE; + STDMETHOD(SetLightState)(THIS_ D3DLIGHTSTATETYPE,DWORD) PURE; + STDMETHOD(SetTransform)(THIS_ D3DTRANSFORMSTATETYPE,LPD3DMATRIX) PURE; + STDMETHOD(GetTransform)(THIS_ D3DTRANSFORMSTATETYPE,LPD3DMATRIX) PURE; + STDMETHOD(MultiplyTransform)(THIS_ D3DTRANSFORMSTATETYPE,LPD3DMATRIX) PURE; + STDMETHOD(DrawPrimitive)(THIS_ D3DPRIMITIVETYPE,D3DVERTEXTYPE,LPVOID,DWORD,DWORD) PURE; + STDMETHOD(DrawIndexedPrimitive)(THIS_ D3DPRIMITIVETYPE,D3DVERTEXTYPE,LPVOID,DWORD,LPWORD,DWORD,DWORD) PURE; + STDMETHOD(SetClipStatus)(THIS_ LPD3DCLIPSTATUS) PURE; + STDMETHOD(GetClipStatus)(THIS_ LPD3DCLIPSTATUS) PURE; +}; + +typedef struct IDirect3DDevice2 *LPDIRECT3DDEVICE2; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirect3DDevice2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DDevice2_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DDevice2_Release(p) (p)->lpVtbl->Release(p) +#define IDirect3DDevice2_GetCaps(p,a,b) (p)->lpVtbl->GetCaps(p,a,b) +#define IDirect3DDevice2_SwapTextureHandles(p,a,b) (p)->lpVtbl->SwapTextureHandles(p,a,b) +#define IDirect3DDevice2_GetStats(p,a) (p)->lpVtbl->GetStats(p,a) +#define IDirect3DDevice2_AddViewport(p,a) (p)->lpVtbl->AddViewport(p,a) +#define IDirect3DDevice2_DeleteViewport(p,a) (p)->lpVtbl->DeleteViewport(p,a) +#define IDirect3DDevice2_NextViewport(p,a,b,c) (p)->lpVtbl->NextViewport(p,a,b,c) +#define IDirect3DDevice2_EnumTextureFormats(p,a,b) (p)->lpVtbl->EnumTextureFormats(p,a,b) +#define IDirect3DDevice2_BeginScene(p) (p)->lpVtbl->BeginScene(p) +#define IDirect3DDevice2_EndScene(p) (p)->lpVtbl->EndScene(p) +#define IDirect3DDevice2_GetDirect3D(p,a) (p)->lpVtbl->GetDirect3D(p,a) +#define IDirect3DDevice2_SetCurrentViewport(p,a) (p)->lpVtbl->SetCurrentViewport(p,a) +#define IDirect3DDevice2_GetCurrentViewport(p,a) (p)->lpVtbl->GetCurrentViewport(p,a) +#define IDirect3DDevice2_SetRenderTarget(p,a,b) (p)->lpVtbl->SetRenderTarget(p,a,b) +#define IDirect3DDevice2_GetRenderTarget(p,a) (p)->lpVtbl->GetRenderTarget(p,a) +#define IDirect3DDevice2_Begin(p,a,b,c) (p)->lpVtbl->Begin(p,a,b,c) +#define IDirect3DDevice2_BeginIndexed(p,a,b,c,d,e) (p)->lpVtbl->BeginIndexed(p,a,b,c,d,e) +#define IDirect3DDevice2_Vertex(p,a) (p)->lpVtbl->Vertex(p,a) +#define IDirect3DDevice2_Index(p,a) (p)->lpVtbl->Index(p,a) +#define IDirect3DDevice2_End(p,a) (p)->lpVtbl->End(p,a) +#define IDirect3DDevice2_GetRenderState(p,a,b) (p)->lpVtbl->GetRenderState(p,a,b) +#define IDirect3DDevice2_SetRenderState(p,a,b) (p)->lpVtbl->SetRenderState(p,a,b) +#define IDirect3DDevice2_GetLightState(p,a,b) (p)->lpVtbl->GetLightState(p,a,b) +#define IDirect3DDevice2_SetLightState(p,a,b) (p)->lpVtbl->SetLightState(p,a,b) +#define IDirect3DDevice2_SetTransform(p,a,b) (p)->lpVtbl->SetTransform(p,a,b) +#define IDirect3DDevice2_GetTransform(p,a,b) (p)->lpVtbl->GetTransform(p,a,b) +#define IDirect3DDevice2_MultiplyTransform(p,a,b) (p)->lpVtbl->MultiplyTransform(p,a,b) +#define IDirect3DDevice2_DrawPrimitive(p,a,b,c,d,e) (p)->lpVtbl->DrawPrimitive(p,a,b,c,d,e) +#define IDirect3DDevice2_DrawIndexedPrimitive(p,a,b,c,d,e,f,g) (p)->lpVtbl->DrawIndexedPrimitive(p,a,b,c,d,e,f,g) +#define IDirect3DDevice2_SetClipStatus(p,a) (p)->lpVtbl->SetClipStatus(p,a) +#define IDirect3DDevice2_GetClipStatus(p,a) (p)->lpVtbl->GetClipStatus(p,a) +#else +#define IDirect3DDevice2_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DDevice2_AddRef(p) (p)->AddRef() +#define IDirect3DDevice2_Release(p) (p)->Release() +#define IDirect3DDevice2_GetCaps(p,a,b) (p)->GetCaps(a,b) +#define IDirect3DDevice2_SwapTextureHandles(p,a,b) (p)->SwapTextureHandles(a,b) +#define IDirect3DDevice2_GetStats(p,a) (p)->GetStats(a) +#define IDirect3DDevice2_AddViewport(p,a) (p)->AddViewport(a) +#define IDirect3DDevice2_DeleteViewport(p,a) (p)->DeleteViewport(a) +#define IDirect3DDevice2_NextViewport(p,a,b,c) (p)->NextViewport(a,b,c) +#define IDirect3DDevice2_EnumTextureFormats(p,a,b) (p)->EnumTextureFormats(a,b) +#define IDirect3DDevice2_BeginScene(p) (p)->BeginScene() +#define IDirect3DDevice2_EndScene(p) (p)->EndScene() +#define IDirect3DDevice2_GetDirect3D(p,a) (p)->GetDirect3D(a) +#define IDirect3DDevice2_SetCurrentViewport(p,a) (p)->SetCurrentViewport(a) +#define IDirect3DDevice2_GetCurrentViewport(p,a) (p)->GetCurrentViewport(a) +#define IDirect3DDevice2_SetRenderTarget(p,a,b) (p)->SetRenderTarget(a,b) +#define IDirect3DDevice2_GetRenderTarget(p,a) (p)->GetRenderTarget(a) +#define IDirect3DDevice2_Begin(p,a,b,c) (p)->Begin(a,b,c) +#define IDirect3DDevice2_BeginIndexed(p,a,b,c,d,e) (p)->BeginIndexed(a,b,c,d,e) +#define IDirect3DDevice2_Vertex(p,a) (p)->Vertex(a) +#define IDirect3DDevice2_Index(p,a) (p)->Index(a) +#define IDirect3DDevice2_End(p,a) (p)->End(a) +#define IDirect3DDevice2_GetRenderState(p,a,b) (p)->GetRenderState(a,b) +#define IDirect3DDevice2_SetRenderState(p,a,b) (p)->SetRenderState(a,b) +#define IDirect3DDevice2_GetLightState(p,a,b) (p)->GetLightState(a,b) +#define IDirect3DDevice2_SetLightState(p,a,b) (p)->SetLightState(a,b) +#define IDirect3DDevice2_SetTransform(p,a,b) (p)->SetTransform(a,b) +#define IDirect3DDevice2_GetTransform(p,a,b) (p)->GetTransform(a,b) +#define IDirect3DDevice2_MultiplyTransform(p,a,b) (p)->MultiplyTransform(a,b) +#define IDirect3DDevice2_DrawPrimitive(p,a,b,c,d,e) (p)->DrawPrimitive(a,b,c,d,e) +#define IDirect3DDevice2_DrawIndexedPrimitive(p,a,b,c,d,e,f,g) (p)->DrawIndexedPrimitive(a,b,c,d,e,f,g) +#define IDirect3DDevice2_SetClipStatus(p,a) (p)->SetClipStatus(a) +#define IDirect3DDevice2_GetClipStatus(p,a) (p)->GetClipStatus(a) +#endif +#endif /* DIRECT3D_VERSION >= 0x0500 */ + +#if(DIRECT3D_VERSION >= 0x0600) +#undef INTERFACE +#define INTERFACE IDirect3DDevice3 + +DECLARE_INTERFACE_(IDirect3DDevice3, IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + + /*** IDirect3DDevice3 methods ***/ + STDMETHOD(GetCaps)(THIS_ LPD3DDEVICEDESC,LPD3DDEVICEDESC) PURE; + STDMETHOD(GetStats)(THIS_ LPD3DSTATS) PURE; + STDMETHOD(AddViewport)(THIS_ LPDIRECT3DVIEWPORT3) PURE; + STDMETHOD(DeleteViewport)(THIS_ LPDIRECT3DVIEWPORT3) PURE; + STDMETHOD(NextViewport)(THIS_ LPDIRECT3DVIEWPORT3,LPDIRECT3DVIEWPORT3*,DWORD) PURE; + STDMETHOD(EnumTextureFormats)(THIS_ LPD3DENUMPIXELFORMATSCALLBACK,LPVOID) PURE; + STDMETHOD(BeginScene)(THIS) PURE; + STDMETHOD(EndScene)(THIS) PURE; + STDMETHOD(GetDirect3D)(THIS_ LPDIRECT3D3*) PURE; + STDMETHOD(SetCurrentViewport)(THIS_ LPDIRECT3DVIEWPORT3) PURE; + STDMETHOD(GetCurrentViewport)(THIS_ LPDIRECT3DVIEWPORT3 *) PURE; + STDMETHOD(SetRenderTarget)(THIS_ LPDIRECTDRAWSURFACE4,DWORD) PURE; + STDMETHOD(GetRenderTarget)(THIS_ LPDIRECTDRAWSURFACE4 *) PURE; + STDMETHOD(Begin)(THIS_ D3DPRIMITIVETYPE,DWORD,DWORD) PURE; + STDMETHOD(BeginIndexed)(THIS_ D3DPRIMITIVETYPE,DWORD,LPVOID,DWORD,DWORD) PURE; + STDMETHOD(Vertex)(THIS_ LPVOID) PURE; + STDMETHOD(Index)(THIS_ WORD) PURE; + STDMETHOD(End)(THIS_ DWORD) PURE; + STDMETHOD(GetRenderState)(THIS_ D3DRENDERSTATETYPE,LPDWORD) PURE; + STDMETHOD(SetRenderState)(THIS_ D3DRENDERSTATETYPE,DWORD) PURE; + STDMETHOD(GetLightState)(THIS_ D3DLIGHTSTATETYPE,LPDWORD) PURE; + STDMETHOD(SetLightState)(THIS_ D3DLIGHTSTATETYPE,DWORD) PURE; + STDMETHOD(SetTransform)(THIS_ D3DTRANSFORMSTATETYPE,LPD3DMATRIX) PURE; + STDMETHOD(GetTransform)(THIS_ D3DTRANSFORMSTATETYPE,LPD3DMATRIX) PURE; + STDMETHOD(MultiplyTransform)(THIS_ D3DTRANSFORMSTATETYPE,LPD3DMATRIX) PURE; + STDMETHOD(DrawPrimitive)(THIS_ D3DPRIMITIVETYPE,DWORD,LPVOID,DWORD,DWORD) PURE; + STDMETHOD(DrawIndexedPrimitive)(THIS_ D3DPRIMITIVETYPE,DWORD,LPVOID,DWORD,LPWORD,DWORD,DWORD) PURE; + STDMETHOD(SetClipStatus)(THIS_ LPD3DCLIPSTATUS) PURE; + STDMETHOD(GetClipStatus)(THIS_ LPD3DCLIPSTATUS) PURE; + STDMETHOD(DrawPrimitiveStrided)(THIS_ D3DPRIMITIVETYPE,DWORD,LPD3DDRAWPRIMITIVESTRIDEDDATA,DWORD,DWORD) PURE; + STDMETHOD(DrawIndexedPrimitiveStrided)(THIS_ D3DPRIMITIVETYPE,DWORD,LPD3DDRAWPRIMITIVESTRIDEDDATA,DWORD,LPWORD,DWORD,DWORD) PURE; + STDMETHOD(DrawPrimitiveVB)(THIS_ D3DPRIMITIVETYPE,LPDIRECT3DVERTEXBUFFER,DWORD,DWORD,DWORD) PURE; + STDMETHOD(DrawIndexedPrimitiveVB)(THIS_ D3DPRIMITIVETYPE,LPDIRECT3DVERTEXBUFFER,LPWORD,DWORD,DWORD) PURE; + STDMETHOD(ComputeSphereVisibility)(THIS_ LPD3DVECTOR,LPD3DVALUE,DWORD,DWORD,LPDWORD) PURE; + STDMETHOD(GetTexture)(THIS_ DWORD,LPDIRECT3DTEXTURE2 *) PURE; + STDMETHOD(SetTexture)(THIS_ DWORD,LPDIRECT3DTEXTURE2) PURE; + STDMETHOD(GetTextureStageState)(THIS_ DWORD,D3DTEXTURESTAGESTATETYPE,LPDWORD) PURE; + STDMETHOD(SetTextureStageState)(THIS_ DWORD,D3DTEXTURESTAGESTATETYPE,DWORD) PURE; + STDMETHOD(ValidateDevice)(THIS_ LPDWORD) PURE; +}; + +typedef struct IDirect3DDevice3 *LPDIRECT3DDEVICE3; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirect3DDevice3_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DDevice3_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DDevice3_Release(p) (p)->lpVtbl->Release(p) +#define IDirect3DDevice3_GetCaps(p,a,b) (p)->lpVtbl->GetCaps(p,a,b) +#define IDirect3DDevice3_GetStats(p,a) (p)->lpVtbl->GetStats(p,a) +#define IDirect3DDevice3_AddViewport(p,a) (p)->lpVtbl->AddViewport(p,a) +#define IDirect3DDevice3_DeleteViewport(p,a) (p)->lpVtbl->DeleteViewport(p,a) +#define IDirect3DDevice3_NextViewport(p,a,b,c) (p)->lpVtbl->NextViewport(p,a,b,c) +#define IDirect3DDevice3_EnumTextureFormats(p,a,b) (p)->lpVtbl->EnumTextureFormats(p,a,b) +#define IDirect3DDevice3_BeginScene(p) (p)->lpVtbl->BeginScene(p) +#define IDirect3DDevice3_EndScene(p) (p)->lpVtbl->EndScene(p) +#define IDirect3DDevice3_GetDirect3D(p,a) (p)->lpVtbl->GetDirect3D(p,a) +#define IDirect3DDevice3_SetCurrentViewport(p,a) (p)->lpVtbl->SetCurrentViewport(p,a) +#define IDirect3DDevice3_GetCurrentViewport(p,a) (p)->lpVtbl->GetCurrentViewport(p,a) +#define IDirect3DDevice3_SetRenderTarget(p,a,b) (p)->lpVtbl->SetRenderTarget(p,a,b) +#define IDirect3DDevice3_GetRenderTarget(p,a) (p)->lpVtbl->GetRenderTarget(p,a) +#define IDirect3DDevice3_Begin(p,a,b,c) (p)->lpVtbl->Begin(p,a,b,c) +#define IDirect3DDevice3_BeginIndexed(p,a,b,c,d,e) (p)->lpVtbl->BeginIndexed(p,a,b,c,d,e) +#define IDirect3DDevice3_Vertex(p,a) (p)->lpVtbl->Vertex(p,a) +#define IDirect3DDevice3_Index(p,a) (p)->lpVtbl->Index(p,a) +#define IDirect3DDevice3_End(p,a) (p)->lpVtbl->End(p,a) +#define IDirect3DDevice3_GetRenderState(p,a,b) (p)->lpVtbl->GetRenderState(p,a,b) +#define IDirect3DDevice3_SetRenderState(p,a,b) (p)->lpVtbl->SetRenderState(p,a,b) +#define IDirect3DDevice3_GetLightState(p,a,b) (p)->lpVtbl->GetLightState(p,a,b) +#define IDirect3DDevice3_SetLightState(p,a,b) (p)->lpVtbl->SetLightState(p,a,b) +#define IDirect3DDevice3_SetTransform(p,a,b) (p)->lpVtbl->SetTransform(p,a,b) +#define IDirect3DDevice3_GetTransform(p,a,b) (p)->lpVtbl->GetTransform(p,a,b) +#define IDirect3DDevice3_MultiplyTransform(p,a,b) (p)->lpVtbl->MultiplyTransform(p,a,b) +#define IDirect3DDevice3_DrawPrimitive(p,a,b,c,d,e) (p)->lpVtbl->DrawPrimitive(p,a,b,c,d,e) +#define IDirect3DDevice3_DrawIndexedPrimitive(p,a,b,c,d,e,f,g) (p)->lpVtbl->DrawIndexedPrimitive(p,a,b,c,d,e,f,g) +#define IDirect3DDevice3_SetClipStatus(p,a) (p)->lpVtbl->SetClipStatus(p,a) +#define IDirect3DDevice3_GetClipStatus(p,a) (p)->lpVtbl->GetClipStatus(p,a) +#define IDirect3DDevice3_DrawPrimitiveStrided(p,a,b,c,d,e) (p)->lpVtbl->DrawPrimitiveStrided(p,a,b,c,d,e) +#define IDirect3DDevice3_DrawIndexedPrimitiveStrided(p,a,b,c,d,e,f,g) (p)->lpVtbl->DrawIndexedPrimitiveStrided(p,a,b,c,d,e,f,g) +#define IDirect3DDevice3_DrawPrimitiveVB(p,a,b,c,d,e) (p)->lpVtbl->DrawPrimitiveVB(p,a,b,c,d,e) +#define IDirect3DDevice3_DrawIndexedPrimitiveVB(p,a,b,c,d,e) (p)->lpVtbl->DrawIndexedPrimitiveVB(p,a,b,c,d,e) +#define IDirect3DDevice3_ComputeSphereVisibility(p,a,b,c,d,e) (p)->lpVtbl->ComputeSphereVisibility(p,a,b,c,d,e) +#define IDirect3DDevice3_GetTexture(p,a,b) (p)->lpVtbl->GetTexture(p,a,b) +#define IDirect3DDevice3_SetTexture(p,a,b) (p)->lpVtbl->SetTexture(p,a,b) +#define IDirect3DDevice3_GetTextureStageState(p,a,b,c) (p)->lpVtbl->GetTextureStageState(p,a,b,c) +#define IDirect3DDevice3_SetTextureStageState(p,a,b,c) (p)->lpVtbl->SetTextureStageState(p,a,b,c) +#define IDirect3DDevice3_ValidateDevice(p,a) (p)->lpVtbl->ValidateDevice(p,a) +#else +#define IDirect3DDevice3_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DDevice3_AddRef(p) (p)->AddRef() +#define IDirect3DDevice3_Release(p) (p)->Release() +#define IDirect3DDevice3_GetCaps(p,a,b) (p)->GetCaps(a,b) +#define IDirect3DDevice3_GetStats(p,a) (p)->GetStats(a) +#define IDirect3DDevice3_AddViewport(p,a) (p)->AddViewport(a) +#define IDirect3DDevice3_DeleteViewport(p,a) (p)->DeleteViewport(a) +#define IDirect3DDevice3_NextViewport(p,a,b,c) (p)->NextViewport(a,b,c) +#define IDirect3DDevice3_EnumTextureFormats(p,a,b) (p)->EnumTextureFormats(a,b) +#define IDirect3DDevice3_BeginScene(p) (p)->BeginScene() +#define IDirect3DDevice3_EndScene(p) (p)->EndScene() +#define IDirect3DDevice3_GetDirect3D(p,a) (p)->GetDirect3D(a) +#define IDirect3DDevice3_SetCurrentViewport(p,a) (p)->SetCurrentViewport(a) +#define IDirect3DDevice3_GetCurrentViewport(p,a) (p)->GetCurrentViewport(a) +#define IDirect3DDevice3_SetRenderTarget(p,a,b) (p)->SetRenderTarget(a,b) +#define IDirect3DDevice3_GetRenderTarget(p,a) (p)->GetRenderTarget(a) +#define IDirect3DDevice3_Begin(p,a,b,c) (p)->Begin(a,b,c) +#define IDirect3DDevice3_BeginIndexed(p,a,b,c,d,e) (p)->BeginIndexed(a,b,c,d,e) +#define IDirect3DDevice3_Vertex(p,a) (p)->Vertex(a) +#define IDirect3DDevice3_Index(p,a) (p)->Index(a) +#define IDirect3DDevice3_End(p,a) (p)->End(a) +#define IDirect3DDevice3_GetRenderState(p,a,b) (p)->GetRenderState(a,b) +#define IDirect3DDevice3_SetRenderState(p,a,b) (p)->SetRenderState(a,b) +#define IDirect3DDevice3_GetLightState(p,a,b) (p)->GetLightState(a,b) +#define IDirect3DDevice3_SetLightState(p,a,b) (p)->SetLightState(a,b) +#define IDirect3DDevice3_SetTransform(p,a,b) (p)->SetTransform(a,b) +#define IDirect3DDevice3_GetTransform(p,a,b) (p)->GetTransform(a,b) +#define IDirect3DDevice3_MultiplyTransform(p,a,b) (p)->MultiplyTransform(a,b) +#define IDirect3DDevice3_DrawPrimitive(p,a,b,c,d,e) (p)->DrawPrimitive(a,b,c,d,e) +#define IDirect3DDevice3_DrawIndexedPrimitive(p,a,b,c,d,e,f,g) (p)->DrawIndexedPrimitive(a,b,c,d,e,f,g) +#define IDirect3DDevice3_SetClipStatus(p,a) (p)->SetClipStatus(a) +#define IDirect3DDevice3_GetClipStatus(p,a) (p)->GetClipStatus(a) +#define IDirect3DDevice3_DrawPrimitiveStrided(p,a,b,c,d,e) (p)->DrawPrimitiveStrided(a,b,c,d,e) +#define IDirect3DDevice3_DrawIndexedPrimitiveStrided(p,a,b,c,d,e,f,g) (p)->DrawIndexedPrimitiveStrided(a,b,c,d,e,f,g) +#define IDirect3DDevice3_DrawPrimitiveVB(p,a,b,c,d,e) (p)->DrawPrimitiveVB(a,b,c,d,e) +#define IDirect3DDevice3_DrawIndexedPrimitiveVB(p,a,b,c,d,e) (p)->DrawIndexedPrimitiveVB(a,b,c,d,e) +#define IDirect3DDevice3_ComputeSphereVisibility(p,a,b,c,d,e) (p)->ComputeSphereVisibility(a,b,c,d,e) +#define IDirect3DDevice3_GetTexture(p,a,b) (p)->GetTexture(a,b) +#define IDirect3DDevice3_SetTexture(p,a,b) (p)->SetTexture(a,b) +#define IDirect3DDevice3_GetTextureStageState(p,a,b,c) (p)->GetTextureStageState(a,b,c) +#define IDirect3DDevice3_SetTextureStageState(p,a,b,c) (p)->SetTextureStageState(a,b,c) +#define IDirect3DDevice3_ValidateDevice(p,a) (p)->ValidateDevice(a) +#endif +#endif /* DIRECT3D_VERSION >= 0x0600 */ + +#if(DIRECT3D_VERSION >= 0x0700) +#undef INTERFACE +#define INTERFACE IDirect3DDevice7 + +DECLARE_INTERFACE_(IDirect3DDevice7, IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + + /*** IDirect3DDevice7 methods ***/ + STDMETHOD(GetCaps)(THIS_ LPD3DDEVICEDESC7) PURE; + STDMETHOD(EnumTextureFormats)(THIS_ LPD3DENUMPIXELFORMATSCALLBACK,LPVOID) PURE; + STDMETHOD(BeginScene)(THIS) PURE; + STDMETHOD(EndScene)(THIS) PURE; + STDMETHOD(GetDirect3D)(THIS_ LPDIRECT3D7*) PURE; + STDMETHOD(SetRenderTarget)(THIS_ LPDIRECTDRAWSURFACE7,DWORD) PURE; + STDMETHOD(GetRenderTarget)(THIS_ LPDIRECTDRAWSURFACE7 *) PURE; + STDMETHOD(Clear)(THIS_ DWORD,LPD3DRECT,DWORD,D3DCOLOR,D3DVALUE,DWORD) PURE; + STDMETHOD(SetTransform)(THIS_ D3DTRANSFORMSTATETYPE,LPD3DMATRIX) PURE; + STDMETHOD(GetTransform)(THIS_ D3DTRANSFORMSTATETYPE,LPD3DMATRIX) PURE; + STDMETHOD(SetViewport)(THIS_ LPD3DVIEWPORT7) PURE; + STDMETHOD(MultiplyTransform)(THIS_ D3DTRANSFORMSTATETYPE,LPD3DMATRIX) PURE; + STDMETHOD(GetViewport)(THIS_ LPD3DVIEWPORT7) PURE; + STDMETHOD(SetMaterial)(THIS_ LPD3DMATERIAL7) PURE; + STDMETHOD(GetMaterial)(THIS_ LPD3DMATERIAL7) PURE; + STDMETHOD(SetLight)(THIS_ DWORD,LPD3DLIGHT7) PURE; + STDMETHOD(GetLight)(THIS_ DWORD,LPD3DLIGHT7) PURE; + STDMETHOD(SetRenderState)(THIS_ D3DRENDERSTATETYPE,DWORD) PURE; + STDMETHOD(GetRenderState)(THIS_ D3DRENDERSTATETYPE,LPDWORD) PURE; + STDMETHOD(BeginStateBlock)(THIS) PURE; + STDMETHOD(EndStateBlock)(THIS_ LPDWORD) PURE; + STDMETHOD(PreLoad)(THIS_ LPDIRECTDRAWSURFACE7) PURE; + STDMETHOD(DrawPrimitive)(THIS_ D3DPRIMITIVETYPE,DWORD,LPVOID,DWORD,DWORD) PURE; + STDMETHOD(DrawIndexedPrimitive)(THIS_ D3DPRIMITIVETYPE,DWORD,LPVOID,DWORD,LPWORD,DWORD,DWORD) PURE; + STDMETHOD(SetClipStatus)(THIS_ LPD3DCLIPSTATUS) PURE; + STDMETHOD(GetClipStatus)(THIS_ LPD3DCLIPSTATUS) PURE; + STDMETHOD(DrawPrimitiveStrided)(THIS_ D3DPRIMITIVETYPE,DWORD,LPD3DDRAWPRIMITIVESTRIDEDDATA,DWORD,DWORD) PURE; + STDMETHOD(DrawIndexedPrimitiveStrided)(THIS_ D3DPRIMITIVETYPE,DWORD,LPD3DDRAWPRIMITIVESTRIDEDDATA,DWORD,LPWORD,DWORD,DWORD) PURE; + STDMETHOD(DrawPrimitiveVB)(THIS_ D3DPRIMITIVETYPE,LPDIRECT3DVERTEXBUFFER7,DWORD,DWORD,DWORD) PURE; + STDMETHOD(DrawIndexedPrimitiveVB)(THIS_ D3DPRIMITIVETYPE,LPDIRECT3DVERTEXBUFFER7,DWORD,DWORD,LPWORD,DWORD,DWORD) PURE; + STDMETHOD(ComputeSphereVisibility)(THIS_ LPD3DVECTOR,LPD3DVALUE,DWORD,DWORD,LPDWORD) PURE; + STDMETHOD(GetTexture)(THIS_ DWORD,LPDIRECTDRAWSURFACE7 *) PURE; + STDMETHOD(SetTexture)(THIS_ DWORD,LPDIRECTDRAWSURFACE7) PURE; + STDMETHOD(GetTextureStageState)(THIS_ DWORD,D3DTEXTURESTAGESTATETYPE,LPDWORD) PURE; + STDMETHOD(SetTextureStageState)(THIS_ DWORD,D3DTEXTURESTAGESTATETYPE,DWORD) PURE; + STDMETHOD(ValidateDevice)(THIS_ LPDWORD) PURE; + STDMETHOD(ApplyStateBlock)(THIS_ DWORD) PURE; + STDMETHOD(CaptureStateBlock)(THIS_ DWORD) PURE; + STDMETHOD(DeleteStateBlock)(THIS_ DWORD) PURE; + STDMETHOD(CreateStateBlock)(THIS_ D3DSTATEBLOCKTYPE,LPDWORD) PURE; + STDMETHOD(Load)(THIS_ LPDIRECTDRAWSURFACE7,LPPOINT,LPDIRECTDRAWSURFACE7,LPRECT,DWORD) PURE; + STDMETHOD(LightEnable)(THIS_ DWORD,BOOL) PURE; + STDMETHOD(GetLightEnable)(THIS_ DWORD,BOOL*) PURE; + STDMETHOD(SetClipPlane)(THIS_ DWORD,D3DVALUE*) PURE; + STDMETHOD(GetClipPlane)(THIS_ DWORD,D3DVALUE*) PURE; + STDMETHOD(GetInfo)(THIS_ DWORD,LPVOID,DWORD) PURE; +}; + +typedef struct IDirect3DDevice7 *LPDIRECT3DDEVICE7; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirect3DDevice7_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DDevice7_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DDevice7_Release(p) (p)->lpVtbl->Release(p) +#define IDirect3DDevice7_GetCaps(p,a) (p)->lpVtbl->GetCaps(p,a) +#define IDirect3DDevice7_EnumTextureFormats(p,a,b) (p)->lpVtbl->EnumTextureFormats(p,a,b) +#define IDirect3DDevice7_BeginScene(p) (p)->lpVtbl->BeginScene(p) +#define IDirect3DDevice7_EndScene(p) (p)->lpVtbl->EndScene(p) +#define IDirect3DDevice7_GetDirect3D(p,a) (p)->lpVtbl->GetDirect3D(p,a) +#define IDirect3DDevice7_SetRenderTarget(p,a,b) (p)->lpVtbl->SetRenderTarget(p,a,b) +#define IDirect3DDevice7_GetRenderTarget(p,a) (p)->lpVtbl->GetRenderTarget(p,a) +#define IDirect3DDevice7_Clear(p,a,b,c,d,e,f) (p)->lpVtbl->Clear(p,a,b,c,d,e,f) +#define IDirect3DDevice7_SetTransform(p,a,b) (p)->lpVtbl->SetTransform(p,a,b) +#define IDirect3DDevice7_GetTransform(p,a,b) (p)->lpVtbl->GetTransform(p,a,b) +#define IDirect3DDevice7_SetViewport(p,a) (p)->lpVtbl->SetViewport(p,a) +#define IDirect3DDevice7_MultiplyTransform(p,a,b) (p)->lpVtbl->MultiplyTransform(p,a,b) +#define IDirect3DDevice7_GetViewport(p,a) (p)->lpVtbl->GetViewport(p,a) +#define IDirect3DDevice7_SetMaterial(p,a) (p)->lpVtbl->SetMaterial(p,a) +#define IDirect3DDevice7_GetMaterial(p,a) (p)->lpVtbl->GetMaterial(p,a) +#define IDirect3DDevice7_SetLight(p,a,b) (p)->lpVtbl->SetLight(p,a,b) +#define IDirect3DDevice7_GetLight(p,a,b) (p)->lpVtbl->GetLight(p,a,b) +#define IDirect3DDevice7_SetRenderState(p,a,b) (p)->lpVtbl->SetRenderState(p,a,b) +#define IDirect3DDevice7_GetRenderState(p,a,b) (p)->lpVtbl->GetRenderState(p,a,b) +#define IDirect3DDevice7_BeginStateBlock(p) (p)->lpVtbl->BeginStateBlock(p) +#define IDirect3DDevice7_EndStateBlock(p,a) (p)->lpVtbl->EndStateBlock(p,a) +#define IDirect3DDevice7_PreLoad(p,a) (p)->lpVtbl->PreLoad(p,a) +#define IDirect3DDevice7_DrawPrimitive(p,a,b,c,d,e) (p)->lpVtbl->DrawPrimitive(p,a,b,c,d,e) +#define IDirect3DDevice7_DrawIndexedPrimitive(p,a,b,c,d,e,f,g) (p)->lpVtbl->DrawIndexedPrimitive(p,a,b,c,d,e,f,g) +#define IDirect3DDevice7_SetClipStatus(p,a) (p)->lpVtbl->SetClipStatus(p,a) +#define IDirect3DDevice7_GetClipStatus(p,a) (p)->lpVtbl->GetClipStatus(p,a) +#define IDirect3DDevice7_DrawPrimitiveStrided(p,a,b,c,d,e) (p)->lpVtbl->DrawPrimitiveStrided(p,a,b,c,d,e) +#define IDirect3DDevice7_DrawIndexedPrimitiveStrided(p,a,b,c,d,e,f,g) (p)->lpVtbl->DrawIndexedPrimitiveStrided(p,a,b,c,d,e,f,g) +#define IDirect3DDevice7_DrawPrimitiveVB(p,a,b,c,d,e) (p)->lpVtbl->DrawPrimitiveVB(p,a,b,c,d,e) +#define IDirect3DDevice7_DrawIndexedPrimitiveVB(p,a,b,c,d,e,f,g) (p)->lpVtbl->DrawIndexedPrimitiveVB(p,a,b,c,d,e,f,g) +#define IDirect3DDevice7_ComputeSphereVisibility(p,a,b,c,d,e) (p)->lpVtbl->ComputeSphereVisibility(p,a,b,c,d,e) +#define IDirect3DDevice7_GetTexture(p,a,b) (p)->lpVtbl->GetTexture(p,a,b) +#define IDirect3DDevice7_SetTexture(p,a,b) (p)->lpVtbl->SetTexture(p,a,b) +#define IDirect3DDevice7_GetTextureStageState(p,a,b,c) (p)->lpVtbl->GetTextureStageState(p,a,b,c) +#define IDirect3DDevice7_SetTextureStageState(p,a,b,c) (p)->lpVtbl->SetTextureStageState(p,a,b,c) +#define IDirect3DDevice7_ValidateDevice(p,a) (p)->lpVtbl->ValidateDevice(p,a) +#define IDirect3DDevice7_ApplyStateBlock(p,a) (p)->lpVtbl->ApplyStateBlock(p,a) +#define IDirect3DDevice7_CaptureStateBlock(p,a) (p)->lpVtbl->CaptureStateBlock(p,a) +#define IDirect3DDevice7_DeleteStateBlock(p,a) (p)->lpVtbl->DeleteStateBlock(p,a) +#define IDirect3DDevice7_CreateStateBlock(p,a,b) (p)->lpVtbl->CreateStateBlock(p,a,b) +#define IDirect3DDevice7_Load(p,a,b,c,d,e) (p)->lpVtbl->Load(p,a,b,c,d,e) +#define IDirect3DDevice7_LightEnable(p,a,b) (p)->lpVtbl->LightEnable(p,a,b) +#define IDirect3DDevice7_GetLightEnable(p,a,b) (p)->lpVtbl->GetLightEnable(p,a,b) +#define IDirect3DDevice7_SetClipPlane(p,a,b) (p)->lpVtbl->SetClipPlane(p,a,b) +#define IDirect3DDevice7_GetClipPlane(p,a,b) (p)->lpVtbl->GetClipPlane(p,a,b) +#define IDirect3DDevice7_GetInfo(p,a,b,c) (p)->lpVtbl->GetInfo(p,a,b,c) +#else +#define IDirect3DDevice7_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DDevice7_AddRef(p) (p)->AddRef() +#define IDirect3DDevice7_Release(p) (p)->Release() +#define IDirect3DDevice7_GetCaps(p,a) (p)->GetCaps(a) +#define IDirect3DDevice7_EnumTextureFormats(p,a,b) (p)->EnumTextureFormats(a,b) +#define IDirect3DDevice7_BeginScene(p) (p)->BeginScene() +#define IDirect3DDevice7_EndScene(p) (p)->EndScene() +#define IDirect3DDevice7_GetDirect3D(p,a) (p)->GetDirect3D(a) +#define IDirect3DDevice7_SetRenderTarget(p,a,b) (p)->SetRenderTarget(a,b) +#define IDirect3DDevice7_GetRenderTarget(p,a) (p)->GetRenderTarget(a) +#define IDirect3DDevice7_Clear(p,a,b,c,d,e,f) (p)->Clear(a,b,c,d,e,f) +#define IDirect3DDevice7_SetTransform(p,a,b) (p)->SetTransform(a,b) +#define IDirect3DDevice7_GetTransform(p,a,b) (p)->GetTransform(a,b) +#define IDirect3DDevice7_SetViewport(p,a) (p)->SetViewport(a) +#define IDirect3DDevice7_MultiplyTransform(p,a,b) (p)->MultiplyTransform(a,b) +#define IDirect3DDevice7_GetViewport(p,a) (p)->GetViewport(a) +#define IDirect3DDevice7_SetMaterial(p,a) (p)->SetMaterial(a) +#define IDirect3DDevice7_GetMaterial(p,a) (p)->GetMaterial(a) +#define IDirect3DDevice7_SetLight(p,a,b) (p)->SetLight(a,b) +#define IDirect3DDevice7_GetLight(p,a,b) (p)->GetLight(a,b) +#define IDirect3DDevice7_SetRenderState(p,a,b) (p)->SetRenderState(a,b) +#define IDirect3DDevice7_GetRenderState(p,a,b) (p)->GetRenderState(a,b) +#define IDirect3DDevice7_BeginStateBlock(p) (p)->BeginStateBlock() +#define IDirect3DDevice7_EndStateBlock(p,a) (p)->EndStateBlock(a) +#define IDirect3DDevice7_PreLoad(p,a) (p)->PreLoad(a) +#define IDirect3DDevice7_DrawPrimitive(p,a,b,c,d,e) (p)->DrawPrimitive(a,b,c,d,e) +#define IDirect3DDevice7_DrawIndexedPrimitive(p,a,b,c,d,e,f,g) (p)->DrawIndexedPrimitive(a,b,c,d,e,f,g) +#define IDirect3DDevice7_SetClipStatus(p,a) (p)->SetClipStatus(a) +#define IDirect3DDevice7_GetClipStatus(p,a) (p)->GetClipStatus(a) +#define IDirect3DDevice7_DrawPrimitiveStrided(p,a,b,c,d,e) (p)->DrawPrimitiveStrided(a,b,c,d,e) +#define IDirect3DDevice7_DrawIndexedPrimitiveStrided(p,a,b,c,d,e,f,g) (p)->DrawIndexedPrimitiveStrided(a,b,c,d,e,f,g) +#define IDirect3DDevice7_DrawPrimitiveVB(p,a,b,c,d,e) (p)->DrawPrimitiveVB(a,b,c,d,e) +#define IDirect3DDevice7_DrawIndexedPrimitiveVB(p,a,b,c,d,e,f,g) (p)->DrawIndexedPrimitiveVB(a,b,c,d,e,f,g) +#define IDirect3DDevice7_ComputeSphereVisibility(p,a,b,c,d,e) (p)->ComputeSphereVisibility(a,b,c,d,e) +#define IDirect3DDevice7_GetTexture(p,a,b) (p)->GetTexture(a,b) +#define IDirect3DDevice7_SetTexture(p,a,b) (p)->SetTexture(a,b) +#define IDirect3DDevice7_GetTextureStageState(p,a,b,c) (p)->GetTextureStageState(a,b,c) +#define IDirect3DDevice7_SetTextureStageState(p,a,b,c) (p)->SetTextureStageState(a,b,c) +#define IDirect3DDevice7_ValidateDevice(p,a) (p)->ValidateDevice(a) +#define IDirect3DDevice7_ApplyStateBlock(p,a) (p)->ApplyStateBlock(a) +#define IDirect3DDevice7_CaptureStateBlock(p,a) (p)->CaptureStateBlock(a) +#define IDirect3DDevice7_DeleteStateBlock(p,a) (p)->DeleteStateBlock(a) +#define IDirect3DDevice7_CreateStateBlock(p,a,b) (p)->CreateStateBlock(a,b) +#define IDirect3DDevice7_Load(p,a,b,c,d,e) (p)->Load(a,b,c,d,e) +#define IDirect3DDevice7_LightEnable(p,a,b) (p)->LightEnable(a,b) +#define IDirect3DDevice7_GetLightEnable(p,a,b) (p)->GetLightEnable(a,b) +#define IDirect3DDevice7_SetClipPlane(p,a,b) (p)->SetClipPlane(a,b) +#define IDirect3DDevice7_GetClipPlane(p,a,b) (p)->GetClipPlane(a,b) +#define IDirect3DDevice7_GetInfo(p,a,b,c) (p)->GetInfo(a,b,c) +#endif +#endif /* DIRECT3D_VERSION >= 0x0700 */ + +/* + * Execute Buffer interface + */ +#undef INTERFACE +#define INTERFACE IDirect3DExecuteBuffer + +DECLARE_INTERFACE_(IDirect3DExecuteBuffer, IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + + /*** IDirect3DExecuteBuffer methods ***/ + STDMETHOD(Initialize)(THIS_ LPDIRECT3DDEVICE,LPD3DEXECUTEBUFFERDESC) PURE; + STDMETHOD(Lock)(THIS_ LPD3DEXECUTEBUFFERDESC) PURE; + STDMETHOD(Unlock)(THIS) PURE; + STDMETHOD(SetExecuteData)(THIS_ LPD3DEXECUTEDATA) PURE; + STDMETHOD(GetExecuteData)(THIS_ LPD3DEXECUTEDATA) PURE; + STDMETHOD(Validate)(THIS_ LPDWORD,LPD3DVALIDATECALLBACK,LPVOID,DWORD) PURE; + STDMETHOD(Optimize)(THIS_ DWORD) PURE; +}; + +typedef struct IDirect3DExecuteBuffer *LPDIRECT3DEXECUTEBUFFER; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirect3DExecuteBuffer_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DExecuteBuffer_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DExecuteBuffer_Release(p) (p)->lpVtbl->Release(p) +#define IDirect3DExecuteBuffer_Initialize(p,a,b) (p)->lpVtbl->Initialize(p,a,b) +#define IDirect3DExecuteBuffer_Lock(p,a) (p)->lpVtbl->Lock(p,a) +#define IDirect3DExecuteBuffer_Unlock(p) (p)->lpVtbl->Unlock(p) +#define IDirect3DExecuteBuffer_SetExecuteData(p,a) (p)->lpVtbl->SetExecuteData(p,a) +#define IDirect3DExecuteBuffer_GetExecuteData(p,a) (p)->lpVtbl->GetExecuteData(p,a) +#define IDirect3DExecuteBuffer_Validate(p,a,b,c,d) (p)->lpVtbl->Validate(p,a,b,c,d) +#define IDirect3DExecuteBuffer_Optimize(p,a) (p)->lpVtbl->Optimize(p,a) +#else +#define IDirect3DExecuteBuffer_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DExecuteBuffer_AddRef(p) (p)->AddRef() +#define IDirect3DExecuteBuffer_Release(p) (p)->Release() +#define IDirect3DExecuteBuffer_Initialize(p,a,b) (p)->Initialize(a,b) +#define IDirect3DExecuteBuffer_Lock(p,a) (p)->Lock(a) +#define IDirect3DExecuteBuffer_Unlock(p) (p)->Unlock() +#define IDirect3DExecuteBuffer_SetExecuteData(p,a) (p)->SetExecuteData(a) +#define IDirect3DExecuteBuffer_GetExecuteData(p,a) (p)->GetExecuteData(a) +#define IDirect3DExecuteBuffer_Validate(p,a,b,c,d) (p)->Validate(a,b,c,d) +#define IDirect3DExecuteBuffer_Optimize(p,a) (p)->Optimize(a) +#endif + +/* + * Light interfaces + */ +#undef INTERFACE +#define INTERFACE IDirect3DLight + +DECLARE_INTERFACE_(IDirect3DLight, IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + + /*** IDirect3DLight methods ***/ + STDMETHOD(Initialize)(THIS_ LPDIRECT3D) PURE; + STDMETHOD(SetLight)(THIS_ LPD3DLIGHT) PURE; + STDMETHOD(GetLight)(THIS_ LPD3DLIGHT) PURE; +}; + +typedef struct IDirect3DLight *LPDIRECT3DLIGHT; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirect3DLight_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DLight_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DLight_Release(p) (p)->lpVtbl->Release(p) +#define IDirect3DLight_Initialize(p,a) (p)->lpVtbl->Initialize(p,a) +#define IDirect3DLight_SetLight(p,a) (p)->lpVtbl->SetLight(p,a) +#define IDirect3DLight_GetLight(p,a) (p)->lpVtbl->GetLight(p,a) +#else +#define IDirect3DLight_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DLight_AddRef(p) (p)->AddRef() +#define IDirect3DLight_Release(p) (p)->Release() +#define IDirect3DLight_Initialize(p,a) (p)->Initialize(a) +#define IDirect3DLight_SetLight(p,a) (p)->SetLight(a) +#define IDirect3DLight_GetLight(p,a) (p)->GetLight(a) +#endif + +/* + * Material interfaces + */ +#undef INTERFACE +#define INTERFACE IDirect3DMaterial + +DECLARE_INTERFACE_(IDirect3DMaterial, IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + + /*** IDirect3DMaterial methods ***/ + STDMETHOD(Initialize)(THIS_ LPDIRECT3D) PURE; + STDMETHOD(SetMaterial)(THIS_ LPD3DMATERIAL) PURE; + STDMETHOD(GetMaterial)(THIS_ LPD3DMATERIAL) PURE; + STDMETHOD(GetHandle)(THIS_ LPDIRECT3DDEVICE,LPD3DMATERIALHANDLE) PURE; + STDMETHOD(Reserve)(THIS) PURE; + STDMETHOD(Unreserve)(THIS) PURE; +}; + +typedef struct IDirect3DMaterial *LPDIRECT3DMATERIAL; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirect3DMaterial_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DMaterial_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DMaterial_Release(p) (p)->lpVtbl->Release(p) +#define IDirect3DMaterial_Initialize(p,a) (p)->lpVtbl->Initialize(p,a) +#define IDirect3DMaterial_SetMaterial(p,a) (p)->lpVtbl->SetMaterial(p,a) +#define IDirect3DMaterial_GetMaterial(p,a) (p)->lpVtbl->GetMaterial(p,a) +#define IDirect3DMaterial_GetHandle(p,a,b) (p)->lpVtbl->GetHandle(p,a,b) +#define IDirect3DMaterial_Reserve(p) (p)->lpVtbl->Reserve(p) +#define IDirect3DMaterial_Unreserve(p) (p)->lpVtbl->Unreserve(p) +#else +#define IDirect3DMaterial_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DMaterial_AddRef(p) (p)->AddRef() +#define IDirect3DMaterial_Release(p) (p)->Release() +#define IDirect3DMaterial_Initialize(p,a) (p)->Initialize(a) +#define IDirect3DMaterial_SetMaterial(p,a) (p)->SetMaterial(a) +#define IDirect3DMaterial_GetMaterial(p,a) (p)->GetMaterial(a) +#define IDirect3DMaterial_GetHandle(p,a,b) (p)->GetHandle(a,b) +#define IDirect3DMaterial_Reserve(p) (p)->Reserve() +#define IDirect3DMaterial_Unreserve(p) (p)->Unreserve() +#endif + +#if(DIRECT3D_VERSION >= 0x0500) +#undef INTERFACE +#define INTERFACE IDirect3DMaterial2 + +DECLARE_INTERFACE_(IDirect3DMaterial2, IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + + /*** IDirect3DMaterial2 methods ***/ + STDMETHOD(SetMaterial)(THIS_ LPD3DMATERIAL) PURE; + STDMETHOD(GetMaterial)(THIS_ LPD3DMATERIAL) PURE; + STDMETHOD(GetHandle)(THIS_ LPDIRECT3DDEVICE2,LPD3DMATERIALHANDLE) PURE; +}; + +typedef struct IDirect3DMaterial2 *LPDIRECT3DMATERIAL2; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirect3DMaterial2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DMaterial2_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DMaterial2_Release(p) (p)->lpVtbl->Release(p) +#define IDirect3DMaterial2_SetMaterial(p,a) (p)->lpVtbl->SetMaterial(p,a) +#define IDirect3DMaterial2_GetMaterial(p,a) (p)->lpVtbl->GetMaterial(p,a) +#define IDirect3DMaterial2_GetHandle(p,a,b) (p)->lpVtbl->GetHandle(p,a,b) +#else +#define IDirect3DMaterial2_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DMaterial2_AddRef(p) (p)->AddRef() +#define IDirect3DMaterial2_Release(p) (p)->Release() +#define IDirect3DMaterial2_SetMaterial(p,a) (p)->SetMaterial(a) +#define IDirect3DMaterial2_GetMaterial(p,a) (p)->GetMaterial(a) +#define IDirect3DMaterial2_GetHandle(p,a,b) (p)->GetHandle(a,b) +#endif +#endif /* DIRECT3D_VERSION >= 0x0500 */ + +#if(DIRECT3D_VERSION >= 0x0600) +#undef INTERFACE +#define INTERFACE IDirect3DMaterial3 + +DECLARE_INTERFACE_(IDirect3DMaterial3, IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + + /*** IDirect3DMaterial3 methods ***/ + STDMETHOD(SetMaterial)(THIS_ LPD3DMATERIAL) PURE; + STDMETHOD(GetMaterial)(THIS_ LPD3DMATERIAL) PURE; + STDMETHOD(GetHandle)(THIS_ LPDIRECT3DDEVICE3,LPD3DMATERIALHANDLE) PURE; +}; + +typedef struct IDirect3DMaterial3 *LPDIRECT3DMATERIAL3; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirect3DMaterial3_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DMaterial3_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DMaterial3_Release(p) (p)->lpVtbl->Release(p) +#define IDirect3DMaterial3_SetMaterial(p,a) (p)->lpVtbl->SetMaterial(p,a) +#define IDirect3DMaterial3_GetMaterial(p,a) (p)->lpVtbl->GetMaterial(p,a) +#define IDirect3DMaterial3_GetHandle(p,a,b) (p)->lpVtbl->GetHandle(p,a,b) +#else +#define IDirect3DMaterial3_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DMaterial3_AddRef(p) (p)->AddRef() +#define IDirect3DMaterial3_Release(p) (p)->Release() +#define IDirect3DMaterial3_SetMaterial(p,a) (p)->SetMaterial(a) +#define IDirect3DMaterial3_GetMaterial(p,a) (p)->GetMaterial(a) +#define IDirect3DMaterial3_GetHandle(p,a,b) (p)->GetHandle(a,b) +#endif +#endif /* DIRECT3D_VERSION >= 0x0600 */ + +/* + * Texture interfaces + */ +#undef INTERFACE +#define INTERFACE IDirect3DTexture + +DECLARE_INTERFACE_(IDirect3DTexture, IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + + /*** IDirect3DTexture methods ***/ + STDMETHOD(Initialize)(THIS_ LPDIRECT3DDEVICE,LPDIRECTDRAWSURFACE) PURE; + STDMETHOD(GetHandle)(THIS_ LPDIRECT3DDEVICE,LPD3DTEXTUREHANDLE) PURE; + STDMETHOD(PaletteChanged)(THIS_ DWORD,DWORD) PURE; + STDMETHOD(Load)(THIS_ LPDIRECT3DTEXTURE) PURE; + STDMETHOD(Unload)(THIS) PURE; +}; + +typedef struct IDirect3DTexture *LPDIRECT3DTEXTURE; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirect3DTexture_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DTexture_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DTexture_Release(p) (p)->lpVtbl->Release(p) +#define IDirect3DTexture_Initialize(p,a,b) (p)->lpVtbl->Initialize(p,a,b) +#define IDirect3DTexture_GetHandle(p,a,b) (p)->lpVtbl->GetHandle(p,a,b) +#define IDirect3DTexture_PaletteChanged(p,a,b) (p)->lpVtbl->PaletteChanged(p,a,b) +#define IDirect3DTexture_Load(p,a) (p)->lpVtbl->Load(p,a) +#define IDirect3DTexture_Unload(p) (p)->lpVtbl->Unload(p) +#else +#define IDirect3DTexture_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DTexture_AddRef(p) (p)->AddRef() +#define IDirect3DTexture_Release(p) (p)->Release() +#define IDirect3DTexture_Initialize(p,a,b) (p)->Initialize(a,b) +#define IDirect3DTexture_GetHandle(p,a,b) (p)->GetHandle(a,b) +#define IDirect3DTexture_PaletteChanged(p,a,b) (p)->PaletteChanged(a,b) +#define IDirect3DTexture_Load(p,a) (p)->Load(a) +#define IDirect3DTexture_Unload(p) (p)->Unload() +#endif + +#if(DIRECT3D_VERSION >= 0x0500) +#undef INTERFACE +#define INTERFACE IDirect3DTexture2 + +DECLARE_INTERFACE_(IDirect3DTexture2, IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + + /*** IDirect3DTexture2 methods ***/ + STDMETHOD(GetHandle)(THIS_ LPDIRECT3DDEVICE2,LPD3DTEXTUREHANDLE) PURE; + STDMETHOD(PaletteChanged)(THIS_ DWORD,DWORD) PURE; + STDMETHOD(Load)(THIS_ LPDIRECT3DTEXTURE2) PURE; +}; + +typedef struct IDirect3DTexture2 *LPDIRECT3DTEXTURE2; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirect3DTexture2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DTexture2_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DTexture2_Release(p) (p)->lpVtbl->Release(p) +#define IDirect3DTexture2_GetHandle(p,a,b) (p)->lpVtbl->GetHandle(p,a,b) +#define IDirect3DTexture2_PaletteChanged(p,a,b) (p)->lpVtbl->PaletteChanged(p,a,b) +#define IDirect3DTexture2_Load(p,a) (p)->lpVtbl->Load(p,a) +#else +#define IDirect3DTexture2_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DTexture2_AddRef(p) (p)->AddRef() +#define IDirect3DTexture2_Release(p) (p)->Release() +#define IDirect3DTexture2_GetHandle(p,a,b) (p)->GetHandle(a,b) +#define IDirect3DTexture2_PaletteChanged(p,a,b) (p)->PaletteChanged(a,b) +#define IDirect3DTexture2_Load(p,a) (p)->Load(a) +#endif +#endif /* DIRECT3D_VERSION >= 0x0500 */ + +/* + * Viewport interfaces + */ +#undef INTERFACE +#define INTERFACE IDirect3DViewport + +DECLARE_INTERFACE_(IDirect3DViewport, IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + + /*** IDirect3DViewport methods ***/ + STDMETHOD(Initialize)(THIS_ LPDIRECT3D) PURE; + STDMETHOD(GetViewport)(THIS_ LPD3DVIEWPORT) PURE; + STDMETHOD(SetViewport)(THIS_ LPD3DVIEWPORT) PURE; + STDMETHOD(TransformVertices)(THIS_ DWORD,LPD3DTRANSFORMDATA,DWORD,LPDWORD) PURE; + STDMETHOD(LightElements)(THIS_ DWORD,LPD3DLIGHTDATA) PURE; + STDMETHOD(SetBackground)(THIS_ D3DMATERIALHANDLE) PURE; + STDMETHOD(GetBackground)(THIS_ LPD3DMATERIALHANDLE,LPBOOL) PURE; + STDMETHOD(SetBackgroundDepth)(THIS_ LPDIRECTDRAWSURFACE) PURE; + STDMETHOD(GetBackgroundDepth)(THIS_ LPDIRECTDRAWSURFACE*,LPBOOL) PURE; + STDMETHOD(Clear)(THIS_ DWORD,LPD3DRECT,DWORD) PURE; + STDMETHOD(AddLight)(THIS_ LPDIRECT3DLIGHT) PURE; + STDMETHOD(DeleteLight)(THIS_ LPDIRECT3DLIGHT) PURE; + STDMETHOD(NextLight)(THIS_ LPDIRECT3DLIGHT,LPDIRECT3DLIGHT*,DWORD) PURE; +}; + +typedef struct IDirect3DViewport *LPDIRECT3DVIEWPORT; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirect3DViewport_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DViewport_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DViewport_Release(p) (p)->lpVtbl->Release(p) +#define IDirect3DViewport_Initialize(p,a) (p)->lpVtbl->Initialize(p,a) +#define IDirect3DViewport_GetViewport(p,a) (p)->lpVtbl->GetViewport(p,a) +#define IDirect3DViewport_SetViewport(p,a) (p)->lpVtbl->SetViewport(p,a) +#define IDirect3DViewport_TransformVertices(p,a,b,c,d) (p)->lpVtbl->TransformVertices(p,a,b,c,d) +#define IDirect3DViewport_LightElements(p,a,b) (p)->lpVtbl->LightElements(p,a,b) +#define IDirect3DViewport_SetBackground(p,a) (p)->lpVtbl->SetBackground(p,a) +#define IDirect3DViewport_GetBackground(p,a,b) (p)->lpVtbl->GetBackground(p,a,b) +#define IDirect3DViewport_SetBackgroundDepth(p,a) (p)->lpVtbl->SetBackgroundDepth(p,a) +#define IDirect3DViewport_GetBackgroundDepth(p,a,b) (p)->lpVtbl->GetBackgroundDepth(p,a,b) +#define IDirect3DViewport_Clear(p,a,b,c) (p)->lpVtbl->Clear(p,a,b,c) +#define IDirect3DViewport_AddLight(p,a) (p)->lpVtbl->AddLight(p,a) +#define IDirect3DViewport_DeleteLight(p,a) (p)->lpVtbl->DeleteLight(p,a) +#define IDirect3DViewport_NextLight(p,a,b,c) (p)->lpVtbl->NextLight(p,a,b,c) +#else +#define IDirect3DViewport_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DViewport_AddRef(p) (p)->AddRef() +#define IDirect3DViewport_Release(p) (p)->Release() +#define IDirect3DViewport_Initialize(p,a) (p)->Initialize(a) +#define IDirect3DViewport_GetViewport(p,a) (p)->GetViewport(a) +#define IDirect3DViewport_SetViewport(p,a) (p)->SetViewport(a) +#define IDirect3DViewport_TransformVertices(p,a,b,c,d) (p)->TransformVertices(a,b,c,d) +#define IDirect3DViewport_LightElements(p,a,b) (p)->LightElements(a,b) +#define IDirect3DViewport_SetBackground(p,a) (p)->SetBackground(a) +#define IDirect3DViewport_GetBackground(p,a,b) (p)->GetBackground(a,b) +#define IDirect3DViewport_SetBackgroundDepth(p,a) (p)->SetBackgroundDepth(a) +#define IDirect3DViewport_GetBackgroundDepth(p,a,b) (p)->GetBackgroundDepth(a,b) +#define IDirect3DViewport_Clear(p,a,b,c) (p)->Clear(a,b,c) +#define IDirect3DViewport_AddLight(p,a) (p)->AddLight(a) +#define IDirect3DViewport_DeleteLight(p,a) (p)->DeleteLight(a) +#define IDirect3DViewport_NextLight(p,a,b,c) (p)->NextLight(a,b,c) +#endif + +#if(DIRECT3D_VERSION >= 0x0500) +#undef INTERFACE +#define INTERFACE IDirect3DViewport2 + +DECLARE_INTERFACE_(IDirect3DViewport2, IDirect3DViewport) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + + /*** IDirect3DViewport methods ***/ + STDMETHOD(Initialize)(THIS_ LPDIRECT3D) PURE; + STDMETHOD(GetViewport)(THIS_ LPD3DVIEWPORT) PURE; + STDMETHOD(SetViewport)(THIS_ LPD3DVIEWPORT) PURE; + STDMETHOD(TransformVertices)(THIS_ DWORD,LPD3DTRANSFORMDATA,DWORD,LPDWORD) PURE; + STDMETHOD(LightElements)(THIS_ DWORD,LPD3DLIGHTDATA) PURE; + STDMETHOD(SetBackground)(THIS_ D3DMATERIALHANDLE) PURE; + STDMETHOD(GetBackground)(THIS_ LPD3DMATERIALHANDLE,LPBOOL) PURE; + STDMETHOD(SetBackgroundDepth)(THIS_ LPDIRECTDRAWSURFACE) PURE; + STDMETHOD(GetBackgroundDepth)(THIS_ LPDIRECTDRAWSURFACE*,LPBOOL) PURE; + STDMETHOD(Clear)(THIS_ DWORD,LPD3DRECT,DWORD) PURE; + STDMETHOD(AddLight)(THIS_ LPDIRECT3DLIGHT) PURE; + STDMETHOD(DeleteLight)(THIS_ LPDIRECT3DLIGHT) PURE; + STDMETHOD(NextLight)(THIS_ LPDIRECT3DLIGHT,LPDIRECT3DLIGHT*,DWORD) PURE; + STDMETHOD(GetViewport2)(THIS_ LPD3DVIEWPORT2) PURE; + STDMETHOD(SetViewport2)(THIS_ LPD3DVIEWPORT2) PURE; +}; + +typedef struct IDirect3DViewport2 *LPDIRECT3DVIEWPORT2; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirect3DViewport2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DViewport2_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DViewport2_Release(p) (p)->lpVtbl->Release(p) +#define IDirect3DViewport2_Initialize(p,a) (p)->lpVtbl->Initialize(p,a) +#define IDirect3DViewport2_GetViewport(p,a) (p)->lpVtbl->GetViewport(p,a) +#define IDirect3DViewport2_SetViewport(p,a) (p)->lpVtbl->SetViewport(p,a) +#define IDirect3DViewport2_TransformVertices(p,a,b,c,d) (p)->lpVtbl->TransformVertices(p,a,b,c,d) +#define IDirect3DViewport2_LightElements(p,a,b) (p)->lpVtbl->LightElements(p,a,b) +#define IDirect3DViewport2_SetBackground(p,a) (p)->lpVtbl->SetBackground(p,a) +#define IDirect3DViewport2_GetBackground(p,a,b) (p)->lpVtbl->GetBackground(p,a,b) +#define IDirect3DViewport2_SetBackgroundDepth(p,a) (p)->lpVtbl->SetBackgroundDepth(p,a) +#define IDirect3DViewport2_GetBackgroundDepth(p,a,b) (p)->lpVtbl->GetBackgroundDepth(p,a,b) +#define IDirect3DViewport2_Clear(p,a,b,c) (p)->lpVtbl->Clear(p,a,b,c) +#define IDirect3DViewport2_AddLight(p,a) (p)->lpVtbl->AddLight(p,a) +#define IDirect3DViewport2_DeleteLight(p,a) (p)->lpVtbl->DeleteLight(p,a) +#define IDirect3DViewport2_NextLight(p,a,b,c) (p)->lpVtbl->NextLight(p,a,b,c) +#define IDirect3DViewport2_GetViewport2(p,a) (p)->lpVtbl->GetViewport2(p,a) +#define IDirect3DViewport2_SetViewport2(p,a) (p)->lpVtbl->SetViewport2(p,a) +#else +#define IDirect3DViewport2_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DViewport2_AddRef(p) (p)->AddRef() +#define IDirect3DViewport2_Release(p) (p)->Release() +#define IDirect3DViewport2_Initialize(p,a) (p)->Initialize(a) +#define IDirect3DViewport2_GetViewport(p,a) (p)->GetViewport(a) +#define IDirect3DViewport2_SetViewport(p,a) (p)->SetViewport(a) +#define IDirect3DViewport2_TransformVertices(p,a,b,c,d) (p)->TransformVertices(a,b,c,d) +#define IDirect3DViewport2_LightElements(p,a,b) (p)->LightElements(a,b) +#define IDirect3DViewport2_SetBackground(p,a) (p)->SetBackground(a) +#define IDirect3DViewport2_GetBackground(p,a,b) (p)->GetBackground(a,b) +#define IDirect3DViewport2_SetBackgroundDepth(p,a) (p)->SetBackgroundDepth(a) +#define IDirect3DViewport2_GetBackgroundDepth(p,a,b) (p)->GetBackgroundDepth(a,b) +#define IDirect3DViewport2_Clear(p,a,b,c) (p)->Clear(a,b,c) +#define IDirect3DViewport2_AddLight(p,a) (p)->AddLight(a) +#define IDirect3DViewport2_DeleteLight(p,a) (p)->DeleteLight(a) +#define IDirect3DViewport2_NextLight(p,a,b,c) (p)->NextLight(a,b,c) +#define IDirect3DViewport2_GetViewport2(p,a) (p)->GetViewport2(a) +#define IDirect3DViewport2_SetViewport2(p,a) (p)->SetViewport2(a) +#endif +#endif /* DIRECT3D_VERSION >= 0x0500 */ + +#if(DIRECT3D_VERSION >= 0x0600) + +#undef INTERFACE +#define INTERFACE IDirect3DViewport3 + +DECLARE_INTERFACE_(IDirect3DViewport3, IDirect3DViewport2) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + + /*** IDirect3DViewport2 methods ***/ + STDMETHOD(Initialize)(THIS_ LPDIRECT3D) PURE; + STDMETHOD(GetViewport)(THIS_ LPD3DVIEWPORT) PURE; + STDMETHOD(SetViewport)(THIS_ LPD3DVIEWPORT) PURE; + STDMETHOD(TransformVertices)(THIS_ DWORD,LPD3DTRANSFORMDATA,DWORD,LPDWORD) PURE; + STDMETHOD(LightElements)(THIS_ DWORD,LPD3DLIGHTDATA) PURE; + STDMETHOD(SetBackground)(THIS_ D3DMATERIALHANDLE) PURE; + STDMETHOD(GetBackground)(THIS_ LPD3DMATERIALHANDLE,LPBOOL) PURE; + STDMETHOD(SetBackgroundDepth)(THIS_ LPDIRECTDRAWSURFACE) PURE; + STDMETHOD(GetBackgroundDepth)(THIS_ LPDIRECTDRAWSURFACE*,LPBOOL) PURE; + STDMETHOD(Clear)(THIS_ DWORD,LPD3DRECT,DWORD) PURE; + STDMETHOD(AddLight)(THIS_ LPDIRECT3DLIGHT) PURE; + STDMETHOD(DeleteLight)(THIS_ LPDIRECT3DLIGHT) PURE; + STDMETHOD(NextLight)(THIS_ LPDIRECT3DLIGHT,LPDIRECT3DLIGHT*,DWORD) PURE; + STDMETHOD(GetViewport2)(THIS_ LPD3DVIEWPORT2) PURE; + STDMETHOD(SetViewport2)(THIS_ LPD3DVIEWPORT2) PURE; + STDMETHOD(SetBackgroundDepth2)(THIS_ LPDIRECTDRAWSURFACE4) PURE; + STDMETHOD(GetBackgroundDepth2)(THIS_ LPDIRECTDRAWSURFACE4*,LPBOOL) PURE; + STDMETHOD(Clear2)(THIS_ DWORD,LPD3DRECT,DWORD,D3DCOLOR,D3DVALUE,DWORD) PURE; +}; + +typedef struct IDirect3DViewport3 *LPDIRECT3DVIEWPORT3; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirect3DViewport3_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DViewport3_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DViewport3_Release(p) (p)->lpVtbl->Release(p) +#define IDirect3DViewport3_Initialize(p,a) (p)->lpVtbl->Initialize(p,a) +#define IDirect3DViewport3_GetViewport(p,a) (p)->lpVtbl->GetViewport(p,a) +#define IDirect3DViewport3_SetViewport(p,a) (p)->lpVtbl->SetViewport(p,a) +#define IDirect3DViewport3_TransformVertices(p,a,b,c,d) (p)->lpVtbl->TransformVertices(p,a,b,c,d) +#define IDirect3DViewport3_LightElements(p,a,b) (p)->lpVtbl->LightElements(p,a,b) +#define IDirect3DViewport3_SetBackground(p,a) (p)->lpVtbl->SetBackground(p,a) +#define IDirect3DViewport3_GetBackground(p,a,b) (p)->lpVtbl->GetBackground(p,a,b) +#define IDirect3DViewport3_SetBackgroundDepth(p,a) (p)->lpVtbl->SetBackgroundDepth(p,a) +#define IDirect3DViewport3_GetBackgroundDepth(p,a,b) (p)->lpVtbl->GetBackgroundDepth(p,a,b) +#define IDirect3DViewport3_Clear(p,a,b,c) (p)->lpVtbl->Clear(p,a,b,c) +#define IDirect3DViewport3_AddLight(p,a) (p)->lpVtbl->AddLight(p,a) +#define IDirect3DViewport3_DeleteLight(p,a) (p)->lpVtbl->DeleteLight(p,a) +#define IDirect3DViewport3_NextLight(p,a,b,c) (p)->lpVtbl->NextLight(p,a,b,c) +#define IDirect3DViewport3_GetViewport2(p,a) (p)->lpVtbl->GetViewport2(p,a) +#define IDirect3DViewport3_SetViewport2(p,a) (p)->lpVtbl->SetViewport2(p,a) +#define IDirect3DViewport3_SetBackgroundDepth2(p,a) (p)->lpVtbl->SetBackgroundDepth2(p,a) +#define IDirect3DViewport3_GetBackgroundDepth2(p,a,b) (p)->lpVtbl->GetBackgroundDepth2(p,a,b) +#define IDirect3DViewport3_Clear2(p,a,b,c,d,e,f) (p)->lpVtbl->Clear2(p,a,b,c,d,e,f) +#else +#define IDirect3DViewport3_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DViewport3_AddRef(p) (p)->AddRef() +#define IDirect3DViewport3_Release(p) (p)->Release() +#define IDirect3DViewport3_Initialize(p,a) (p)->Initialize(a) +#define IDirect3DViewport3_GetViewport(p,a) (p)->GetViewport(a) +#define IDirect3DViewport3_SetViewport(p,a) (p)->SetViewport(a) +#define IDirect3DViewport3_TransformVertices(p,a,b,c,d) (p)->TransformVertices(a,b,c,d) +#define IDirect3DViewport3_LightElements(p,a,b) (p)->LightElements(a,b) +#define IDirect3DViewport3_SetBackground(p,a) (p)->SetBackground(a) +#define IDirect3DViewport3_GetBackground(p,a,b) (p)->GetBackground(a,b) +#define IDirect3DViewport3_SetBackgroundDepth(p,a) (p)->SetBackgroundDepth(a) +#define IDirect3DViewport3_GetBackgroundDepth(p,a,b) (p)->GetBackgroundDepth(a,b) +#define IDirect3DViewport3_Clear(p,a,b,c) (p)->Clear(a,b,c) +#define IDirect3DViewport3_AddLight(p,a) (p)->AddLight(a) +#define IDirect3DViewport3_DeleteLight(p,a) (p)->DeleteLight(a) +#define IDirect3DViewport3_NextLight(p,a,b,c) (p)->NextLight(a,b,c) +#define IDirect3DViewport3_GetViewport2(p,a) (p)->GetViewport2(a) +#define IDirect3DViewport3_SetViewport2(p,a) (p)->SetViewport2(a) +#define IDirect3DViewport3_SetBackgroundDepth2(p,a) (p)->SetBackgroundDepth2(a) +#define IDirect3DViewport3_GetBackgroundDepth2(p,a,b) (p)->GetBackgroundDepth2(a,b) +#define IDirect3DViewport3_Clear2(p,a,b,c,d,e,f) (p)->Clear2(a,b,c,d,e,f) +#endif +#endif /* DIRECT3D_VERSION >= 0x0600 */ + +#if(DIRECT3D_VERSION >= 0x0600) +#undef INTERFACE +#define INTERFACE IDirect3DVertexBuffer + +DECLARE_INTERFACE_(IDirect3DVertexBuffer, IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + + /*** IDirect3DVertexBuffer methods ***/ + STDMETHOD(Lock)(THIS_ DWORD,LPVOID*,LPDWORD) PURE; + STDMETHOD(Unlock)(THIS) PURE; + STDMETHOD(ProcessVertices)(THIS_ DWORD,DWORD,DWORD,LPDIRECT3DVERTEXBUFFER,DWORD,LPDIRECT3DDEVICE3,DWORD) PURE; + STDMETHOD(GetVertexBufferDesc)(THIS_ LPD3DVERTEXBUFFERDESC) PURE; + STDMETHOD(Optimize)(THIS_ LPDIRECT3DDEVICE3,DWORD) PURE; +}; + +typedef struct IDirect3DVertexBuffer *LPDIRECT3DVERTEXBUFFER; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirect3DVertexBuffer_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DVertexBuffer_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DVertexBuffer_Release(p) (p)->lpVtbl->Release(p) +#define IDirect3DVertexBuffer_Lock(p,a,b,c) (p)->lpVtbl->Lock(p,a,b,c) +#define IDirect3DVertexBuffer_Unlock(p) (p)->lpVtbl->Unlock(p) +#define IDirect3DVertexBuffer_ProcessVertices(p,a,b,c,d,e,f,g) (p)->lpVtbl->ProcessVertices(p,a,b,c,d,e,f,g) +#define IDirect3DVertexBuffer_GetVertexBufferDesc(p,a) (p)->lpVtbl->GetVertexBufferDesc(p,a) +#define IDirect3DVertexBuffer_Optimize(p,a,b) (p)->lpVtbl->Optimize(p,a,b) +#else +#define IDirect3DVertexBuffer_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DVertexBuffer_AddRef(p) (p)->AddRef() +#define IDirect3DVertexBuffer_Release(p) (p)->Release() +#define IDirect3DVertexBuffer_Lock(p,a,b,c) (p)->Lock(a,b,c) +#define IDirect3DVertexBuffer_Unlock(p) (p)->Unlock() +#define IDirect3DVertexBuffer_ProcessVertices(p,a,b,c,d,e,f,g) (p)->ProcessVertices(a,b,c,d,e,f,g) +#define IDirect3DVertexBuffer_GetVertexBufferDesc(p,a) (p)->GetVertexBufferDesc(a) +#define IDirect3DVertexBuffer_Optimize(p,a,b) (p)->Optimize(a,b) +#endif +#endif /* DIRECT3D_VERSION >= 0x0600 */ + +#if(DIRECT3D_VERSION >= 0x0700) +#undef INTERFACE +#define INTERFACE IDirect3DVertexBuffer7 + +DECLARE_INTERFACE_(IDirect3DVertexBuffer7, IUnknown) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + + /*** IDirect3DVertexBuffer7 methods ***/ + STDMETHOD(Lock)(THIS_ DWORD,LPVOID*,LPDWORD) PURE; + STDMETHOD(Unlock)(THIS) PURE; + STDMETHOD(ProcessVertices)(THIS_ DWORD,DWORD,DWORD,LPDIRECT3DVERTEXBUFFER7,DWORD,LPDIRECT3DDEVICE7,DWORD) PURE; + STDMETHOD(GetVertexBufferDesc)(THIS_ LPD3DVERTEXBUFFERDESC) PURE; + STDMETHOD(Optimize)(THIS_ LPDIRECT3DDEVICE7,DWORD) PURE; + STDMETHOD(ProcessVerticesStrided)(THIS_ DWORD,DWORD,DWORD,LPD3DDRAWPRIMITIVESTRIDEDDATA,DWORD,LPDIRECT3DDEVICE7,DWORD) PURE; +}; + +typedef struct IDirect3DVertexBuffer7 *LPDIRECT3DVERTEXBUFFER7; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirect3DVertexBuffer7_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirect3DVertexBuffer7_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirect3DVertexBuffer7_Release(p) (p)->lpVtbl->Release(p) +#define IDirect3DVertexBuffer7_Lock(p,a,b,c) (p)->lpVtbl->Lock(p,a,b,c) +#define IDirect3DVertexBuffer7_Unlock(p) (p)->lpVtbl->Unlock(p) +#define IDirect3DVertexBuffer7_ProcessVertices(p,a,b,c,d,e,f,g) (p)->lpVtbl->ProcessVertices(p,a,b,c,d,e,f,g) +#define IDirect3DVertexBuffer7_GetVertexBufferDesc(p,a) (p)->lpVtbl->GetVertexBufferDesc(p,a) +#define IDirect3DVertexBuffer7_Optimize(p,a,b) (p)->lpVtbl->Optimize(p,a,b) +#define IDirect3DVertexBuffer7_ProcessVerticesStrided(p,a,b,c,d,e,f,g) (p)->lpVtbl->ProcessVerticesStrided(p,a,b,c,d,e,f,g) +#else +#define IDirect3DVertexBuffer7_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirect3DVertexBuffer7_AddRef(p) (p)->AddRef() +#define IDirect3DVertexBuffer7_Release(p) (p)->Release() +#define IDirect3DVertexBuffer7_Lock(p,a,b,c) (p)->Lock(a,b,c) +#define IDirect3DVertexBuffer7_Unlock(p) (p)->Unlock() +#define IDirect3DVertexBuffer7_ProcessVertices(p,a,b,c,d,e,f,g) (p)->ProcessVertices(a,b,c,d,e,f,g) +#define IDirect3DVertexBuffer7_GetVertexBufferDesc(p,a) (p)->GetVertexBufferDesc(a) +#define IDirect3DVertexBuffer7_Optimize(p,a,b) (p)->Optimize(a,b) +#define IDirect3DVertexBuffer7_ProcessVerticesStrided(p,a,b,c,d,e,f,g) (p)->ProcessVerticesStrided(a,b,c,d,e,f,g) +#endif +#endif /* DIRECT3D_VERSION >= 0x0700 */ + +#if(DIRECT3D_VERSION >= 0x0500) +/**************************************************************************** + * + * Flags for IDirect3DDevice::NextViewport + * + ****************************************************************************/ + +/* + * Return the next viewport + */ +#define D3DNEXT_NEXT 0x00000001l + +/* + * Return the first viewport + */ +#define D3DNEXT_HEAD 0x00000002l + +/* + * Return the last viewport + */ +#define D3DNEXT_TAIL 0x00000004l + + +/**************************************************************************** + * + * Flags for DrawPrimitive/DrawIndexedPrimitive + * Also valid for Begin/BeginIndexed + * Also valid for VertexBuffer::CreateVertexBuffer + ****************************************************************************/ + +/* + * Wait until the device is ready to draw the primitive + * This will cause DP to not return DDERR_WASSTILLDRAWING + */ +#define D3DDP_WAIT 0x00000001l +#endif /* DIRECT3D_VERSION >= 0x0500 */ + +#if (DIRECT3D_VERSION == 0x0500) +/* + * Hint that it is acceptable to render the primitive out of order. + */ +#define D3DDP_OUTOFORDER 0x00000002l +#endif + + +#if(DIRECT3D_VERSION >= 0x0500) +/* + * Hint that the primitives have been clipped by the application. + */ +#define D3DDP_DONOTCLIP 0x00000004l + +/* + * Hint that the extents need not be updated. + */ +#define D3DDP_DONOTUPDATEEXTENTS 0x00000008l +#endif /* DIRECT3D_VERSION >= 0x0500 */ + +#if(DIRECT3D_VERSION >= 0x0600) + +/* + * Hint that the lighting should not be applied on vertices. + */ + +#define D3DDP_DONOTLIGHT 0x00000010l + +#endif /* DIRECT3D_VERSION >= 0x0600 */ + +/* + * Direct3D Errors + * DirectDraw error codes are used when errors not specified here. + */ +#define D3D_OK DD_OK +#define D3DERR_BADMAJORVERSION MAKE_DDHRESULT(700) +#define D3DERR_BADMINORVERSION MAKE_DDHRESULT(701) + +#if(DIRECT3D_VERSION >= 0x0500) +/* + * An invalid device was requested by the application. + */ +#define D3DERR_INVALID_DEVICE MAKE_DDHRESULT(705) +#define D3DERR_INITFAILED MAKE_DDHRESULT(706) + +/* + * SetRenderTarget attempted on a device that was + * QI'd off the render target. + */ +#define D3DERR_DEVICEAGGREGATED MAKE_DDHRESULT(707) +#endif /* DIRECT3D_VERSION >= 0x0500 */ + +#define D3DERR_EXECUTE_CREATE_FAILED MAKE_DDHRESULT(710) +#define D3DERR_EXECUTE_DESTROY_FAILED MAKE_DDHRESULT(711) +#define D3DERR_EXECUTE_LOCK_FAILED MAKE_DDHRESULT(712) +#define D3DERR_EXECUTE_UNLOCK_FAILED MAKE_DDHRESULT(713) +#define D3DERR_EXECUTE_LOCKED MAKE_DDHRESULT(714) +#define D3DERR_EXECUTE_NOT_LOCKED MAKE_DDHRESULT(715) + +#define D3DERR_EXECUTE_FAILED MAKE_DDHRESULT(716) +#define D3DERR_EXECUTE_CLIPPED_FAILED MAKE_DDHRESULT(717) + +#define D3DERR_TEXTURE_NO_SUPPORT MAKE_DDHRESULT(720) +#define D3DERR_TEXTURE_CREATE_FAILED MAKE_DDHRESULT(721) +#define D3DERR_TEXTURE_DESTROY_FAILED MAKE_DDHRESULT(722) +#define D3DERR_TEXTURE_LOCK_FAILED MAKE_DDHRESULT(723) +#define D3DERR_TEXTURE_UNLOCK_FAILED MAKE_DDHRESULT(724) +#define D3DERR_TEXTURE_LOAD_FAILED MAKE_DDHRESULT(725) +#define D3DERR_TEXTURE_SWAP_FAILED MAKE_DDHRESULT(726) +#define D3DERR_TEXTURE_LOCKED MAKE_DDHRESULT(727) +#define D3DERR_TEXTURE_NOT_LOCKED MAKE_DDHRESULT(728) +#define D3DERR_TEXTURE_GETSURF_FAILED MAKE_DDHRESULT(729) + +#define D3DERR_MATRIX_CREATE_FAILED MAKE_DDHRESULT(730) +#define D3DERR_MATRIX_DESTROY_FAILED MAKE_DDHRESULT(731) +#define D3DERR_MATRIX_SETDATA_FAILED MAKE_DDHRESULT(732) +#define D3DERR_MATRIX_GETDATA_FAILED MAKE_DDHRESULT(733) +#define D3DERR_SETVIEWPORTDATA_FAILED MAKE_DDHRESULT(734) + +#if(DIRECT3D_VERSION >= 0x0500) +#define D3DERR_INVALIDCURRENTVIEWPORT MAKE_DDHRESULT(735) +#define D3DERR_INVALIDPRIMITIVETYPE MAKE_DDHRESULT(736) +#define D3DERR_INVALIDVERTEXTYPE MAKE_DDHRESULT(737) +#define D3DERR_TEXTURE_BADSIZE MAKE_DDHRESULT(738) +#define D3DERR_INVALIDRAMPTEXTURE MAKE_DDHRESULT(739) +#endif /* DIRECT3D_VERSION >= 0x0500 */ + +#define D3DERR_MATERIAL_CREATE_FAILED MAKE_DDHRESULT(740) +#define D3DERR_MATERIAL_DESTROY_FAILED MAKE_DDHRESULT(741) +#define D3DERR_MATERIAL_SETDATA_FAILED MAKE_DDHRESULT(742) +#define D3DERR_MATERIAL_GETDATA_FAILED MAKE_DDHRESULT(743) + +#if(DIRECT3D_VERSION >= 0x0500) +#define D3DERR_INVALIDPALETTE MAKE_DDHRESULT(744) + +#define D3DERR_ZBUFF_NEEDS_SYSTEMMEMORY MAKE_DDHRESULT(745) +#define D3DERR_ZBUFF_NEEDS_VIDEOMEMORY MAKE_DDHRESULT(746) +#define D3DERR_SURFACENOTINVIDMEM MAKE_DDHRESULT(747) +#endif /* DIRECT3D_VERSION >= 0x0500 */ + +#define D3DERR_LIGHT_SET_FAILED MAKE_DDHRESULT(750) +#if(DIRECT3D_VERSION >= 0x0500) +#define D3DERR_LIGHTHASVIEWPORT MAKE_DDHRESULT(751) +#define D3DERR_LIGHTNOTINTHISVIEWPORT MAKE_DDHRESULT(752) +#endif /* DIRECT3D_VERSION >= 0x0500 */ + +#define D3DERR_SCENE_IN_SCENE MAKE_DDHRESULT(760) +#define D3DERR_SCENE_NOT_IN_SCENE MAKE_DDHRESULT(761) +#define D3DERR_SCENE_BEGIN_FAILED MAKE_DDHRESULT(762) +#define D3DERR_SCENE_END_FAILED MAKE_DDHRESULT(763) + +#if(DIRECT3D_VERSION >= 0x0500) +#define D3DERR_INBEGIN MAKE_DDHRESULT(770) +#define D3DERR_NOTINBEGIN MAKE_DDHRESULT(771) +#define D3DERR_NOVIEWPORTS MAKE_DDHRESULT(772) +#define D3DERR_VIEWPORTDATANOTSET MAKE_DDHRESULT(773) +#define D3DERR_VIEWPORTHASNODEVICE MAKE_DDHRESULT(774) +#define D3DERR_NOCURRENTVIEWPORT MAKE_DDHRESULT(775) +#endif /* DIRECT3D_VERSION >= 0x0500 */ + +#if(DIRECT3D_VERSION >= 0x0600) +#define D3DERR_INVALIDVERTEXFORMAT MAKE_DDHRESULT(2048) + +/* + * Attempted to CreateTexture on a surface that had a color key + */ +#define D3DERR_COLORKEYATTACHED MAKE_DDHRESULT(2050) + +#define D3DERR_VERTEXBUFFEROPTIMIZED MAKE_DDHRESULT(2060) +#define D3DERR_VBUF_CREATE_FAILED MAKE_DDHRESULT(2061) +#define D3DERR_VERTEXBUFFERLOCKED MAKE_DDHRESULT(2062) +#define D3DERR_VERTEXBUFFERUNLOCKFAILED MAKE_DDHRESULT(2063) + +#define D3DERR_ZBUFFER_NOTPRESENT MAKE_DDHRESULT(2070) +#define D3DERR_STENCILBUFFER_NOTPRESENT MAKE_DDHRESULT(2071) + +#define D3DERR_WRONGTEXTUREFORMAT MAKE_DDHRESULT(2072) +#define D3DERR_UNSUPPORTEDCOLOROPERATION MAKE_DDHRESULT(2073) +#define D3DERR_UNSUPPORTEDCOLORARG MAKE_DDHRESULT(2074) +#define D3DERR_UNSUPPORTEDALPHAOPERATION MAKE_DDHRESULT(2075) +#define D3DERR_UNSUPPORTEDALPHAARG MAKE_DDHRESULT(2076) +#define D3DERR_TOOMANYOPERATIONS MAKE_DDHRESULT(2077) +#define D3DERR_CONFLICTINGTEXTUREFILTER MAKE_DDHRESULT(2078) +#define D3DERR_UNSUPPORTEDFACTORVALUE MAKE_DDHRESULT(2079) +#define D3DERR_CONFLICTINGRENDERSTATE MAKE_DDHRESULT(2081) +#define D3DERR_UNSUPPORTEDTEXTUREFILTER MAKE_DDHRESULT(2082) +#define D3DERR_TOOMANYPRIMITIVES MAKE_DDHRESULT(2083) +#define D3DERR_INVALIDMATRIX MAKE_DDHRESULT(2084) +#define D3DERR_TOOMANYVERTICES MAKE_DDHRESULT(2085) +#define D3DERR_CONFLICTINGTEXTUREPALETTE MAKE_DDHRESULT(2086) + +#endif /* DIRECT3D_VERSION >= 0x0600 */ + +#if(DIRECT3D_VERSION >= 0x0700) +#define D3DERR_INVALIDSTATEBLOCK MAKE_DDHRESULT(2100) +#define D3DERR_INBEGINSTATEBLOCK MAKE_DDHRESULT(2101) +#define D3DERR_NOTINBEGINSTATEBLOCK MAKE_DDHRESULT(2102) +#endif /* DIRECT3D_VERSION >= 0x0700 */ + + +#ifdef __cplusplus +}; +#endif + +#endif /* _D3D_H_ */ + diff --git a/engine/libs/dxsdk7/include/d3dcaps.h b/engine/libs/dxsdk7/include/d3dcaps.h new file mode 100644 index 000000000..0f0a9ff1f --- /dev/null +++ b/engine/libs/dxsdk7/include/d3dcaps.h @@ -0,0 +1,593 @@ +/*==========================================================================; + * + * + * File: d3dcaps.h + * Content: Direct3D capabilities include file + * + ***************************************************************************/ + +#ifndef _D3DCAPS_H +#define _D3DCAPS_H + +/* + * Pull in DirectDraw include file automatically: + */ +#include "ddraw.h" + +#ifndef DIRECT3D_VERSION +#define DIRECT3D_VERSION 0x0700 +#endif + +#pragma pack(4) + +/* Description of capabilities of transform */ + +typedef struct _D3DTRANSFORMCAPS { + DWORD dwSize; + DWORD dwCaps; +} D3DTRANSFORMCAPS, *LPD3DTRANSFORMCAPS; + +#define D3DTRANSFORMCAPS_CLIP 0x00000001L /* Will clip whilst transforming */ + +/* Description of capabilities of lighting */ + +typedef struct _D3DLIGHTINGCAPS { + DWORD dwSize; + DWORD dwCaps; /* Lighting caps */ + DWORD dwLightingModel; /* Lighting model - RGB or mono */ + DWORD dwNumLights; /* Number of lights that can be handled */ +} D3DLIGHTINGCAPS, *LPD3DLIGHTINGCAPS; + +#define D3DLIGHTINGMODEL_RGB 0x00000001L +#define D3DLIGHTINGMODEL_MONO 0x00000002L + +#define D3DLIGHTCAPS_POINT 0x00000001L /* Point lights supported */ +#define D3DLIGHTCAPS_SPOT 0x00000002L /* Spot lights supported */ +#define D3DLIGHTCAPS_DIRECTIONAL 0x00000004L /* Directional lights supported */ +#if(DIRECT3D_VERSION < 0x700) +#define D3DLIGHTCAPS_PARALLELPOINT 0x00000008L /* Parallel point lights supported */ +#endif +#if(DIRECT3D_VERSION < 0x500) +#define D3DLIGHTCAPS_GLSPOT 0x00000010L /* GL syle spot lights supported */ +#endif + +/* Description of capabilities for each primitive type */ + +typedef struct _D3DPrimCaps { + DWORD dwSize; + DWORD dwMiscCaps; /* Capability flags */ + DWORD dwRasterCaps; + DWORD dwZCmpCaps; + DWORD dwSrcBlendCaps; + DWORD dwDestBlendCaps; + DWORD dwAlphaCmpCaps; + DWORD dwShadeCaps; + DWORD dwTextureCaps; + DWORD dwTextureFilterCaps; + DWORD dwTextureBlendCaps; + DWORD dwTextureAddressCaps; + DWORD dwStippleWidth; /* maximum width and height of */ + DWORD dwStippleHeight; /* of supported stipple (up to 32x32) */ +} D3DPRIMCAPS, *LPD3DPRIMCAPS; + +/* D3DPRIMCAPS dwMiscCaps */ + +#define D3DPMISCCAPS_MASKPLANES 0x00000001L +#define D3DPMISCCAPS_MASKZ 0x00000002L +#define D3DPMISCCAPS_LINEPATTERNREP 0x00000004L +#define D3DPMISCCAPS_CONFORMANT 0x00000008L +#define D3DPMISCCAPS_CULLNONE 0x00000010L +#define D3DPMISCCAPS_CULLCW 0x00000020L +#define D3DPMISCCAPS_CULLCCW 0x00000040L + +/* D3DPRIMCAPS dwRasterCaps */ + +#define D3DPRASTERCAPS_DITHER 0x00000001L +#define D3DPRASTERCAPS_ROP2 0x00000002L +#define D3DPRASTERCAPS_XOR 0x00000004L +#define D3DPRASTERCAPS_PAT 0x00000008L +#define D3DPRASTERCAPS_ZTEST 0x00000010L +#define D3DPRASTERCAPS_SUBPIXEL 0x00000020L +#define D3DPRASTERCAPS_SUBPIXELX 0x00000040L +#define D3DPRASTERCAPS_FOGVERTEX 0x00000080L +#define D3DPRASTERCAPS_FOGTABLE 0x00000100L +#define D3DPRASTERCAPS_STIPPLE 0x00000200L +#if(DIRECT3D_VERSION >= 0x0500) +#define D3DPRASTERCAPS_ANTIALIASSORTDEPENDENT 0x00000400L +#define D3DPRASTERCAPS_ANTIALIASSORTINDEPENDENT 0x00000800L +#define D3DPRASTERCAPS_ANTIALIASEDGES 0x00001000L +#define D3DPRASTERCAPS_MIPMAPLODBIAS 0x00002000L +#define D3DPRASTERCAPS_ZBIAS 0x00004000L +#define D3DPRASTERCAPS_ZBUFFERLESSHSR 0x00008000L +#define D3DPRASTERCAPS_FOGRANGE 0x00010000L +#define D3DPRASTERCAPS_ANISOTROPY 0x00020000L +#endif /* DIRECT3D_VERSION >= 0x0500 */ +#if(DIRECT3D_VERSION >= 0x0600) +#define D3DPRASTERCAPS_WBUFFER 0x00040000L +#define D3DPRASTERCAPS_TRANSLUCENTSORTINDEPENDENT 0x00080000L +#define D3DPRASTERCAPS_WFOG 0x00100000L +#define D3DPRASTERCAPS_ZFOG 0x00200000L +#endif /* DIRECT3D_VERSION >= 0x0600 */ + +/* D3DPRIMCAPS dwZCmpCaps, dwAlphaCmpCaps */ + +#define D3DPCMPCAPS_NEVER 0x00000001L +#define D3DPCMPCAPS_LESS 0x00000002L +#define D3DPCMPCAPS_EQUAL 0x00000004L +#define D3DPCMPCAPS_LESSEQUAL 0x00000008L +#define D3DPCMPCAPS_GREATER 0x00000010L +#define D3DPCMPCAPS_NOTEQUAL 0x00000020L +#define D3DPCMPCAPS_GREATEREQUAL 0x00000040L +#define D3DPCMPCAPS_ALWAYS 0x00000080L + +/* D3DPRIMCAPS dwSourceBlendCaps, dwDestBlendCaps */ + +#define D3DPBLENDCAPS_ZERO 0x00000001L +#define D3DPBLENDCAPS_ONE 0x00000002L +#define D3DPBLENDCAPS_SRCCOLOR 0x00000004L +#define D3DPBLENDCAPS_INVSRCCOLOR 0x00000008L +#define D3DPBLENDCAPS_SRCALPHA 0x00000010L +#define D3DPBLENDCAPS_INVSRCALPHA 0x00000020L +#define D3DPBLENDCAPS_DESTALPHA 0x00000040L +#define D3DPBLENDCAPS_INVDESTALPHA 0x00000080L +#define D3DPBLENDCAPS_DESTCOLOR 0x00000100L +#define D3DPBLENDCAPS_INVDESTCOLOR 0x00000200L +#define D3DPBLENDCAPS_SRCALPHASAT 0x00000400L +#define D3DPBLENDCAPS_BOTHSRCALPHA 0x00000800L +#define D3DPBLENDCAPS_BOTHINVSRCALPHA 0x00001000L + +/* D3DPRIMCAPS dwShadeCaps */ + +#define D3DPSHADECAPS_COLORFLATMONO 0x00000001L +#define D3DPSHADECAPS_COLORFLATRGB 0x00000002L +#define D3DPSHADECAPS_COLORGOURAUDMONO 0x00000004L +#define D3DPSHADECAPS_COLORGOURAUDRGB 0x00000008L +#define D3DPSHADECAPS_COLORPHONGMONO 0x00000010L +#define D3DPSHADECAPS_COLORPHONGRGB 0x00000020L + +#define D3DPSHADECAPS_SPECULARFLATMONO 0x00000040L +#define D3DPSHADECAPS_SPECULARFLATRGB 0x00000080L +#define D3DPSHADECAPS_SPECULARGOURAUDMONO 0x00000100L +#define D3DPSHADECAPS_SPECULARGOURAUDRGB 0x00000200L +#define D3DPSHADECAPS_SPECULARPHONGMONO 0x00000400L +#define D3DPSHADECAPS_SPECULARPHONGRGB 0x00000800L + +#define D3DPSHADECAPS_ALPHAFLATBLEND 0x00001000L +#define D3DPSHADECAPS_ALPHAFLATSTIPPLED 0x00002000L +#define D3DPSHADECAPS_ALPHAGOURAUDBLEND 0x00004000L +#define D3DPSHADECAPS_ALPHAGOURAUDSTIPPLED 0x00008000L +#define D3DPSHADECAPS_ALPHAPHONGBLEND 0x00010000L +#define D3DPSHADECAPS_ALPHAPHONGSTIPPLED 0x00020000L + +#define D3DPSHADECAPS_FOGFLAT 0x00040000L +#define D3DPSHADECAPS_FOGGOURAUD 0x00080000L +#define D3DPSHADECAPS_FOGPHONG 0x00100000L + +/* D3DPRIMCAPS dwTextureCaps */ + +/* + * Perspective-correct texturing is supported + */ +#define D3DPTEXTURECAPS_PERSPECTIVE 0x00000001L + +/* + * Power-of-2 texture dimensions are required + */ +#define D3DPTEXTURECAPS_POW2 0x00000002L + +/* + * Alpha in texture pixels is supported + */ +#define D3DPTEXTURECAPS_ALPHA 0x00000004L + +/* + * Color-keyed textures are supported + */ +#define D3DPTEXTURECAPS_TRANSPARENCY 0x00000008L + +/* + * obsolete, see D3DPTADDRESSCAPS_BORDER + */ +#define D3DPTEXTURECAPS_BORDER 0x00000010L + +/* + * Only square textures are supported + */ +#define D3DPTEXTURECAPS_SQUAREONLY 0x00000020L + +#if(DIRECT3D_VERSION >= 0x0600) +/* + * Texture indices are not scaled by the texture size prior + * to interpolation. + */ +#define D3DPTEXTURECAPS_TEXREPEATNOTSCALEDBYSIZE 0x00000040L + +/* + * Device can draw alpha from texture palettes + */ +#define D3DPTEXTURECAPS_ALPHAPALETTE 0x00000080L + +/* + * Device can use non-POW2 textures if: + * 1) D3DTEXTURE_ADDRESS is set to CLAMP for this texture's stage + * 2) D3DRS_WRAP(N) is zero for this texture's coordinates + * 3) mip mapping is not enabled (use magnification filter only) + */ +#define D3DPTEXTURECAPS_NONPOW2CONDITIONAL 0x00000100L + +#endif /* DIRECT3D_VERSION >= 0x0600 */ +#if(DIRECT3D_VERSION >= 0x0700) + +// 0x00000200L unused + +/* + * Device can divide transformed texture coordinates by the + * COUNTth texture coordinate (can do D3DTTFF_PROJECTED) + */ +#define D3DPTEXTURECAPS_PROJECTED 0x00000400L + +/* + * Device can do cubemap textures + */ +#define D3DPTEXTURECAPS_CUBEMAP 0x00000800L + +#define D3DPTEXTURECAPS_COLORKEYBLEND 0x00001000L +#endif /* DIRECT3D_VERSION >= 0x0700 */ + +/* D3DPRIMCAPS dwTextureFilterCaps */ + +#define D3DPTFILTERCAPS_NEAREST 0x00000001L +#define D3DPTFILTERCAPS_LINEAR 0x00000002L +#define D3DPTFILTERCAPS_MIPNEAREST 0x00000004L +#define D3DPTFILTERCAPS_MIPLINEAR 0x00000008L +#define D3DPTFILTERCAPS_LINEARMIPNEAREST 0x00000010L +#define D3DPTFILTERCAPS_LINEARMIPLINEAR 0x00000020L + +#if(DIRECT3D_VERSION >= 0x0600) +/* Device3 Min Filter */ +#define D3DPTFILTERCAPS_MINFPOINT 0x00000100L +#define D3DPTFILTERCAPS_MINFLINEAR 0x00000200L +#define D3DPTFILTERCAPS_MINFANISOTROPIC 0x00000400L + +/* Device3 Mip Filter */ +#define D3DPTFILTERCAPS_MIPFPOINT 0x00010000L +#define D3DPTFILTERCAPS_MIPFLINEAR 0x00020000L + +/* Device3 Mag Filter */ +#define D3DPTFILTERCAPS_MAGFPOINT 0x01000000L +#define D3DPTFILTERCAPS_MAGFLINEAR 0x02000000L +#define D3DPTFILTERCAPS_MAGFANISOTROPIC 0x04000000L +#define D3DPTFILTERCAPS_MAGFAFLATCUBIC 0x08000000L +#define D3DPTFILTERCAPS_MAGFGAUSSIANCUBIC 0x10000000L +#endif /* DIRECT3D_VERSION >= 0x0600 */ + +/* D3DPRIMCAPS dwTextureBlendCaps */ + +#define D3DPTBLENDCAPS_DECAL 0x00000001L +#define D3DPTBLENDCAPS_MODULATE 0x00000002L +#define D3DPTBLENDCAPS_DECALALPHA 0x00000004L +#define D3DPTBLENDCAPS_MODULATEALPHA 0x00000008L +#define D3DPTBLENDCAPS_DECALMASK 0x00000010L +#define D3DPTBLENDCAPS_MODULATEMASK 0x00000020L +#define D3DPTBLENDCAPS_COPY 0x00000040L +#if(DIRECT3D_VERSION >= 0x0500) +#define D3DPTBLENDCAPS_ADD 0x00000080L +#endif /* DIRECT3D_VERSION >= 0x0500 */ + +/* D3DPRIMCAPS dwTextureAddressCaps */ +#define D3DPTADDRESSCAPS_WRAP 0x00000001L +#define D3DPTADDRESSCAPS_MIRROR 0x00000002L +#define D3DPTADDRESSCAPS_CLAMP 0x00000004L +#if(DIRECT3D_VERSION >= 0x0500) +#define D3DPTADDRESSCAPS_BORDER 0x00000008L +#define D3DPTADDRESSCAPS_INDEPENDENTUV 0x00000010L +#endif /* DIRECT3D_VERSION >= 0x0500 */ + +#if(DIRECT3D_VERSION >= 0x0600) + +/* D3DDEVICEDESC dwStencilCaps */ + +#define D3DSTENCILCAPS_KEEP 0x00000001L +#define D3DSTENCILCAPS_ZERO 0x00000002L +#define D3DSTENCILCAPS_REPLACE 0x00000004L +#define D3DSTENCILCAPS_INCRSAT 0x00000008L +#define D3DSTENCILCAPS_DECRSAT 0x00000010L +#define D3DSTENCILCAPS_INVERT 0x00000020L +#define D3DSTENCILCAPS_INCR 0x00000040L +#define D3DSTENCILCAPS_DECR 0x00000080L + +/* D3DDEVICEDESC dwTextureOpCaps */ + +#define D3DTEXOPCAPS_DISABLE 0x00000001L +#define D3DTEXOPCAPS_SELECTARG1 0x00000002L +#define D3DTEXOPCAPS_SELECTARG2 0x00000004L +#define D3DTEXOPCAPS_MODULATE 0x00000008L +#define D3DTEXOPCAPS_MODULATE2X 0x00000010L +#define D3DTEXOPCAPS_MODULATE4X 0x00000020L +#define D3DTEXOPCAPS_ADD 0x00000040L +#define D3DTEXOPCAPS_ADDSIGNED 0x00000080L +#define D3DTEXOPCAPS_ADDSIGNED2X 0x00000100L +#define D3DTEXOPCAPS_SUBTRACT 0x00000200L +#define D3DTEXOPCAPS_ADDSMOOTH 0x00000400L +#define D3DTEXOPCAPS_BLENDDIFFUSEALPHA 0x00000800L +#define D3DTEXOPCAPS_BLENDTEXTUREALPHA 0x00001000L +#define D3DTEXOPCAPS_BLENDFACTORALPHA 0x00002000L +#define D3DTEXOPCAPS_BLENDTEXTUREALPHAPM 0x00004000L +#define D3DTEXOPCAPS_BLENDCURRENTALPHA 0x00008000L +#define D3DTEXOPCAPS_PREMODULATE 0x00010000L +#define D3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR 0x00020000L +#define D3DTEXOPCAPS_MODULATECOLOR_ADDALPHA 0x00040000L +#define D3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR 0x00080000L +#define D3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA 0x00100000L +#define D3DTEXOPCAPS_BUMPENVMAP 0x00200000L +#define D3DTEXOPCAPS_BUMPENVMAPLUMINANCE 0x00400000L +#define D3DTEXOPCAPS_DOTPRODUCT3 0x00800000L + +/* D3DDEVICEDESC dwFVFCaps flags */ + +#define D3DFVFCAPS_TEXCOORDCOUNTMASK 0x0000ffffL /* mask for texture coordinate count field */ +#define D3DFVFCAPS_DONOTSTRIPELEMENTS 0x00080000L /* Device prefers that vertex elements not be stripped */ + +#endif /* DIRECT3D_VERSION >= 0x0600 */ + +/* + * Description for a device. + * This is used to describe a device that is to be created or to query + * the current device. + */ +typedef struct _D3DDeviceDesc { + DWORD dwSize; /* Size of D3DDEVICEDESC structure */ + DWORD dwFlags; /* Indicates which fields have valid data */ + D3DCOLORMODEL dcmColorModel; /* Color model of device */ + DWORD dwDevCaps; /* Capabilities of device */ + D3DTRANSFORMCAPS dtcTransformCaps; /* Capabilities of transform */ + BOOL bClipping; /* Device can do 3D clipping */ + D3DLIGHTINGCAPS dlcLightingCaps; /* Capabilities of lighting */ + D3DPRIMCAPS dpcLineCaps; + D3DPRIMCAPS dpcTriCaps; + DWORD dwDeviceRenderBitDepth; /* One of DDBB_8, 16, etc.. */ + DWORD dwDeviceZBufferBitDepth;/* One of DDBD_16, 32, etc.. */ + DWORD dwMaxBufferSize; /* Maximum execute buffer size */ + DWORD dwMaxVertexCount; /* Maximum vertex count */ +#if(DIRECT3D_VERSION >= 0x0500) + // *** New fields for DX5 *** // + + // Width and height caps are 0 for legacy HALs. + DWORD dwMinTextureWidth, dwMinTextureHeight; + DWORD dwMaxTextureWidth, dwMaxTextureHeight; + DWORD dwMinStippleWidth, dwMaxStippleWidth; + DWORD dwMinStippleHeight, dwMaxStippleHeight; +#endif /* DIRECT3D_VERSION >= 0x0500 */ + +#if(DIRECT3D_VERSION >= 0x0600) + // New fields for DX6 + DWORD dwMaxTextureRepeat; + DWORD dwMaxTextureAspectRatio; + DWORD dwMaxAnisotropy; + + // Guard band that the rasterizer can accommodate + // Screen-space vertices inside this space but outside the viewport + // will get clipped properly. + D3DVALUE dvGuardBandLeft; + D3DVALUE dvGuardBandTop; + D3DVALUE dvGuardBandRight; + D3DVALUE dvGuardBandBottom; + + D3DVALUE dvExtentsAdjust; + DWORD dwStencilCaps; + + DWORD dwFVFCaps; + DWORD dwTextureOpCaps; + WORD wMaxTextureBlendStages; + WORD wMaxSimultaneousTextures; +#endif /* DIRECT3D_VERSION >= 0x0600 */ +} D3DDEVICEDESC, *LPD3DDEVICEDESC; + +#if(DIRECT3D_VERSION >= 0x0700) +typedef struct _D3DDeviceDesc7 { + DWORD dwDevCaps; /* Capabilities of device */ + D3DPRIMCAPS dpcLineCaps; + D3DPRIMCAPS dpcTriCaps; + DWORD dwDeviceRenderBitDepth; /* One of DDBB_8, 16, etc.. */ + DWORD dwDeviceZBufferBitDepth;/* One of DDBD_16, 32, etc.. */ + + DWORD dwMinTextureWidth, dwMinTextureHeight; + DWORD dwMaxTextureWidth, dwMaxTextureHeight; + + DWORD dwMaxTextureRepeat; + DWORD dwMaxTextureAspectRatio; + DWORD dwMaxAnisotropy; + + D3DVALUE dvGuardBandLeft; + D3DVALUE dvGuardBandTop; + D3DVALUE dvGuardBandRight; + D3DVALUE dvGuardBandBottom; + + D3DVALUE dvExtentsAdjust; + DWORD dwStencilCaps; + + DWORD dwFVFCaps; + DWORD dwTextureOpCaps; + WORD wMaxTextureBlendStages; + WORD wMaxSimultaneousTextures; + + DWORD dwMaxActiveLights; + D3DVALUE dvMaxVertexW; + GUID deviceGUID; + + WORD wMaxUserClipPlanes; + WORD wMaxVertexBlendMatrices; + + DWORD dwVertexProcessingCaps; + + DWORD dwReserved1; + DWORD dwReserved2; + DWORD dwReserved3; + DWORD dwReserved4; +} D3DDEVICEDESC7, *LPD3DDEVICEDESC7; +#endif /* DIRECT3D_VERSION >= 0x0700 */ + +#define D3DDEVICEDESCSIZE (sizeof(D3DDEVICEDESC)) +#define D3DDEVICEDESC7SIZE (sizeof(D3DDEVICEDESC7)) + +typedef HRESULT (CALLBACK * LPD3DENUMDEVICESCALLBACK)(GUID FAR *lpGuid, LPSTR lpDeviceDescription, LPSTR lpDeviceName, LPD3DDEVICEDESC, LPD3DDEVICEDESC, LPVOID); + +#if(DIRECT3D_VERSION >= 0x0700) +typedef HRESULT (CALLBACK * LPD3DENUMDEVICESCALLBACK7)(LPSTR lpDeviceDescription, LPSTR lpDeviceName, LPD3DDEVICEDESC7, LPVOID); +#endif /* DIRECT3D_VERSION >= 0x0700 */ + +/* D3DDEVICEDESC dwFlags indicating valid fields */ + +#define D3DDD_COLORMODEL 0x00000001L /* dcmColorModel is valid */ +#define D3DDD_DEVCAPS 0x00000002L /* dwDevCaps is valid */ +#define D3DDD_TRANSFORMCAPS 0x00000004L /* dtcTransformCaps is valid */ +#define D3DDD_LIGHTINGCAPS 0x00000008L /* dlcLightingCaps is valid */ +#define D3DDD_BCLIPPING 0x00000010L /* bClipping is valid */ +#define D3DDD_LINECAPS 0x00000020L /* dpcLineCaps is valid */ +#define D3DDD_TRICAPS 0x00000040L /* dpcTriCaps is valid */ +#define D3DDD_DEVICERENDERBITDEPTH 0x00000080L /* dwDeviceRenderBitDepth is valid */ +#define D3DDD_DEVICEZBUFFERBITDEPTH 0x00000100L /* dwDeviceZBufferBitDepth is valid */ +#define D3DDD_MAXBUFFERSIZE 0x00000200L /* dwMaxBufferSize is valid */ +#define D3DDD_MAXVERTEXCOUNT 0x00000400L /* dwMaxVertexCount is valid */ + +/* D3DDEVICEDESC dwDevCaps flags */ + +#define D3DDEVCAPS_FLOATTLVERTEX 0x00000001L /* Device accepts floating point */ + /* for post-transform vertex data */ +#define D3DDEVCAPS_SORTINCREASINGZ 0x00000002L /* Device needs data sorted for increasing Z */ +#define D3DDEVCAPS_SORTDECREASINGZ 0X00000004L /* Device needs data sorted for decreasing Z */ +#define D3DDEVCAPS_SORTEXACT 0x00000008L /* Device needs data sorted exactly */ + +#define D3DDEVCAPS_EXECUTESYSTEMMEMORY 0x00000010L /* Device can use execute buffers from system memory */ +#define D3DDEVCAPS_EXECUTEVIDEOMEMORY 0x00000020L /* Device can use execute buffers from video memory */ +#define D3DDEVCAPS_TLVERTEXSYSTEMMEMORY 0x00000040L /* Device can use TL buffers from system memory */ +#define D3DDEVCAPS_TLVERTEXVIDEOMEMORY 0x00000080L /* Device can use TL buffers from video memory */ +#define D3DDEVCAPS_TEXTURESYSTEMMEMORY 0x00000100L /* Device can texture from system memory */ +#define D3DDEVCAPS_TEXTUREVIDEOMEMORY 0x00000200L /* Device can texture from device memory */ +#if(DIRECT3D_VERSION >= 0x0500) +#define D3DDEVCAPS_DRAWPRIMTLVERTEX 0x00000400L /* Device can draw TLVERTEX primitives */ +#define D3DDEVCAPS_CANRENDERAFTERFLIP 0x00000800L /* Device can render without waiting for flip to complete */ +#define D3DDEVCAPS_TEXTURENONLOCALVIDMEM 0x00001000L /* Device can texture from nonlocal video memory */ +#endif /* DIRECT3D_VERSION >= 0x0500 */ +#if(DIRECT3D_VERSION >= 0x0600) +#define D3DDEVCAPS_DRAWPRIMITIVES2 0x00002000L /* Device can support DrawPrimitives2 */ +#define D3DDEVCAPS_SEPARATETEXTUREMEMORIES 0x00004000L /* Device is texturing from separate memory pools */ +#define D3DDEVCAPS_DRAWPRIMITIVES2EX 0x00008000L /* Device can support Extended DrawPrimitives2 i.e. DX7 compliant driver*/ +#endif /* DIRECT3D_VERSION >= 0x0600 */ +#if(DIRECT3D_VERSION >= 0x0700) +#define D3DDEVCAPS_HWTRANSFORMANDLIGHT 0x00010000L /* Device can support transformation and lighting in hardware and DRAWPRIMITIVES2EX must be also */ +#define D3DDEVCAPS_CANBLTSYSTONONLOCAL 0x00020000L /* Device supports a Tex Blt from system memory to non-local vidmem */ +#define D3DDEVCAPS_HWRASTERIZATION 0x00080000L /* Device has HW acceleration for rasterization */ + +/* + * These are the flags in the D3DDEVICEDESC7.dwVertexProcessingCaps field + */ + +/* device can do texgen */ +#define D3DVTXPCAPS_TEXGEN 0x00000001L +/* device can do IDirect3DDevice7 colormaterialsource ops */ +#define D3DVTXPCAPS_MATERIALSOURCE7 0x00000002L +/* device can do vertex fog */ +#define D3DVTXPCAPS_VERTEXFOG 0x00000004L +/* device can do directional lights */ +#define D3DVTXPCAPS_DIRECTIONALLIGHTS 0x00000008L +/* device can do positional lights (includes point and spot) */ +#define D3DVTXPCAPS_POSITIONALLIGHTS 0x00000010L +/* device can do local viewer */ +#define D3DVTXPCAPS_LOCALVIEWER 0x00000020L + +#endif /* DIRECT3D_VERSION >= 0x0700 */ + +#define D3DFDS_COLORMODEL 0x00000001L /* Match color model */ +#define D3DFDS_GUID 0x00000002L /* Match guid */ +#define D3DFDS_HARDWARE 0x00000004L /* Match hardware/software */ +#define D3DFDS_TRIANGLES 0x00000008L /* Match in triCaps */ +#define D3DFDS_LINES 0x00000010L /* Match in lineCaps */ +#define D3DFDS_MISCCAPS 0x00000020L /* Match primCaps.dwMiscCaps */ +#define D3DFDS_RASTERCAPS 0x00000040L /* Match primCaps.dwRasterCaps */ +#define D3DFDS_ZCMPCAPS 0x00000080L /* Match primCaps.dwZCmpCaps */ +#define D3DFDS_ALPHACMPCAPS 0x00000100L /* Match primCaps.dwAlphaCmpCaps */ +#define D3DFDS_SRCBLENDCAPS 0x00000200L /* Match primCaps.dwSourceBlendCaps */ +#define D3DFDS_DSTBLENDCAPS 0x00000400L /* Match primCaps.dwDestBlendCaps */ +#define D3DFDS_SHADECAPS 0x00000800L /* Match primCaps.dwShadeCaps */ +#define D3DFDS_TEXTURECAPS 0x00001000L /* Match primCaps.dwTextureCaps */ +#define D3DFDS_TEXTUREFILTERCAPS 0x00002000L /* Match primCaps.dwTextureFilterCaps */ +#define D3DFDS_TEXTUREBLENDCAPS 0x00004000L /* Match primCaps.dwTextureBlendCaps */ +#define D3DFDS_TEXTUREADDRESSCAPS 0x00008000L /* Match primCaps.dwTextureBlendCaps */ + +/* + * FindDevice arguments + */ +typedef struct _D3DFINDDEVICESEARCH { + DWORD dwSize; + DWORD dwFlags; + BOOL bHardware; + D3DCOLORMODEL dcmColorModel; + GUID guid; + DWORD dwCaps; + D3DPRIMCAPS dpcPrimCaps; +} D3DFINDDEVICESEARCH, *LPD3DFINDDEVICESEARCH; + +typedef struct _D3DFINDDEVICERESULT { + DWORD dwSize; + GUID guid; /* guid which matched */ + D3DDEVICEDESC ddHwDesc; /* hardware D3DDEVICEDESC */ + D3DDEVICEDESC ddSwDesc; /* software D3DDEVICEDESC */ +} D3DFINDDEVICERESULT, *LPD3DFINDDEVICERESULT; + +/* + * Description of execute buffer. + */ +typedef struct _D3DExecuteBufferDesc { + DWORD dwSize; /* size of this structure */ + DWORD dwFlags; /* flags indicating which fields are valid */ + DWORD dwCaps; /* capabilities of execute buffer */ + DWORD dwBufferSize; /* size of execute buffer data */ + LPVOID lpData; /* pointer to actual data */ +} D3DEXECUTEBUFFERDESC, *LPD3DEXECUTEBUFFERDESC; + +/* D3DEXECUTEBUFFER dwFlags indicating valid fields */ + +#define D3DDEB_BUFSIZE 0x00000001l /* buffer size valid */ +#define D3DDEB_CAPS 0x00000002l /* caps valid */ +#define D3DDEB_LPDATA 0x00000004l /* lpData valid */ + +/* D3DEXECUTEBUFFER dwCaps */ + +#define D3DDEBCAPS_SYSTEMMEMORY 0x00000001l /* buffer in system memory */ +#define D3DDEBCAPS_VIDEOMEMORY 0x00000002l /* buffer in device memory */ +#define D3DDEBCAPS_MEM (D3DDEBCAPS_SYSTEMMEMORY|D3DDEBCAPS_VIDEOMEMORY) + +#if(DIRECT3D_VERSION >= 0x0700) +typedef struct _D3DDEVINFO_TEXTUREMANAGER { + BOOL bThrashing; /* indicates if thrashing */ + DWORD dwApproxBytesDownloaded; /* Approximate number of bytes downloaded by texture manager */ + DWORD dwNumEvicts; /* number of textures evicted */ + DWORD dwNumVidCreates; /* number of textures created in video memory */ + DWORD dwNumTexturesUsed; /* number of textures used */ + DWORD dwNumUsedTexInVid; /* number of used textures present in video memory */ + DWORD dwWorkingSet; /* number of textures in video memory */ + DWORD dwWorkingSetBytes; /* number of bytes in video memory */ + DWORD dwTotalManaged; /* total number of managed textures */ + DWORD dwTotalBytes; /* total number of bytes of managed textures */ + DWORD dwLastPri; /* priority of last texture evicted */ +} D3DDEVINFO_TEXTUREMANAGER, *LPD3DDEVINFO_TEXTUREMANAGER; + +typedef struct _D3DDEVINFO_TEXTURING { + DWORD dwNumLoads; /* counts Load() API calls */ + DWORD dwApproxBytesLoaded; /* Approximate number bytes loaded via Load() */ + DWORD dwNumPreLoads; /* counts PreLoad() API calls */ + DWORD dwNumSet; /* counts SetTexture() API calls */ + DWORD dwNumCreates; /* counts texture creates */ + DWORD dwNumDestroys; /* counts texture destroys */ + DWORD dwNumSetPriorities; /* counts SetPriority() API calls */ + DWORD dwNumSetLODs; /* counts SetLOD() API calls */ + DWORD dwNumLocks; /* counts number of texture locks */ + DWORD dwNumGetDCs; /* counts number of GetDCs to textures */ +} D3DDEVINFO_TEXTURING, *LPD3DDEVINFO_TEXTURING; +#endif /* DIRECT3D_VERSION >= 0x0700 */ + +#pragma pack() + +#endif /* _D3DCAPS_H_ */ + diff --git a/engine/libs/dxsdk7/include/d3dtypes.h b/engine/libs/dxsdk7/include/d3dtypes.h new file mode 100644 index 000000000..f113896a6 --- /dev/null +++ b/engine/libs/dxsdk7/include/d3dtypes.h @@ -0,0 +1,1820 @@ +/*==========================================================================; + * + * Copyright (C) 1995-1998 Microsoft Corporation. All Rights Reserved. + * + * File: d3dtypes.h + * Content: Direct3D types include file + * + ***************************************************************************/ + +#ifndef _D3DTYPES_H_ +#define _D3DTYPES_H_ + +#include + +#include +#include "ddraw.h" + +#ifndef DIRECT3D_VERSION +#define DIRECT3D_VERSION 0x0700 +#endif + +#ifdef _MSC_VER +#pragma warning(disable:4201) // anonymous unions warning +#endif +#pragma pack(4) + + +/* D3DVALUE is the fundamental Direct3D fractional data type */ + +#define D3DVALP(val, prec) ((float)(val)) +#define D3DVAL(val) ((float)(val)) +typedef float D3DVALUE, *LPD3DVALUE; +#define D3DDivide(a, b) (float)((double) (a) / (double) (b)) +#define D3DMultiply(a, b) ((a) * (b)) + +typedef LONG D3DFIXED; + +#ifndef RGB_MAKE +/* + * Format of CI colors is + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | alpha | color index | fraction | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ +#define CI_GETALPHA(ci) ((ci) >> 24) +#define CI_GETINDEX(ci) (((ci) >> 8) & 0xffff) +#define CI_GETFRACTION(ci) ((ci) & 0xff) +#define CI_ROUNDINDEX(ci) CI_GETINDEX((ci) + 0x80) +#define CI_MASKALPHA(ci) ((ci) & 0xffffff) +#define CI_MAKE(a, i, f) (((a) << 24) | ((i) << 8) | (f)) + +/* + * Format of RGBA colors is + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | alpha | red | green | blue | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ +#define RGBA_GETALPHA(rgb) ((rgb) >> 24) +#define RGBA_GETRED(rgb) (((rgb) >> 16) & 0xff) +#define RGBA_GETGREEN(rgb) (((rgb) >> 8) & 0xff) +#define RGBA_GETBLUE(rgb) ((rgb) & 0xff) +#define RGBA_MAKE(r, g, b, a) ((D3DCOLOR) (((a) << 24) | ((r) << 16) | ((g) << 8) | (b))) + +/* D3DRGB and D3DRGBA may be used as initialisers for D3DCOLORs + * The float values must be in the range 0..1 + */ +#define D3DRGB(r, g, b) \ + (0xff000000L | ( ((long)((r) * 255)) << 16) | (((long)((g) * 255)) << 8) | (long)((b) * 255)) +#define D3DRGBA(r, g, b, a) \ + ( (((long)((a) * 255)) << 24) | (((long)((r) * 255)) << 16) \ + | (((long)((g) * 255)) << 8) | (long)((b) * 255) \ + ) + +/* + * Format of RGB colors is + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | ignored | red | green | blue | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ +#define RGB_GETRED(rgb) (((rgb) >> 16) & 0xff) +#define RGB_GETGREEN(rgb) (((rgb) >> 8) & 0xff) +#define RGB_GETBLUE(rgb) ((rgb) & 0xff) +#define RGBA_SETALPHA(rgba, x) (((x) << 24) | ((rgba) & 0x00ffffff)) +#define RGB_MAKE(r, g, b) ((D3DCOLOR) (((r) << 16) | ((g) << 8) | (b))) +#define RGBA_TORGB(rgba) ((D3DCOLOR) ((rgba) & 0xffffff)) +#define RGB_TORGBA(rgb) ((D3DCOLOR) ((rgb) | 0xff000000)) + +#endif + +/* + * Flags for Enumerate functions + */ + +/* + * Stop the enumeration + */ +#define D3DENUMRET_CANCEL DDENUMRET_CANCEL + +/* + * Continue the enumeration + */ +#define D3DENUMRET_OK DDENUMRET_OK + +typedef HRESULT (CALLBACK* LPD3DVALIDATECALLBACK)(LPVOID lpUserArg, DWORD dwOffset); +typedef HRESULT (CALLBACK* LPD3DENUMTEXTUREFORMATSCALLBACK)(LPDDSURFACEDESC lpDdsd, LPVOID lpContext); +typedef HRESULT (CALLBACK* LPD3DENUMPIXELFORMATSCALLBACK)(LPDDPIXELFORMAT lpDDPixFmt, LPVOID lpContext); + +typedef DWORD D3DCOLOR, *LPD3DCOLOR; + +typedef DWORD D3DMATERIALHANDLE, *LPD3DMATERIALHANDLE; +typedef DWORD D3DTEXTUREHANDLE, *LPD3DTEXTUREHANDLE; +typedef DWORD D3DMATRIXHANDLE, *LPD3DMATRIXHANDLE; + +typedef struct _D3DCOLORVALUE { + union { + D3DVALUE r; + D3DVALUE dvR; + }; + union { + D3DVALUE g; + D3DVALUE dvG; + }; + union { + D3DVALUE b; + D3DVALUE dvB; + }; + union { + D3DVALUE a; + D3DVALUE dvA; + }; +} D3DCOLORVALUE, *LPD3DCOLORVALUE; + +typedef struct _D3DRECT { + union { + LONG x1; + LONG lX1; + }; + union { + LONG y1; + LONG lY1; + }; + union { + LONG x2; + LONG lX2; + }; + union { + LONG y2; + LONG lY2; + }; +} D3DRECT, *LPD3DRECT; + +typedef struct _D3DVECTOR { + union { + D3DVALUE x; + D3DVALUE dvX; + }; + union { + D3DVALUE y; + D3DVALUE dvY; + }; + union { + D3DVALUE z; + D3DVALUE dvZ; + }; +#if(DIRECT3D_VERSION >= 0x0500) +#if (defined __cplusplus) && (defined D3D_OVERLOADS) + +public: + + // ===================================== + // Constructors + // ===================================== + + _D3DVECTOR() { } + _D3DVECTOR(D3DVALUE f); + _D3DVECTOR(D3DVALUE _x, D3DVALUE _y, D3DVALUE _z); + _D3DVECTOR(const D3DVALUE f[3]); + + // ===================================== + // Access grants + // ===================================== + + const D3DVALUE&operator[](int i) const; + D3DVALUE&operator[](int i); + + // ===================================== + // Assignment operators + // ===================================== + + _D3DVECTOR& operator += (const _D3DVECTOR& v); + _D3DVECTOR& operator -= (const _D3DVECTOR& v); + _D3DVECTOR& operator *= (const _D3DVECTOR& v); + _D3DVECTOR& operator /= (const _D3DVECTOR& v); + _D3DVECTOR& operator *= (D3DVALUE s); + _D3DVECTOR& operator /= (D3DVALUE s); + + // ===================================== + // Unary operators + // ===================================== + + friend _D3DVECTOR operator + (const _D3DVECTOR& v); + friend _D3DVECTOR operator - (const _D3DVECTOR& v); + + + // ===================================== + // Binary operators + // ===================================== + + // Addition and subtraction + friend _D3DVECTOR operator + (const _D3DVECTOR& v1, const _D3DVECTOR& v2); + friend _D3DVECTOR operator - (const _D3DVECTOR& v1, const _D3DVECTOR& v2); + // Scalar multiplication and division + friend _D3DVECTOR operator * (const _D3DVECTOR& v, D3DVALUE s); + friend _D3DVECTOR operator * (D3DVALUE s, const _D3DVECTOR& v); + friend _D3DVECTOR operator / (const _D3DVECTOR& v, D3DVALUE s); + // Memberwise multiplication and division + friend _D3DVECTOR operator * (const _D3DVECTOR& v1, const _D3DVECTOR& v2); + friend _D3DVECTOR operator / (const _D3DVECTOR& v1, const _D3DVECTOR& v2); + + // Vector dominance + friend int operator < (const _D3DVECTOR& v1, const _D3DVECTOR& v2); + friend int operator <= (const _D3DVECTOR& v1, const _D3DVECTOR& v2); + + // Bitwise equality + friend int operator == (const _D3DVECTOR& v1, const _D3DVECTOR& v2); + + // Length-related functions + friend D3DVALUE SquareMagnitude (const _D3DVECTOR& v); + friend D3DVALUE Magnitude (const _D3DVECTOR& v); + + // Returns vector with same direction and unit length + friend _D3DVECTOR Normalize (const _D3DVECTOR& v); + + // Return min/max component of the input vector + friend D3DVALUE Min (const _D3DVECTOR& v); + friend D3DVALUE Max (const _D3DVECTOR& v); + + // Return memberwise min/max of input vectors + friend _D3DVECTOR Minimize (const _D3DVECTOR& v1, const _D3DVECTOR& v2); + friend _D3DVECTOR Maximize (const _D3DVECTOR& v1, const _D3DVECTOR& v2); + + // Dot and cross product + friend D3DVALUE DotProduct (const _D3DVECTOR& v1, const _D3DVECTOR& v2); + friend _D3DVECTOR CrossProduct (const _D3DVECTOR& v1, const _D3DVECTOR& v2); + +#endif +#endif /* DIRECT3D_VERSION >= 0x0500 */ +} D3DVECTOR, *LPD3DVECTOR; + +/* + * Vertex data types supported in an ExecuteBuffer. + */ + +/* + * Homogeneous vertices + */ + +typedef struct _D3DHVERTEX { + DWORD dwFlags; /* Homogeneous clipping flags */ + union { + D3DVALUE hx; + D3DVALUE dvHX; + }; + union { + D3DVALUE hy; + D3DVALUE dvHY; + }; + union { + D3DVALUE hz; + D3DVALUE dvHZ; + }; +} D3DHVERTEX, *LPD3DHVERTEX; + +/* + * Transformed/lit vertices + */ +typedef struct _D3DTLVERTEX { + union { + D3DVALUE sx; /* Screen coordinates */ + D3DVALUE dvSX; + }; + union { + D3DVALUE sy; + D3DVALUE dvSY; + }; + union { + D3DVALUE sz; + D3DVALUE dvSZ; + }; + union { + D3DVALUE rhw; /* Reciprocal of homogeneous w */ + D3DVALUE dvRHW; + }; + union { + D3DCOLOR color; /* Vertex color */ + D3DCOLOR dcColor; + }; + union { + D3DCOLOR specular; /* Specular component of vertex */ + D3DCOLOR dcSpecular; + }; + union { + D3DVALUE tu; /* Texture coordinates */ + D3DVALUE dvTU; + }; + union { + D3DVALUE tv; + D3DVALUE dvTV; + }; +#if(DIRECT3D_VERSION >= 0x0500) +#if (defined __cplusplus) && (defined D3D_OVERLOADS) + _D3DTLVERTEX() { } + _D3DTLVERTEX(const D3DVECTOR& v, float _rhw, + D3DCOLOR _color, D3DCOLOR _specular, + float _tu, float _tv) + { sx = v.x; sy = v.y; sz = v.z; rhw = _rhw; + color = _color; specular = _specular; + tu = _tu; tv = _tv; + } +#endif +#endif /* DIRECT3D_VERSION >= 0x0500 */ +} D3DTLVERTEX, *LPD3DTLVERTEX; + +/* + * Untransformed/lit vertices + */ +typedef struct _D3DLVERTEX { + union { + D3DVALUE x; /* Homogeneous coordinates */ + D3DVALUE dvX; + }; + union { + D3DVALUE y; + D3DVALUE dvY; + }; + union { + D3DVALUE z; + D3DVALUE dvZ; + }; + DWORD dwReserved; + union { + D3DCOLOR color; /* Vertex color */ + D3DCOLOR dcColor; + }; + union { + D3DCOLOR specular; /* Specular component of vertex */ + D3DCOLOR dcSpecular; + }; + union { + D3DVALUE tu; /* Texture coordinates */ + D3DVALUE dvTU; + }; + union { + D3DVALUE tv; + D3DVALUE dvTV; + }; +#if(DIRECT3D_VERSION >= 0x0500) +#if (defined __cplusplus) && (defined D3D_OVERLOADS) + _D3DLVERTEX() { } + _D3DLVERTEX(const D3DVECTOR& v, + D3DCOLOR _color, D3DCOLOR _specular, + float _tu, float _tv) + { x = v.x; y = v.y; z = v.z; dwReserved = 0; + color = _color; specular = _specular; + tu = _tu; tv = _tv; + } +#endif +#endif /* DIRECT3D_VERSION >= 0x0500 */ +} D3DLVERTEX, *LPD3DLVERTEX; + +/* + * Untransformed/unlit vertices + */ + +typedef struct _D3DVERTEX { + union { + D3DVALUE x; /* Homogeneous coordinates */ + D3DVALUE dvX; + }; + union { + D3DVALUE y; + D3DVALUE dvY; + }; + union { + D3DVALUE z; + D3DVALUE dvZ; + }; + union { + D3DVALUE nx; /* Normal */ + D3DVALUE dvNX; + }; + union { + D3DVALUE ny; + D3DVALUE dvNY; + }; + union { + D3DVALUE nz; + D3DVALUE dvNZ; + }; + union { + D3DVALUE tu; /* Texture coordinates */ + D3DVALUE dvTU; + }; + union { + D3DVALUE tv; + D3DVALUE dvTV; + }; +#if(DIRECT3D_VERSION >= 0x0500) +#if (defined __cplusplus) && (defined D3D_OVERLOADS) + _D3DVERTEX() { } + _D3DVERTEX(const D3DVECTOR& v, const D3DVECTOR& n, float _tu, float _tv) + { x = v.x; y = v.y; z = v.z; + nx = n.x; ny = n.y; nz = n.z; + tu = _tu; tv = _tv; + } +#endif +#endif /* DIRECT3D_VERSION >= 0x0500 */ +} D3DVERTEX, *LPD3DVERTEX; + + +/* + * Matrix, viewport, and tranformation structures and definitions. + */ + +typedef struct _D3DMATRIX { +#if(DIRECT3D_VERSION >= 0x0500) +#if (defined __cplusplus) && (defined D3D_OVERLOADS) + union { + struct { +#endif + +#endif /* DIRECT3D_VERSION >= 0x0500 */ + D3DVALUE _11, _12, _13, _14; + D3DVALUE _21, _22, _23, _24; + D3DVALUE _31, _32, _33, _34; + D3DVALUE _41, _42, _43, _44; + +#if(DIRECT3D_VERSION >= 0x0500) +#if (defined __cplusplus) && (defined D3D_OVERLOADS) + }; + D3DVALUE m[4][4]; + }; + _D3DMATRIX() { } + _D3DMATRIX( D3DVALUE _m00, D3DVALUE _m01, D3DVALUE _m02, D3DVALUE _m03, + D3DVALUE _m10, D3DVALUE _m11, D3DVALUE _m12, D3DVALUE _m13, + D3DVALUE _m20, D3DVALUE _m21, D3DVALUE _m22, D3DVALUE _m23, + D3DVALUE _m30, D3DVALUE _m31, D3DVALUE _m32, D3DVALUE _m33 + ) + { + m[0][0] = _m00; m[0][1] = _m01; m[0][2] = _m02; m[0][3] = _m03; + m[1][0] = _m10; m[1][1] = _m11; m[1][2] = _m12; m[1][3] = _m13; + m[2][0] = _m20; m[2][1] = _m21; m[2][2] = _m22; m[2][3] = _m23; + m[3][0] = _m30; m[3][1] = _m31; m[3][2] = _m32; m[3][3] = _m33; + } + + D3DVALUE& operator()(int iRow, int iColumn) { return m[iRow][iColumn]; } + const D3DVALUE& operator()(int iRow, int iColumn) const { return m[iRow][iColumn]; } +#if(DIRECT3D_VERSION >= 0x0600) + friend _D3DMATRIX operator* (const _D3DMATRIX&, const _D3DMATRIX&); +#endif /* DIRECT3D_VERSION >= 0x0600 */ +#endif +#endif /* DIRECT3D_VERSION >= 0x0500 */ +} D3DMATRIX, *LPD3DMATRIX; + +#if (defined __cplusplus) && (defined D3D_OVERLOADS) +#include "d3dvec.inl" +#endif + +typedef struct _D3DVIEWPORT { + DWORD dwSize; + DWORD dwX; + DWORD dwY; /* Top left */ + DWORD dwWidth; + DWORD dwHeight; /* Dimensions */ + D3DVALUE dvScaleX; /* Scale homogeneous to screen */ + D3DVALUE dvScaleY; /* Scale homogeneous to screen */ + D3DVALUE dvMaxX; /* Min/max homogeneous x coord */ + D3DVALUE dvMaxY; /* Min/max homogeneous y coord */ + D3DVALUE dvMinZ; + D3DVALUE dvMaxZ; /* Min/max homogeneous z coord */ +} D3DVIEWPORT, *LPD3DVIEWPORT; + +#if(DIRECT3D_VERSION >= 0x0500) +typedef struct _D3DVIEWPORT2 { + DWORD dwSize; + DWORD dwX; + DWORD dwY; /* Viewport Top left */ + DWORD dwWidth; + DWORD dwHeight; /* Viewport Dimensions */ + D3DVALUE dvClipX; /* Top left of clip volume */ + D3DVALUE dvClipY; + D3DVALUE dvClipWidth; /* Clip Volume Dimensions */ + D3DVALUE dvClipHeight; + D3DVALUE dvMinZ; /* Min/max of clip Volume */ + D3DVALUE dvMaxZ; +} D3DVIEWPORT2, *LPD3DVIEWPORT2; +#endif /* DIRECT3D_VERSION >= 0x0500 */ + +#if(DIRECT3D_VERSION >= 0x0700) +typedef struct _D3DVIEWPORT7 { + DWORD dwX; + DWORD dwY; /* Viewport Top left */ + DWORD dwWidth; + DWORD dwHeight; /* Viewport Dimensions */ + D3DVALUE dvMinZ; /* Min/max of clip Volume */ + D3DVALUE dvMaxZ; +} D3DVIEWPORT7, *LPD3DVIEWPORT7; +#endif /* DIRECT3D_VERSION >= 0x0700 */ + +/* + * Values for clip fields. + */ + +#if(DIRECT3D_VERSION >= 0x0700) + +// Max number of user clipping planes, supported in D3D. +#define D3DMAXUSERCLIPPLANES 32 + +// These bits could be ORed together to use with D3DRENDERSTATE_CLIPPLANEENABLE +// +#define D3DCLIPPLANE0 (1 << 0) +#define D3DCLIPPLANE1 (1 << 1) +#define D3DCLIPPLANE2 (1 << 2) +#define D3DCLIPPLANE3 (1 << 3) +#define D3DCLIPPLANE4 (1 << 4) +#define D3DCLIPPLANE5 (1 << 5) + +#endif /* DIRECT3D_VERSION >= 0x0700 */ + +#define D3DCLIP_LEFT 0x00000001L +#define D3DCLIP_RIGHT 0x00000002L +#define D3DCLIP_TOP 0x00000004L +#define D3DCLIP_BOTTOM 0x00000008L +#define D3DCLIP_FRONT 0x00000010L +#define D3DCLIP_BACK 0x00000020L +#define D3DCLIP_GEN0 0x00000040L +#define D3DCLIP_GEN1 0x00000080L +#define D3DCLIP_GEN2 0x00000100L +#define D3DCLIP_GEN3 0x00000200L +#define D3DCLIP_GEN4 0x00000400L +#define D3DCLIP_GEN5 0x00000800L + +/* + * Values for d3d status. + */ +#define D3DSTATUS_CLIPUNIONLEFT D3DCLIP_LEFT +#define D3DSTATUS_CLIPUNIONRIGHT D3DCLIP_RIGHT +#define D3DSTATUS_CLIPUNIONTOP D3DCLIP_TOP +#define D3DSTATUS_CLIPUNIONBOTTOM D3DCLIP_BOTTOM +#define D3DSTATUS_CLIPUNIONFRONT D3DCLIP_FRONT +#define D3DSTATUS_CLIPUNIONBACK D3DCLIP_BACK +#define D3DSTATUS_CLIPUNIONGEN0 D3DCLIP_GEN0 +#define D3DSTATUS_CLIPUNIONGEN1 D3DCLIP_GEN1 +#define D3DSTATUS_CLIPUNIONGEN2 D3DCLIP_GEN2 +#define D3DSTATUS_CLIPUNIONGEN3 D3DCLIP_GEN3 +#define D3DSTATUS_CLIPUNIONGEN4 D3DCLIP_GEN4 +#define D3DSTATUS_CLIPUNIONGEN5 D3DCLIP_GEN5 + +#define D3DSTATUS_CLIPINTERSECTIONLEFT 0x00001000L +#define D3DSTATUS_CLIPINTERSECTIONRIGHT 0x00002000L +#define D3DSTATUS_CLIPINTERSECTIONTOP 0x00004000L +#define D3DSTATUS_CLIPINTERSECTIONBOTTOM 0x00008000L +#define D3DSTATUS_CLIPINTERSECTIONFRONT 0x00010000L +#define D3DSTATUS_CLIPINTERSECTIONBACK 0x00020000L +#define D3DSTATUS_CLIPINTERSECTIONGEN0 0x00040000L +#define D3DSTATUS_CLIPINTERSECTIONGEN1 0x00080000L +#define D3DSTATUS_CLIPINTERSECTIONGEN2 0x00100000L +#define D3DSTATUS_CLIPINTERSECTIONGEN3 0x00200000L +#define D3DSTATUS_CLIPINTERSECTIONGEN4 0x00400000L +#define D3DSTATUS_CLIPINTERSECTIONGEN5 0x00800000L +#define D3DSTATUS_ZNOTVISIBLE 0x01000000L +/* Do not use 0x80000000 for any status flags in future as it is reserved */ + +#define D3DSTATUS_CLIPUNIONALL ( \ + D3DSTATUS_CLIPUNIONLEFT | \ + D3DSTATUS_CLIPUNIONRIGHT | \ + D3DSTATUS_CLIPUNIONTOP | \ + D3DSTATUS_CLIPUNIONBOTTOM | \ + D3DSTATUS_CLIPUNIONFRONT | \ + D3DSTATUS_CLIPUNIONBACK | \ + D3DSTATUS_CLIPUNIONGEN0 | \ + D3DSTATUS_CLIPUNIONGEN1 | \ + D3DSTATUS_CLIPUNIONGEN2 | \ + D3DSTATUS_CLIPUNIONGEN3 | \ + D3DSTATUS_CLIPUNIONGEN4 | \ + D3DSTATUS_CLIPUNIONGEN5 \ + ) + +#define D3DSTATUS_CLIPINTERSECTIONALL ( \ + D3DSTATUS_CLIPINTERSECTIONLEFT | \ + D3DSTATUS_CLIPINTERSECTIONRIGHT | \ + D3DSTATUS_CLIPINTERSECTIONTOP | \ + D3DSTATUS_CLIPINTERSECTIONBOTTOM | \ + D3DSTATUS_CLIPINTERSECTIONFRONT | \ + D3DSTATUS_CLIPINTERSECTIONBACK | \ + D3DSTATUS_CLIPINTERSECTIONGEN0 | \ + D3DSTATUS_CLIPINTERSECTIONGEN1 | \ + D3DSTATUS_CLIPINTERSECTIONGEN2 | \ + D3DSTATUS_CLIPINTERSECTIONGEN3 | \ + D3DSTATUS_CLIPINTERSECTIONGEN4 | \ + D3DSTATUS_CLIPINTERSECTIONGEN5 \ + ) + +#define D3DSTATUS_DEFAULT ( \ + D3DSTATUS_CLIPINTERSECTIONALL | \ + D3DSTATUS_ZNOTVISIBLE) + + +/* + * Options for direct transform calls + */ +#define D3DTRANSFORM_CLIPPED 0x00000001l +#define D3DTRANSFORM_UNCLIPPED 0x00000002l + +typedef struct _D3DTRANSFORMDATA { + DWORD dwSize; + LPVOID lpIn; /* Input vertices */ + DWORD dwInSize; /* Stride of input vertices */ + LPVOID lpOut; /* Output vertices */ + DWORD dwOutSize; /* Stride of output vertices */ + LPD3DHVERTEX lpHOut; /* Output homogeneous vertices */ + DWORD dwClip; /* Clipping hint */ + DWORD dwClipIntersection; + DWORD dwClipUnion; /* Union of all clip flags */ + D3DRECT drExtent; /* Extent of transformed vertices */ +} D3DTRANSFORMDATA, *LPD3DTRANSFORMDATA; + +/* + * Structure defining position and direction properties for lighting. + */ +typedef struct _D3DLIGHTINGELEMENT { + D3DVECTOR dvPosition; /* Lightable point in model space */ + D3DVECTOR dvNormal; /* Normalised unit vector */ +} D3DLIGHTINGELEMENT, *LPD3DLIGHTINGELEMENT; + +/* + * Structure defining material properties for lighting. + */ +typedef struct _D3DMATERIAL { + DWORD dwSize; + union { + D3DCOLORVALUE diffuse; /* Diffuse color RGBA */ + D3DCOLORVALUE dcvDiffuse; + }; + union { + D3DCOLORVALUE ambient; /* Ambient color RGB */ + D3DCOLORVALUE dcvAmbient; + }; + union { + D3DCOLORVALUE specular; /* Specular 'shininess' */ + D3DCOLORVALUE dcvSpecular; + }; + union { + D3DCOLORVALUE emissive; /* Emissive color RGB */ + D3DCOLORVALUE dcvEmissive; + }; + union { + D3DVALUE power; /* Sharpness if specular highlight */ + D3DVALUE dvPower; + }; + D3DTEXTUREHANDLE hTexture; /* Handle to texture map */ + DWORD dwRampSize; +} D3DMATERIAL, *LPD3DMATERIAL; + +#if(DIRECT3D_VERSION >= 0x0700) + +typedef struct _D3DMATERIAL7 { + union { + D3DCOLORVALUE diffuse; /* Diffuse color RGBA */ + D3DCOLORVALUE dcvDiffuse; + }; + union { + D3DCOLORVALUE ambient; /* Ambient color RGB */ + D3DCOLORVALUE dcvAmbient; + }; + union { + D3DCOLORVALUE specular; /* Specular 'shininess' */ + D3DCOLORVALUE dcvSpecular; + }; + union { + D3DCOLORVALUE emissive; /* Emissive color RGB */ + D3DCOLORVALUE dcvEmissive; + }; + union { + D3DVALUE power; /* Sharpness if specular highlight */ + D3DVALUE dvPower; + }; +} D3DMATERIAL7, *LPD3DMATERIAL7; + +#endif /* DIRECT3D_VERSION >= 0x0700 */ + +typedef enum _D3DLIGHTTYPE { + D3DLIGHT_POINT = 1, + D3DLIGHT_SPOT = 2, + D3DLIGHT_DIRECTIONAL = 3, +// Note: The following light type (D3DLIGHT_PARALLELPOINT) +// is no longer supported from D3D for DX7 onwards. + D3DLIGHT_PARALLELPOINT = 4, +#if(DIRECT3D_VERSION < 0x0500) // For backward compatible headers + D3DLIGHT_GLSPOT = 5, +#endif + D3DLIGHT_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ +} D3DLIGHTTYPE; + +/* + * Structure defining a light source and its properties. + */ +typedef struct _D3DLIGHT { + DWORD dwSize; + D3DLIGHTTYPE dltType; /* Type of light source */ + D3DCOLORVALUE dcvColor; /* Color of light */ + D3DVECTOR dvPosition; /* Position in world space */ + D3DVECTOR dvDirection; /* Direction in world space */ + D3DVALUE dvRange; /* Cutoff range */ + D3DVALUE dvFalloff; /* Falloff */ + D3DVALUE dvAttenuation0; /* Constant attenuation */ + D3DVALUE dvAttenuation1; /* Linear attenuation */ + D3DVALUE dvAttenuation2; /* Quadratic attenuation */ + D3DVALUE dvTheta; /* Inner angle of spotlight cone */ + D3DVALUE dvPhi; /* Outer angle of spotlight cone */ +} D3DLIGHT, *LPD3DLIGHT; + +#if(DIRECT3D_VERSION >= 0x0700) + +typedef struct _D3DLIGHT7 { + D3DLIGHTTYPE dltType; /* Type of light source */ + D3DCOLORVALUE dcvDiffuse; /* Diffuse color of light */ + D3DCOLORVALUE dcvSpecular; /* Specular color of light */ + D3DCOLORVALUE dcvAmbient; /* Ambient color of light */ + D3DVECTOR dvPosition; /* Position in world space */ + D3DVECTOR dvDirection; /* Direction in world space */ + D3DVALUE dvRange; /* Cutoff range */ + D3DVALUE dvFalloff; /* Falloff */ + D3DVALUE dvAttenuation0; /* Constant attenuation */ + D3DVALUE dvAttenuation1; /* Linear attenuation */ + D3DVALUE dvAttenuation2; /* Quadratic attenuation */ + D3DVALUE dvTheta; /* Inner angle of spotlight cone */ + D3DVALUE dvPhi; /* Outer angle of spotlight cone */ +} D3DLIGHT7, *LPD3DLIGHT7; + +#endif /* DIRECT3D_VERSION >= 0x0700 */ + +#if(DIRECT3D_VERSION >= 0x0500) +/* + * Structure defining a light source and its properties. + */ + +/* flags bits */ +#define D3DLIGHT_ACTIVE 0x00000001 +#define D3DLIGHT_NO_SPECULAR 0x00000002 +#define D3DLIGHT_ALL (D3DLIGHT_ACTIVE | D3DLIGHT_NO_SPECULAR) + +/* maximum valid light range */ +#define D3DLIGHT_RANGE_MAX ((float)sqrt(FLT_MAX)) + +typedef struct _D3DLIGHT2 { + DWORD dwSize; + D3DLIGHTTYPE dltType; /* Type of light source */ + D3DCOLORVALUE dcvColor; /* Color of light */ + D3DVECTOR dvPosition; /* Position in world space */ + D3DVECTOR dvDirection; /* Direction in world space */ + D3DVALUE dvRange; /* Cutoff range */ + D3DVALUE dvFalloff; /* Falloff */ + D3DVALUE dvAttenuation0; /* Constant attenuation */ + D3DVALUE dvAttenuation1; /* Linear attenuation */ + D3DVALUE dvAttenuation2; /* Quadratic attenuation */ + D3DVALUE dvTheta; /* Inner angle of spotlight cone */ + D3DVALUE dvPhi; /* Outer angle of spotlight cone */ + DWORD dwFlags; +} D3DLIGHT2, *LPD3DLIGHT2; + +#endif /* DIRECT3D_VERSION >= 0x0500 */ +typedef struct _D3DLIGHTDATA { + DWORD dwSize; + LPD3DLIGHTINGELEMENT lpIn; /* Input positions and normals */ + DWORD dwInSize; /* Stride of input elements */ + LPD3DTLVERTEX lpOut; /* Output colors */ + DWORD dwOutSize; /* Stride of output colors */ +} D3DLIGHTDATA, *LPD3DLIGHTDATA; + +#if(DIRECT3D_VERSION >= 0x0500) +/* + * Before DX5, these values were in an enum called + * D3DCOLORMODEL. This was not correct, since they are + * bit flags. A driver can surface either or both flags + * in the dcmColorModel member of D3DDEVICEDESC. + */ +#define D3DCOLOR_MONO 1 +#define D3DCOLOR_RGB 2 + +typedef DWORD D3DCOLORMODEL; +#endif /* DIRECT3D_VERSION >= 0x0500 */ + +/* + * Options for clearing + */ +#define D3DCLEAR_TARGET 0x00000001l /* Clear target surface */ +#define D3DCLEAR_ZBUFFER 0x00000002l /* Clear target z buffer */ +#if(DIRECT3D_VERSION >= 0x0600) +#define D3DCLEAR_STENCIL 0x00000004l /* Clear stencil planes */ +#endif /* DIRECT3D_VERSION >= 0x0600 */ + +/* + * Execute buffers are allocated via Direct3D. These buffers may then + * be filled by the application with instructions to execute along with + * vertex data. + */ + +/* + * Supported op codes for execute instructions. + */ +typedef enum _D3DOPCODE { + D3DOP_POINT = 1, + D3DOP_LINE = 2, + D3DOP_TRIANGLE = 3, + D3DOP_MATRIXLOAD = 4, + D3DOP_MATRIXMULTIPLY = 5, + D3DOP_STATETRANSFORM = 6, + D3DOP_STATELIGHT = 7, + D3DOP_STATERENDER = 8, + D3DOP_PROCESSVERTICES = 9, + D3DOP_TEXTURELOAD = 10, + D3DOP_EXIT = 11, + D3DOP_BRANCHFORWARD = 12, + D3DOP_SPAN = 13, + D3DOP_SETSTATUS = 14, +#if(DIRECT3D_VERSION >= 0x0500) + D3DOP_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ +#endif /* DIRECT3D_VERSION >= 0x0500 */ +} D3DOPCODE; + +typedef struct _D3DINSTRUCTION { + BYTE bOpcode; /* Instruction opcode */ + BYTE bSize; /* Size of each instruction data unit */ + WORD wCount; /* Count of instruction data units to follow */ +} D3DINSTRUCTION, *LPD3DINSTRUCTION; + +/* + * Structure for texture loads + */ +typedef struct _D3DTEXTURELOAD { + D3DTEXTUREHANDLE hDestTexture; + D3DTEXTUREHANDLE hSrcTexture; +} D3DTEXTURELOAD, *LPD3DTEXTURELOAD; + +/* + * Structure for picking + */ +typedef struct _D3DPICKRECORD { + BYTE bOpcode; + BYTE bPad; + DWORD dwOffset; + D3DVALUE dvZ; +} D3DPICKRECORD, *LPD3DPICKRECORD; + +/* + * The following defines the rendering states which can be set in the + * execute buffer. + */ + +typedef enum _D3DSHADEMODE { + D3DSHADE_FLAT = 1, + D3DSHADE_GOURAUD = 2, + D3DSHADE_PHONG = 3, +#if(DIRECT3D_VERSION >= 0x0500) + D3DSHADE_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ +#endif /* DIRECT3D_VERSION >= 0x0500 */ +} D3DSHADEMODE; + +typedef enum _D3DFILLMODE { + D3DFILL_POINT = 1, + D3DFILL_WIREFRAME = 2, + D3DFILL_SOLID = 3, +#if(DIRECT3D_VERSION >= 0x0500) + D3DFILL_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ +#endif /* DIRECT3D_VERSION >= 0x0500 */ +} D3DFILLMODE; + +typedef struct _D3DLINEPATTERN { + WORD wRepeatFactor; + WORD wLinePattern; +} D3DLINEPATTERN; + +typedef enum _D3DTEXTUREFILTER { + D3DFILTER_NEAREST = 1, + D3DFILTER_LINEAR = 2, + D3DFILTER_MIPNEAREST = 3, + D3DFILTER_MIPLINEAR = 4, + D3DFILTER_LINEARMIPNEAREST = 5, + D3DFILTER_LINEARMIPLINEAR = 6, +#if(DIRECT3D_VERSION >= 0x0500) + D3DFILTER_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ +#endif /* DIRECT3D_VERSION >= 0x0500 */ +} D3DTEXTUREFILTER; + +typedef enum _D3DBLEND { + D3DBLEND_ZERO = 1, + D3DBLEND_ONE = 2, + D3DBLEND_SRCCOLOR = 3, + D3DBLEND_INVSRCCOLOR = 4, + D3DBLEND_SRCALPHA = 5, + D3DBLEND_INVSRCALPHA = 6, + D3DBLEND_DESTALPHA = 7, + D3DBLEND_INVDESTALPHA = 8, + D3DBLEND_DESTCOLOR = 9, + D3DBLEND_INVDESTCOLOR = 10, + D3DBLEND_SRCALPHASAT = 11, + D3DBLEND_BOTHSRCALPHA = 12, + D3DBLEND_BOTHINVSRCALPHA = 13, +#if(DIRECT3D_VERSION >= 0x0500) + D3DBLEND_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ +#endif /* DIRECT3D_VERSION >= 0x0500 */ +} D3DBLEND; + +typedef enum _D3DTEXTUREBLEND { + D3DTBLEND_DECAL = 1, + D3DTBLEND_MODULATE = 2, + D3DTBLEND_DECALALPHA = 3, + D3DTBLEND_MODULATEALPHA = 4, + D3DTBLEND_DECALMASK = 5, + D3DTBLEND_MODULATEMASK = 6, + D3DTBLEND_COPY = 7, +#if(DIRECT3D_VERSION >= 0x0500) + D3DTBLEND_ADD = 8, + D3DTBLEND_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ +#endif /* DIRECT3D_VERSION >= 0x0500 */ +} D3DTEXTUREBLEND; + +typedef enum _D3DTEXTUREADDRESS { + D3DTADDRESS_WRAP = 1, + D3DTADDRESS_MIRROR = 2, + D3DTADDRESS_CLAMP = 3, +#if(DIRECT3D_VERSION >= 0x0500) + D3DTADDRESS_BORDER = 4, + D3DTADDRESS_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ +#endif /* DIRECT3D_VERSION >= 0x0500 */ +} D3DTEXTUREADDRESS; + +typedef enum _D3DCULL { + D3DCULL_NONE = 1, + D3DCULL_CW = 2, + D3DCULL_CCW = 3, +#if(DIRECT3D_VERSION >= 0x0500) + D3DCULL_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ +#endif /* DIRECT3D_VERSION >= 0x0500 */ +} D3DCULL; + +typedef enum _D3DCMPFUNC { + D3DCMP_NEVER = 1, + D3DCMP_LESS = 2, + D3DCMP_EQUAL = 3, + D3DCMP_LESSEQUAL = 4, + D3DCMP_GREATER = 5, + D3DCMP_NOTEQUAL = 6, + D3DCMP_GREATEREQUAL = 7, + D3DCMP_ALWAYS = 8, +#if(DIRECT3D_VERSION >= 0x0500) + D3DCMP_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ +#endif /* DIRECT3D_VERSION >= 0x0500 */ +} D3DCMPFUNC; + +#if(DIRECT3D_VERSION >= 0x0600) +typedef enum _D3DSTENCILOP { + D3DSTENCILOP_KEEP = 1, + D3DSTENCILOP_ZERO = 2, + D3DSTENCILOP_REPLACE = 3, + D3DSTENCILOP_INCRSAT = 4, + D3DSTENCILOP_DECRSAT = 5, + D3DSTENCILOP_INVERT = 6, + D3DSTENCILOP_INCR = 7, + D3DSTENCILOP_DECR = 8, + D3DSTENCILOP_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ +} D3DSTENCILOP; +#endif /* DIRECT3D_VERSION >= 0x0600 */ + +typedef enum _D3DFOGMODE { + D3DFOG_NONE = 0, + D3DFOG_EXP = 1, + D3DFOG_EXP2 = 2, +#if(DIRECT3D_VERSION >= 0x0500) + D3DFOG_LINEAR = 3, + D3DFOG_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ +#endif /* DIRECT3D_VERSION >= 0x0500 */ +} D3DFOGMODE; + +#if(DIRECT3D_VERSION >= 0x0600) +typedef enum _D3DZBUFFERTYPE { + D3DZB_FALSE = 0, + D3DZB_TRUE = 1, // Z buffering + D3DZB_USEW = 2, // W buffering + D3DZB_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ +} D3DZBUFFERTYPE; +#endif /* DIRECT3D_VERSION >= 0x0600 */ + +#if(DIRECT3D_VERSION >= 0x0500) +typedef enum _D3DANTIALIASMODE { + D3DANTIALIAS_NONE = 0, + D3DANTIALIAS_SORTDEPENDENT = 1, + D3DANTIALIAS_SORTINDEPENDENT = 2, + D3DANTIALIAS_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ +} D3DANTIALIASMODE; + +// Vertex types supported by Direct3D +typedef enum _D3DVERTEXTYPE { + D3DVT_VERTEX = 1, + D3DVT_LVERTEX = 2, + D3DVT_TLVERTEX = 3, + D3DVT_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ +} D3DVERTEXTYPE; + +// Primitives supported by draw-primitive API +typedef enum _D3DPRIMITIVETYPE { + D3DPT_POINTLIST = 1, + D3DPT_LINELIST = 2, + D3DPT_LINESTRIP = 3, + D3DPT_TRIANGLELIST = 4, + D3DPT_TRIANGLESTRIP = 5, + D3DPT_TRIANGLEFAN = 6, + D3DPT_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ +} D3DPRIMITIVETYPE; + +#endif /* DIRECT3D_VERSION >= 0x0500 */ +/* + * Amount to add to a state to generate the override for that state. + */ +#define D3DSTATE_OVERRIDE_BIAS 256 + +/* + * A state which sets the override flag for the specified state type. + */ +#define D3DSTATE_OVERRIDE(type) (D3DRENDERSTATETYPE)(((DWORD) (type) + D3DSTATE_OVERRIDE_BIAS)) + +typedef enum _D3DTRANSFORMSTATETYPE { + D3DTRANSFORMSTATE_WORLD = 1, + D3DTRANSFORMSTATE_VIEW = 2, + D3DTRANSFORMSTATE_PROJECTION = 3, +#if(DIRECT3D_VERSION >= 0x0700) + D3DTRANSFORMSTATE_WORLD1 = 4, // 2nd matrix to blend + D3DTRANSFORMSTATE_WORLD2 = 5, // 3rd matrix to blend + D3DTRANSFORMSTATE_WORLD3 = 6, // 4th matrix to blend + D3DTRANSFORMSTATE_TEXTURE0 = 16, + D3DTRANSFORMSTATE_TEXTURE1 = 17, + D3DTRANSFORMSTATE_TEXTURE2 = 18, + D3DTRANSFORMSTATE_TEXTURE3 = 19, + D3DTRANSFORMSTATE_TEXTURE4 = 20, + D3DTRANSFORMSTATE_TEXTURE5 = 21, + D3DTRANSFORMSTATE_TEXTURE6 = 22, + D3DTRANSFORMSTATE_TEXTURE7 = 23, +#endif /* DIRECT3D_VERSION >= 0x0700 */ +#if(DIRECT3D_VERSION >= 0x0500) + D3DTRANSFORMSTATE_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ +#endif /* DIRECT3D_VERSION >= 0x0500 */ +} D3DTRANSFORMSTATETYPE; + +typedef enum _D3DLIGHTSTATETYPE { + D3DLIGHTSTATE_MATERIAL = 1, + D3DLIGHTSTATE_AMBIENT = 2, + D3DLIGHTSTATE_COLORMODEL = 3, + D3DLIGHTSTATE_FOGMODE = 4, + D3DLIGHTSTATE_FOGSTART = 5, + D3DLIGHTSTATE_FOGEND = 6, + D3DLIGHTSTATE_FOGDENSITY = 7, +#if(DIRECT3D_VERSION >= 0x0600) + D3DLIGHTSTATE_COLORVERTEX = 8, +#endif /* DIRECT3D_VERSION >= 0x0600 */ +#if(DIRECT3D_VERSION >= 0x0500) + D3DLIGHTSTATE_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ +#endif /* DIRECT3D_VERSION >= 0x0500 */ +} D3DLIGHTSTATETYPE; + +typedef enum _D3DRENDERSTATETYPE { + D3DRENDERSTATE_ANTIALIAS = 2, /* D3DANTIALIASMODE */ + D3DRENDERSTATE_TEXTUREPERSPECTIVE = 4, /* TRUE for perspective correction */ + D3DRENDERSTATE_ZENABLE = 7, /* D3DZBUFFERTYPE (or TRUE/FALSE for legacy) */ + D3DRENDERSTATE_FILLMODE = 8, /* D3DFILL_MODE */ + D3DRENDERSTATE_SHADEMODE = 9, /* D3DSHADEMODE */ + D3DRENDERSTATE_LINEPATTERN = 10, /* D3DLINEPATTERN */ + D3DRENDERSTATE_ZWRITEENABLE = 14, /* TRUE to enable z writes */ + D3DRENDERSTATE_ALPHATESTENABLE = 15, /* TRUE to enable alpha tests */ + D3DRENDERSTATE_LASTPIXEL = 16, /* TRUE for last-pixel on lines */ + D3DRENDERSTATE_SRCBLEND = 19, /* D3DBLEND */ + D3DRENDERSTATE_DESTBLEND = 20, /* D3DBLEND */ + D3DRENDERSTATE_CULLMODE = 22, /* D3DCULL */ + D3DRENDERSTATE_ZFUNC = 23, /* D3DCMPFUNC */ + D3DRENDERSTATE_ALPHAREF = 24, /* D3DFIXED */ + D3DRENDERSTATE_ALPHAFUNC = 25, /* D3DCMPFUNC */ + D3DRENDERSTATE_DITHERENABLE = 26, /* TRUE to enable dithering */ +#if(DIRECT3D_VERSION >= 0x0500) + D3DRENDERSTATE_ALPHABLENDENABLE = 27, /* TRUE to enable alpha blending */ +#endif /* DIRECT3D_VERSION >= 0x0500 */ + D3DRENDERSTATE_FOGENABLE = 28, /* TRUE to enable fog blending */ + D3DRENDERSTATE_SPECULARENABLE = 29, /* TRUE to enable specular */ + D3DRENDERSTATE_ZVISIBLE = 30, /* TRUE to enable z checking */ + D3DRENDERSTATE_STIPPLEDALPHA = 33, /* TRUE to enable stippled alpha (RGB device only) */ + D3DRENDERSTATE_FOGCOLOR = 34, /* D3DCOLOR */ + D3DRENDERSTATE_FOGTABLEMODE = 35, /* D3DFOGMODE */ +#if(DIRECT3D_VERSION >= 0x0700) + D3DRENDERSTATE_FOGSTART = 36, /* Fog start (for both vertex and pixel fog) */ + D3DRENDERSTATE_FOGEND = 37, /* Fog end */ + D3DRENDERSTATE_FOGDENSITY = 38, /* Fog density */ +#endif /* DIRECT3D_VERSION >= 0x0700 */ +#if(DIRECT3D_VERSION >= 0x0500) + D3DRENDERSTATE_EDGEANTIALIAS = 40, /* TRUE to enable edge antialiasing */ + D3DRENDERSTATE_COLORKEYENABLE = 41, /* TRUE to enable source colorkeyed textures */ + D3DRENDERSTATE_ZBIAS = 47, /* LONG Z bias */ + D3DRENDERSTATE_RANGEFOGENABLE = 48, /* Enables range-based fog */ +#endif /* DIRECT3D_VERSION >= 0x0500 */ + +#if(DIRECT3D_VERSION >= 0x0600) + D3DRENDERSTATE_STENCILENABLE = 52, /* BOOL enable/disable stenciling */ + D3DRENDERSTATE_STENCILFAIL = 53, /* D3DSTENCILOP to do if stencil test fails */ + D3DRENDERSTATE_STENCILZFAIL = 54, /* D3DSTENCILOP to do if stencil test passes and Z test fails */ + D3DRENDERSTATE_STENCILPASS = 55, /* D3DSTENCILOP to do if both stencil and Z tests pass */ + D3DRENDERSTATE_STENCILFUNC = 56, /* D3DCMPFUNC fn. Stencil Test passes if ((ref & mask) stencilfn (stencil & mask)) is true */ + D3DRENDERSTATE_STENCILREF = 57, /* Reference value used in stencil test */ + D3DRENDERSTATE_STENCILMASK = 58, /* Mask value used in stencil test */ + D3DRENDERSTATE_STENCILWRITEMASK = 59, /* Write mask applied to values written to stencil buffer */ + D3DRENDERSTATE_TEXTUREFACTOR = 60, /* D3DCOLOR used for multi-texture blend */ +#endif /* DIRECT3D_VERSION >= 0x0600 */ + +#if(DIRECT3D_VERSION >= 0x0600) + + /* + * 128 values [128, 255] are reserved for texture coordinate wrap flags. + * These are constructed with the D3DWRAP_U and D3DWRAP_V macros. Using + * a flags word preserves forward compatibility with texture coordinates + * that are >2D. + */ + D3DRENDERSTATE_WRAP0 = 128, /* wrap for 1st texture coord. set */ + D3DRENDERSTATE_WRAP1 = 129, /* wrap for 2nd texture coord. set */ + D3DRENDERSTATE_WRAP2 = 130, /* wrap for 3rd texture coord. set */ + D3DRENDERSTATE_WRAP3 = 131, /* wrap for 4th texture coord. set */ + D3DRENDERSTATE_WRAP4 = 132, /* wrap for 5th texture coord. set */ + D3DRENDERSTATE_WRAP5 = 133, /* wrap for 6th texture coord. set */ + D3DRENDERSTATE_WRAP6 = 134, /* wrap for 7th texture coord. set */ + D3DRENDERSTATE_WRAP7 = 135, /* wrap for 8th texture coord. set */ +#endif /* DIRECT3D_VERSION >= 0x0600 */ +#if(DIRECT3D_VERSION >= 0x0700) + D3DRENDERSTATE_CLIPPING = 136, + D3DRENDERSTATE_LIGHTING = 137, + D3DRENDERSTATE_EXTENTS = 138, + D3DRENDERSTATE_AMBIENT = 139, + D3DRENDERSTATE_FOGVERTEXMODE = 140, + D3DRENDERSTATE_COLORVERTEX = 141, + D3DRENDERSTATE_LOCALVIEWER = 142, + D3DRENDERSTATE_NORMALIZENORMALS = 143, + D3DRENDERSTATE_COLORKEYBLENDENABLE = 144, + D3DRENDERSTATE_DIFFUSEMATERIALSOURCE = 145, + D3DRENDERSTATE_SPECULARMATERIALSOURCE = 146, + D3DRENDERSTATE_AMBIENTMATERIALSOURCE = 147, + D3DRENDERSTATE_EMISSIVEMATERIALSOURCE = 148, + D3DRENDERSTATE_VERTEXBLEND = 151, + D3DRENDERSTATE_CLIPPLANEENABLE = 152, + +#endif /* DIRECT3D_VERSION >= 0x0700 */ + +// +// retired renderstates - not supported for DX7 interfaces +// + D3DRENDERSTATE_TEXTUREHANDLE = 1, /* Texture handle for legacy interfaces (Texture,Texture2) */ + D3DRENDERSTATE_TEXTUREADDRESS = 3, /* D3DTEXTUREADDRESS */ + D3DRENDERSTATE_WRAPU = 5, /* TRUE for wrapping in u */ + D3DRENDERSTATE_WRAPV = 6, /* TRUE for wrapping in v */ + D3DRENDERSTATE_MONOENABLE = 11, /* TRUE to enable mono rasterization */ + D3DRENDERSTATE_ROP2 = 12, /* ROP2 */ + D3DRENDERSTATE_PLANEMASK = 13, /* DWORD physical plane mask */ + D3DRENDERSTATE_TEXTUREMAG = 17, /* D3DTEXTUREFILTER */ + D3DRENDERSTATE_TEXTUREMIN = 18, /* D3DTEXTUREFILTER */ + D3DRENDERSTATE_TEXTUREMAPBLEND = 21, /* D3DTEXTUREBLEND */ + D3DRENDERSTATE_SUBPIXEL = 31, /* TRUE to enable subpixel correction */ + D3DRENDERSTATE_SUBPIXELX = 32, /* TRUE to enable correction in X only */ + D3DRENDERSTATE_STIPPLEENABLE = 39, /* TRUE to enable stippling */ +#if(DIRECT3D_VERSION >= 0x0500) + D3DRENDERSTATE_BORDERCOLOR = 43, /* Border color for texturing w/border */ + D3DRENDERSTATE_TEXTUREADDRESSU = 44, /* Texture addressing mode for U coordinate */ + D3DRENDERSTATE_TEXTUREADDRESSV = 45, /* Texture addressing mode for V coordinate */ + D3DRENDERSTATE_MIPMAPLODBIAS = 46, /* D3DVALUE Mipmap LOD bias */ + D3DRENDERSTATE_ANISOTROPY = 49, /* Max. anisotropy. 1 = no anisotropy */ +#endif /* DIRECT3D_VERSION >= 0x0500 */ + D3DRENDERSTATE_FLUSHBATCH = 50, /* Explicit flush for DP batching (DX5 Only) */ +#if(DIRECT3D_VERSION >= 0x0600) + D3DRENDERSTATE_TRANSLUCENTSORTINDEPENDENT=51, /* BOOL enable sort-independent transparency */ +#endif /* DIRECT3D_VERSION >= 0x0600 */ + D3DRENDERSTATE_STIPPLEPATTERN00 = 64, /* Stipple pattern 01... */ + D3DRENDERSTATE_STIPPLEPATTERN01 = 65, + D3DRENDERSTATE_STIPPLEPATTERN02 = 66, + D3DRENDERSTATE_STIPPLEPATTERN03 = 67, + D3DRENDERSTATE_STIPPLEPATTERN04 = 68, + D3DRENDERSTATE_STIPPLEPATTERN05 = 69, + D3DRENDERSTATE_STIPPLEPATTERN06 = 70, + D3DRENDERSTATE_STIPPLEPATTERN07 = 71, + D3DRENDERSTATE_STIPPLEPATTERN08 = 72, + D3DRENDERSTATE_STIPPLEPATTERN09 = 73, + D3DRENDERSTATE_STIPPLEPATTERN10 = 74, + D3DRENDERSTATE_STIPPLEPATTERN11 = 75, + D3DRENDERSTATE_STIPPLEPATTERN12 = 76, + D3DRENDERSTATE_STIPPLEPATTERN13 = 77, + D3DRENDERSTATE_STIPPLEPATTERN14 = 78, + D3DRENDERSTATE_STIPPLEPATTERN15 = 79, + D3DRENDERSTATE_STIPPLEPATTERN16 = 80, + D3DRENDERSTATE_STIPPLEPATTERN17 = 81, + D3DRENDERSTATE_STIPPLEPATTERN18 = 82, + D3DRENDERSTATE_STIPPLEPATTERN19 = 83, + D3DRENDERSTATE_STIPPLEPATTERN20 = 84, + D3DRENDERSTATE_STIPPLEPATTERN21 = 85, + D3DRENDERSTATE_STIPPLEPATTERN22 = 86, + D3DRENDERSTATE_STIPPLEPATTERN23 = 87, + D3DRENDERSTATE_STIPPLEPATTERN24 = 88, + D3DRENDERSTATE_STIPPLEPATTERN25 = 89, + D3DRENDERSTATE_STIPPLEPATTERN26 = 90, + D3DRENDERSTATE_STIPPLEPATTERN27 = 91, + D3DRENDERSTATE_STIPPLEPATTERN28 = 92, + D3DRENDERSTATE_STIPPLEPATTERN29 = 93, + D3DRENDERSTATE_STIPPLEPATTERN30 = 94, + D3DRENDERSTATE_STIPPLEPATTERN31 = 95, + +// +// retired renderstate names - the values are still used under new naming conventions +// + D3DRENDERSTATE_FOGTABLESTART = 36, /* Fog table start */ + D3DRENDERSTATE_FOGTABLEEND = 37, /* Fog table end */ + D3DRENDERSTATE_FOGTABLEDENSITY = 38, /* Fog table density */ + +#if(DIRECT3D_VERSION >= 0x0500) + D3DRENDERSTATE_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ +#endif /* DIRECT3D_VERSION >= 0x0500 */ +} D3DRENDERSTATETYPE; + +// Values for material source +typedef enum _D3DMATERIALCOLORSOURCE +{ + D3DMCS_MATERIAL = 0, // Color from material is used + D3DMCS_COLOR1 = 1, // Diffuse vertex color is used + D3DMCS_COLOR2 = 2, // Specular vertex color is used + D3DMCS_FORCE_DWORD = 0x7fffffff, // force 32-bit size enum +} D3DMATERIALCOLORSOURCE; + + +#if(DIRECT3D_VERSION >= 0x0500) +// For back-compatibility with legacy compilations +#define D3DRENDERSTATE_BLENDENABLE D3DRENDERSTATE_ALPHABLENDENABLE +#endif /* DIRECT3D_VERSION >= 0x0500 */ + +#if(DIRECT3D_VERSION >= 0x0600) + +// Bias to apply to the texture coordinate set to apply a wrap to. +#define D3DRENDERSTATE_WRAPBIAS 128UL + +/* Flags to construct the WRAP render states */ +#define D3DWRAP_U 0x00000001L +#define D3DWRAP_V 0x00000002L + +#endif /* DIRECT3D_VERSION >= 0x0600 */ + +#if(DIRECT3D_VERSION >= 0x0700) + +/* Flags to construct the WRAP render states for 1D thru 4D texture coordinates */ +#define D3DWRAPCOORD_0 0x00000001L // same as D3DWRAP_U +#define D3DWRAPCOORD_1 0x00000002L // same as D3DWRAP_V +#define D3DWRAPCOORD_2 0x00000004L +#define D3DWRAPCOORD_3 0x00000008L + +#endif /* DIRECT3D_VERSION >= 0x0700 */ + +#define D3DRENDERSTATE_STIPPLEPATTERN(y) (D3DRENDERSTATE_STIPPLEPATTERN00 + (y)) + +typedef struct _D3DSTATE { + union { + D3DTRANSFORMSTATETYPE dtstTransformStateType; + D3DLIGHTSTATETYPE dlstLightStateType; + D3DRENDERSTATETYPE drstRenderStateType; + }; + union { + DWORD dwArg[1]; + D3DVALUE dvArg[1]; + }; +} D3DSTATE, *LPD3DSTATE; + +/* + * Operation used to load matrices + * hDstMat = hSrcMat + */ +typedef struct _D3DMATRIXLOAD { + D3DMATRIXHANDLE hDestMatrix; /* Destination matrix */ + D3DMATRIXHANDLE hSrcMatrix; /* Source matrix */ +} D3DMATRIXLOAD, *LPD3DMATRIXLOAD; + +/* + * Operation used to multiply matrices + * hDstMat = hSrcMat1 * hSrcMat2 + */ +typedef struct _D3DMATRIXMULTIPLY { + D3DMATRIXHANDLE hDestMatrix; /* Destination matrix */ + D3DMATRIXHANDLE hSrcMatrix1; /* First source matrix */ + D3DMATRIXHANDLE hSrcMatrix2; /* Second source matrix */ +} D3DMATRIXMULTIPLY, *LPD3DMATRIXMULTIPLY; + +/* + * Operation used to transform and light vertices. + */ +typedef struct _D3DPROCESSVERTICES { + DWORD dwFlags; /* Do we transform or light or just copy? */ + WORD wStart; /* Index to first vertex in source */ + WORD wDest; /* Index to first vertex in local buffer */ + DWORD dwCount; /* Number of vertices to be processed */ + DWORD dwReserved; /* Must be zero */ +} D3DPROCESSVERTICES, *LPD3DPROCESSVERTICES; + +#define D3DPROCESSVERTICES_TRANSFORMLIGHT 0x00000000L +#define D3DPROCESSVERTICES_TRANSFORM 0x00000001L +#define D3DPROCESSVERTICES_COPY 0x00000002L +#define D3DPROCESSVERTICES_OPMASK 0x00000007L + +#define D3DPROCESSVERTICES_UPDATEEXTENTS 0x00000008L +#define D3DPROCESSVERTICES_NOCOLOR 0x00000010L + + +#if(DIRECT3D_VERSION >= 0x0600) + + +/* + * State enumerants for per-stage texture processing. + */ +typedef enum _D3DTEXTURESTAGESTATETYPE +{ + D3DTSS_COLOROP = 1, /* D3DTEXTUREOP - per-stage blending controls for color channels */ + D3DTSS_COLORARG1 = 2, /* D3DTA_* (texture arg) */ + D3DTSS_COLORARG2 = 3, /* D3DTA_* (texture arg) */ + D3DTSS_ALPHAOP = 4, /* D3DTEXTUREOP - per-stage blending controls for alpha channel */ + D3DTSS_ALPHAARG1 = 5, /* D3DTA_* (texture arg) */ + D3DTSS_ALPHAARG2 = 6, /* D3DTA_* (texture arg) */ + D3DTSS_BUMPENVMAT00 = 7, /* D3DVALUE (bump mapping matrix) */ + D3DTSS_BUMPENVMAT01 = 8, /* D3DVALUE (bump mapping matrix) */ + D3DTSS_BUMPENVMAT10 = 9, /* D3DVALUE (bump mapping matrix) */ + D3DTSS_BUMPENVMAT11 = 10, /* D3DVALUE (bump mapping matrix) */ + D3DTSS_TEXCOORDINDEX = 11, /* identifies which set of texture coordinates index this texture */ + D3DTSS_ADDRESS = 12, /* D3DTEXTUREADDRESS for both coordinates */ + D3DTSS_ADDRESSU = 13, /* D3DTEXTUREADDRESS for U coordinate */ + D3DTSS_ADDRESSV = 14, /* D3DTEXTUREADDRESS for V coordinate */ + D3DTSS_BORDERCOLOR = 15, /* D3DCOLOR */ + D3DTSS_MAGFILTER = 16, /* D3DTEXTUREMAGFILTER filter to use for magnification */ + D3DTSS_MINFILTER = 17, /* D3DTEXTUREMINFILTER filter to use for minification */ + D3DTSS_MIPFILTER = 18, /* D3DTEXTUREMIPFILTER filter to use between mipmaps during minification */ + D3DTSS_MIPMAPLODBIAS = 19, /* D3DVALUE Mipmap LOD bias */ + D3DTSS_MAXMIPLEVEL = 20, /* DWORD 0..(n-1) LOD index of largest map to use (0 == largest) */ + D3DTSS_MAXANISOTROPY = 21, /* DWORD maximum anisotropy */ + D3DTSS_BUMPENVLSCALE = 22, /* D3DVALUE scale for bump map luminance */ + D3DTSS_BUMPENVLOFFSET = 23, /* D3DVALUE offset for bump map luminance */ +#if(DIRECT3D_VERSION >= 0x0700) + D3DTSS_TEXTURETRANSFORMFLAGS = 24, /* D3DTEXTURETRANSFORMFLAGS controls texture transform */ +#endif /* DIRECT3D_VERSION >= 0x0700 */ + D3DTSS_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */ +} D3DTEXTURESTAGESTATETYPE; + +#if(DIRECT3D_VERSION >= 0x0700) +// Values, used with D3DTSS_TEXCOORDINDEX, to specify that the vertex data(position +// and normal in the camera space) should be taken as texture coordinates +// Low 16 bits are used to specify texture coordinate index, to take the WRAP mode from +// +#define D3DTSS_TCI_PASSTHRU 0x00000000 +#define D3DTSS_TCI_CAMERASPACENORMAL 0x00010000 +#define D3DTSS_TCI_CAMERASPACEPOSITION 0x00020000 +#define D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR 0x00030000 +#endif /* DIRECT3D_VERSION >= 0x0700 */ + +/* + * Enumerations for COLOROP and ALPHAOP texture blending operations set in + * texture processing stage controls in D3DRENDERSTATE. + */ +typedef enum _D3DTEXTUREOP +{ +// Control + D3DTOP_DISABLE = 1, // disables stage + D3DTOP_SELECTARG1 = 2, // the default + D3DTOP_SELECTARG2 = 3, + +// Modulate + D3DTOP_MODULATE = 4, // multiply args together + D3DTOP_MODULATE2X = 5, // multiply and 1 bit + D3DTOP_MODULATE4X = 6, // multiply and 2 bits + +// Add + D3DTOP_ADD = 7, // add arguments together + D3DTOP_ADDSIGNED = 8, // add with -0.5 bias + D3DTOP_ADDSIGNED2X = 9, // as above but left 1 bit + D3DTOP_SUBTRACT = 10, // Arg1 - Arg2, with no saturation + D3DTOP_ADDSMOOTH = 11, // add 2 args, subtract product + // Arg1 + Arg2 - Arg1*Arg2 + // = Arg1 + (1-Arg1)*Arg2 + +// Linear alpha blend: Arg1*(Alpha) + Arg2*(1-Alpha) + D3DTOP_BLENDDIFFUSEALPHA = 12, // iterated alpha + D3DTOP_BLENDTEXTUREALPHA = 13, // texture alpha + D3DTOP_BLENDFACTORALPHA = 14, // alpha from D3DRENDERSTATE_TEXTUREFACTOR + // Linear alpha blend with pre-multiplied arg1 input: Arg1 + Arg2*(1-Alpha) + D3DTOP_BLENDTEXTUREALPHAPM = 15, // texture alpha + D3DTOP_BLENDCURRENTALPHA = 16, // by alpha of current color + +// Specular mapping + D3DTOP_PREMODULATE = 17, // modulate with next texture before use + D3DTOP_MODULATEALPHA_ADDCOLOR = 18, // Arg1.RGB + Arg1.A*Arg2.RGB + // COLOROP only + D3DTOP_MODULATECOLOR_ADDALPHA = 19, // Arg1.RGB*Arg2.RGB + Arg1.A + // COLOROP only + D3DTOP_MODULATEINVALPHA_ADDCOLOR = 20, // (1-Arg1.A)*Arg2.RGB + Arg1.RGB + // COLOROP only + D3DTOP_MODULATEINVCOLOR_ADDALPHA = 21, // (1-Arg1.RGB)*Arg2.RGB + Arg1.A + // COLOROP only + +// Bump mapping + D3DTOP_BUMPENVMAP = 22, // per pixel env map perturbation + D3DTOP_BUMPENVMAPLUMINANCE = 23, // with luminance channel + // This can do either diffuse or specular bump mapping with correct input. + // Performs the function (Arg1.R*Arg2.R + Arg1.G*Arg2.G + Arg1.B*Arg2.B) + // where each component has been scaled and offset to make it signed. + // The result is replicated into all four (including alpha) channels. + // This is a valid COLOROP only. + D3DTOP_DOTPRODUCT3 = 24, + + D3DTOP_FORCE_DWORD = 0x7fffffff, +} D3DTEXTUREOP; + +/* + * Values for COLORARG1,2 and ALPHAARG1,2 texture blending operations + * set in texture processing stage controls in D3DRENDERSTATE. + */ +#define D3DTA_SELECTMASK 0x0000000f // mask for arg selector +#define D3DTA_DIFFUSE 0x00000000 // select diffuse color +#define D3DTA_CURRENT 0x00000001 // select result of previous stage +#define D3DTA_TEXTURE 0x00000002 // select texture color +#define D3DTA_TFACTOR 0x00000003 // select RENDERSTATE_TEXTUREFACTOR +#if(DIRECT3D_VERSION >= 0x0700) +#define D3DTA_SPECULAR 0x00000004 // select specular color +#endif /* DIRECT3D_VERSION >= 0x0700 */ +#define D3DTA_COMPLEMENT 0x00000010 // take 1.0 - x +#define D3DTA_ALPHAREPLICATE 0x00000020 // replicate alpha to color components + + +/* + * IDirect3DTexture2 State Filter Types + */ +typedef enum _D3DTEXTUREMAGFILTER +{ + D3DTFG_POINT = 1, // nearest + D3DTFG_LINEAR = 2, // linear interpolation + D3DTFG_FLATCUBIC = 3, // cubic + D3DTFG_GAUSSIANCUBIC = 4, // different cubic kernel + D3DTFG_ANISOTROPIC = 5, // +#if(DIRECT3D_VERSION >= 0x0700) +#endif /* DIRECT3D_VERSION >= 0x0700 */ + D3DTFG_FORCE_DWORD = 0x7fffffff, // force 32-bit size enum +} D3DTEXTUREMAGFILTER; + +typedef enum _D3DTEXTUREMINFILTER +{ + D3DTFN_POINT = 1, // nearest + D3DTFN_LINEAR = 2, // linear interpolation + D3DTFN_ANISOTROPIC = 3, // + D3DTFN_FORCE_DWORD = 0x7fffffff, // force 32-bit size enum +} D3DTEXTUREMINFILTER; + +typedef enum _D3DTEXTUREMIPFILTER +{ + D3DTFP_NONE = 1, // mipmapping disabled (use MAG filter) + D3DTFP_POINT = 2, // nearest + D3DTFP_LINEAR = 3, // linear interpolation + D3DTFP_FORCE_DWORD = 0x7fffffff, // force 32-bit size enum +} D3DTEXTUREMIPFILTER; + +#endif /* DIRECT3D_VERSION >= 0x0600 */ + +/* + * Triangle flags + */ + +/* + * Tri strip and fan flags. + * START loads all three vertices + * EVEN and ODD load just v3 with even or odd culling + * START_FLAT contains a count from 0 to 29 that allows the + * whole strip or fan to be culled in one hit. + * e.g. for a quad len = 1 + */ +#define D3DTRIFLAG_START 0x00000000L +#define D3DTRIFLAG_STARTFLAT(len) (len) /* 0 < len < 30 */ +#define D3DTRIFLAG_ODD 0x0000001eL +#define D3DTRIFLAG_EVEN 0x0000001fL + +/* + * Triangle edge flags + * enable edges for wireframe or antialiasing + */ +#define D3DTRIFLAG_EDGEENABLE1 0x00000100L /* v0-v1 edge */ +#define D3DTRIFLAG_EDGEENABLE2 0x00000200L /* v1-v2 edge */ +#define D3DTRIFLAG_EDGEENABLE3 0x00000400L /* v2-v0 edge */ +#define D3DTRIFLAG_EDGEENABLETRIANGLE \ + (D3DTRIFLAG_EDGEENABLE1 | D3DTRIFLAG_EDGEENABLE2 | D3DTRIFLAG_EDGEENABLE3) + +/* + * Primitive structures and related defines. Vertex offsets are to types + * D3DVERTEX, D3DLVERTEX, or D3DTLVERTEX. + */ + +/* + * Triangle list primitive structure + */ +typedef struct _D3DTRIANGLE { + union { + WORD v1; /* Vertex indices */ + WORD wV1; + }; + union { + WORD v2; + WORD wV2; + }; + union { + WORD v3; + WORD wV3; + }; + WORD wFlags; /* Edge (and other) flags */ +} D3DTRIANGLE, *LPD3DTRIANGLE; + +/* + * Line list structure. + * The instruction count defines the number of line segments. + */ +typedef struct _D3DLINE { + union { + WORD v1; /* Vertex indices */ + WORD wV1; + }; + union { + WORD v2; + WORD wV2; + }; +} D3DLINE, *LPD3DLINE; + +/* + * Span structure + * Spans join a list of points with the same y value. + * If the y value changes, a new span is started. + */ +typedef struct _D3DSPAN { + WORD wCount; /* Number of spans */ + WORD wFirst; /* Index to first vertex */ +} D3DSPAN, *LPD3DSPAN; + +/* + * Point structure + */ +typedef struct _D3DPOINT { + WORD wCount; /* number of points */ + WORD wFirst; /* index to first vertex */ +} D3DPOINT, *LPD3DPOINT; + + +/* + * Forward branch structure. + * Mask is logically anded with the driver status mask + * if the result equals 'value', the branch is taken. + */ +typedef struct _D3DBRANCH { + DWORD dwMask; /* Bitmask against D3D status */ + DWORD dwValue; + BOOL bNegate; /* TRUE to negate comparison */ + DWORD dwOffset; /* How far to branch forward (0 for exit)*/ +} D3DBRANCH, *LPD3DBRANCH; + +/* + * Status used for set status instruction. + * The D3D status is initialised on device creation + * and is modified by all execute calls. + */ +typedef struct _D3DSTATUS { + DWORD dwFlags; /* Do we set extents or status */ + DWORD dwStatus; /* D3D status */ + D3DRECT drExtent; +} D3DSTATUS, *LPD3DSTATUS; + +#define D3DSETSTATUS_STATUS 0x00000001L +#define D3DSETSTATUS_EXTENTS 0x00000002L +#define D3DSETSTATUS_ALL (D3DSETSTATUS_STATUS | D3DSETSTATUS_EXTENTS) + +#if(DIRECT3D_VERSION >= 0x0500) +typedef struct _D3DCLIPSTATUS { + DWORD dwFlags; /* Do we set 2d extents, 3D extents or status */ + DWORD dwStatus; /* Clip status */ + float minx, maxx; /* X extents */ + float miny, maxy; /* Y extents */ + float minz, maxz; /* Z extents */ +} D3DCLIPSTATUS, *LPD3DCLIPSTATUS; + +#define D3DCLIPSTATUS_STATUS 0x00000001L +#define D3DCLIPSTATUS_EXTENTS2 0x00000002L +#define D3DCLIPSTATUS_EXTENTS3 0x00000004L + +#endif /* DIRECT3D_VERSION >= 0x0500 */ +/* + * Statistics structure + */ +typedef struct _D3DSTATS { + DWORD dwSize; + DWORD dwTrianglesDrawn; + DWORD dwLinesDrawn; + DWORD dwPointsDrawn; + DWORD dwSpansDrawn; + DWORD dwVerticesProcessed; +} D3DSTATS, *LPD3DSTATS; + +/* + * Execute options. + * When calling using D3DEXECUTE_UNCLIPPED all the primitives + * inside the buffer must be contained within the viewport. + */ +#define D3DEXECUTE_CLIPPED 0x00000001l +#define D3DEXECUTE_UNCLIPPED 0x00000002l + +typedef struct _D3DEXECUTEDATA { + DWORD dwSize; + DWORD dwVertexOffset; + DWORD dwVertexCount; + DWORD dwInstructionOffset; + DWORD dwInstructionLength; + DWORD dwHVertexOffset; + D3DSTATUS dsStatus; /* Status after execute */ +} D3DEXECUTEDATA, *LPD3DEXECUTEDATA; + +/* + * Palette flags. + * This are or'ed with the peFlags in the PALETTEENTRYs passed to DirectDraw. + */ +#define D3DPAL_FREE 0x00 /* Renderer may use this entry freely */ +#define D3DPAL_READONLY 0x40 /* Renderer may not set this entry */ +#define D3DPAL_RESERVED 0x80 /* Renderer may not use this entry */ + + +#if(DIRECT3D_VERSION >= 0x0600) + +typedef struct _D3DVERTEXBUFFERDESC { + DWORD dwSize; + DWORD dwCaps; + DWORD dwFVF; + DWORD dwNumVertices; +} D3DVERTEXBUFFERDESC, *LPD3DVERTEXBUFFERDESC; + +#define D3DVBCAPS_SYSTEMMEMORY 0x00000800l +#define D3DVBCAPS_WRITEONLY 0x00010000l +#define D3DVBCAPS_OPTIMIZED 0x80000000l +#define D3DVBCAPS_DONOTCLIP 0x00000001l + +/* Vertex Operations for ProcessVertices */ +#define D3DVOP_LIGHT (1 << 10) +#define D3DVOP_TRANSFORM (1 << 0) +#define D3DVOP_CLIP (1 << 2) +#define D3DVOP_EXTENTS (1 << 3) + +/* The maximum number of vertices user can pass to any d3d + drawing function or to create vertex buffer with +*/ +#define D3DMAXNUMVERTICES ((1<<16) - 1) +/* The maximum number of primitives user can pass to any d3d + drawing function. +*/ +#define D3DMAXNUMPRIMITIVES ((1<<16) - 1) + +#if(DIRECT3D_VERSION >= 0x0700) + +/* Bits for dwFlags in ProcessVertices call */ +#define D3DPV_DONOTCOPYDATA (1 << 0) + +#endif /* DIRECT3D_VERSION >= 0x0700 */ +//------------------------------------------------------------------- + +// Flexible vertex format bits +// +#define D3DFVF_RESERVED0 0x001 +#define D3DFVF_POSITION_MASK 0x00E +#define D3DFVF_XYZ 0x002 +#define D3DFVF_XYZRHW 0x004 +#if(DIRECT3D_VERSION >= 0x0700) +#define D3DFVF_XYZB1 0x006 +#define D3DFVF_XYZB2 0x008 +#define D3DFVF_XYZB3 0x00a +#define D3DFVF_XYZB4 0x00c +#define D3DFVF_XYZB5 0x00e + +#endif /* DIRECT3D_VERSION >= 0x0700 */ +#define D3DFVF_NORMAL 0x010 +#define D3DFVF_RESERVED1 0x020 +#define D3DFVF_DIFFUSE 0x040 +#define D3DFVF_SPECULAR 0x080 + +#define D3DFVF_TEXCOUNT_MASK 0xf00 +#define D3DFVF_TEXCOUNT_SHIFT 8 +#define D3DFVF_TEX0 0x000 +#define D3DFVF_TEX1 0x100 +#define D3DFVF_TEX2 0x200 +#define D3DFVF_TEX3 0x300 +#define D3DFVF_TEX4 0x400 +#define D3DFVF_TEX5 0x500 +#define D3DFVF_TEX6 0x600 +#define D3DFVF_TEX7 0x700 +#define D3DFVF_TEX8 0x800 + +#define D3DFVF_RESERVED2 0xf000 // 4 reserved bits + +#define D3DFVF_VERTEX ( D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_TEX1 ) +#define D3DFVF_LVERTEX ( D3DFVF_XYZ | D3DFVF_RESERVED1 | D3DFVF_DIFFUSE | \ + D3DFVF_SPECULAR | D3DFVF_TEX1 ) +#define D3DFVF_TLVERTEX ( D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_SPECULAR | \ + D3DFVF_TEX1 ) + +typedef struct _D3DDP_PTRSTRIDE +{ + LPVOID lpvData; + DWORD dwStride; +} D3DDP_PTRSTRIDE; + +#define D3DDP_MAXTEXCOORD 8 + +typedef struct _D3DDRAWPRIMITIVESTRIDEDDATA +{ + D3DDP_PTRSTRIDE position; + D3DDP_PTRSTRIDE normal; + D3DDP_PTRSTRIDE diffuse; + D3DDP_PTRSTRIDE specular; + D3DDP_PTRSTRIDE textureCoords[D3DDP_MAXTEXCOORD]; +} D3DDRAWPRIMITIVESTRIDEDDATA, *LPD3DDRAWPRIMITIVESTRIDEDDATA; +//--------------------------------------------------------------------- +// ComputeSphereVisibility return values +// +#define D3DVIS_INSIDE_FRUSTUM 0 +#define D3DVIS_INTERSECT_FRUSTUM 1 +#define D3DVIS_OUTSIDE_FRUSTUM 2 +#define D3DVIS_INSIDE_LEFT 0 +#define D3DVIS_INTERSECT_LEFT (1 << 2) +#define D3DVIS_OUTSIDE_LEFT (2 << 2) +#define D3DVIS_INSIDE_RIGHT 0 +#define D3DVIS_INTERSECT_RIGHT (1 << 4) +#define D3DVIS_OUTSIDE_RIGHT (2 << 4) +#define D3DVIS_INSIDE_TOP 0 +#define D3DVIS_INTERSECT_TOP (1 << 6) +#define D3DVIS_OUTSIDE_TOP (2 << 6) +#define D3DVIS_INSIDE_BOTTOM 0 +#define D3DVIS_INTERSECT_BOTTOM (1 << 8) +#define D3DVIS_OUTSIDE_BOTTOM (2 << 8) +#define D3DVIS_INSIDE_NEAR 0 +#define D3DVIS_INTERSECT_NEAR (1 << 10) +#define D3DVIS_OUTSIDE_NEAR (2 << 10) +#define D3DVIS_INSIDE_FAR 0 +#define D3DVIS_INTERSECT_FAR (1 << 12) +#define D3DVIS_OUTSIDE_FAR (2 << 12) + +#define D3DVIS_MASK_FRUSTUM (3 << 0) +#define D3DVIS_MASK_LEFT (3 << 2) +#define D3DVIS_MASK_RIGHT (3 << 4) +#define D3DVIS_MASK_TOP (3 << 6) +#define D3DVIS_MASK_BOTTOM (3 << 8) +#define D3DVIS_MASK_NEAR (3 << 10) +#define D3DVIS_MASK_FAR (3 << 12) + +#endif /* DIRECT3D_VERSION >= 0x0600 */ + +#if(DIRECT3D_VERSION >= 0x0700) + +// To be used with GetInfo() +#define D3DDEVINFOID_TEXTUREMANAGER 1 +#define D3DDEVINFOID_D3DTEXTUREMANAGER 2 +#define D3DDEVINFOID_TEXTURING 3 + +typedef enum _D3DSTATEBLOCKTYPE +{ + D3DSBT_ALL = 1, // capture all state + D3DSBT_PIXELSTATE = 2, // capture pixel state + D3DSBT_VERTEXSTATE = 3, // capture vertex state + D3DSBT_FORCE_DWORD = 0xffffffff +} D3DSTATEBLOCKTYPE; + +// The D3DVERTEXBLENDFLAGS type is used with D3DRENDERSTATE_VERTEXBLEND state. +// +typedef enum _D3DVERTEXBLENDFLAGS +{ + D3DVBLEND_DISABLE = 0, // Disable vertex blending + D3DVBLEND_1WEIGHT = 1, // blend between 2 matrices + D3DVBLEND_2WEIGHTS = 2, // blend between 3 matrices + D3DVBLEND_3WEIGHTS = 3, // blend between 4 matrices +} D3DVERTEXBLENDFLAGS; + +typedef enum _D3DTEXTURETRANSFORMFLAGS { + D3DTTFF_DISABLE = 0, // texture coordinates are passed directly + D3DTTFF_COUNT1 = 1, // rasterizer should expect 1-D texture coords + D3DTTFF_COUNT2 = 2, // rasterizer should expect 2-D texture coords + D3DTTFF_COUNT3 = 3, // rasterizer should expect 3-D texture coords + D3DTTFF_COUNT4 = 4, // rasterizer should expect 4-D texture coords + D3DTTFF_PROJECTED = 256, // texcoords to be divided by COUNTth element + D3DTTFF_FORCE_DWORD = 0x7fffffff, +} D3DTEXTURETRANSFORMFLAGS; + +// Macros to set texture coordinate format bits in the FVF id + +#define D3DFVF_TEXTUREFORMAT2 0 // Two floating point values +#define D3DFVF_TEXTUREFORMAT1 3 // One floating point value +#define D3DFVF_TEXTUREFORMAT3 1 // Three floating point values +#define D3DFVF_TEXTUREFORMAT4 2 // Four floating point values + +#define D3DFVF_TEXCOORDSIZE3(CoordIndex) (D3DFVF_TEXTUREFORMAT3 << (CoordIndex*2 + 16)) +#define D3DFVF_TEXCOORDSIZE2(CoordIndex) (D3DFVF_TEXTUREFORMAT2) +#define D3DFVF_TEXCOORDSIZE4(CoordIndex) (D3DFVF_TEXTUREFORMAT4 << (CoordIndex*2 + 16)) +#define D3DFVF_TEXCOORDSIZE1(CoordIndex) (D3DFVF_TEXTUREFORMAT1 << (CoordIndex*2 + 16)) + + +#endif /* DIRECT3D_VERSION >= 0x0700 */ + +#pragma pack() +#ifdef _MSC_VER +#pragma warning(default:4201) +#endif + +#endif /* _D3DTYPES_H_ */ + diff --git a/engine/libs/dxsdk7/include/d3dx.h b/engine/libs/dxsdk7/include/d3dx.h new file mode 100644 index 000000000..5cff32508 --- /dev/null +++ b/engine/libs/dxsdk7/include/d3dx.h @@ -0,0 +1,26 @@ +/////////////////////////////////////////////////////////////////////////// +// +// Copyright (C) 1999 Microsoft Corporation. All Rights Reserved. +// +// File: d3dx.h +// Content: D3DX utility library +// +/////////////////////////////////////////////////////////////////////////// + +#ifndef __D3DX_H__ +#define __D3DX_H__ + +#ifndef D3DXINLINE +#ifdef __cplusplus +#define D3DXINLINE inline +#else +#define D3DXINLINE _inline +#endif +#endif + +#include "d3dxcore.h" +#include "d3dxmath.h" +#include "d3dxshapes.h" +#include "d3dxsprite.h" + +#endif //__D3DX_H__ diff --git a/engine/libs/dxsdk7/include/d3dxcore.h b/engine/libs/dxsdk7/include/d3dxcore.h new file mode 100644 index 000000000..c0be0cfee --- /dev/null +++ b/engine/libs/dxsdk7/include/d3dxcore.h @@ -0,0 +1,1027 @@ +/////////////////////////////////////////////////////////////////////////// +// +// Copyright (C) 1999 Microsoft Corporation. All Rights Reserved. +// +// File: d3dxcore.h +// Content: D3DX core types and functions +// +/////////////////////////////////////////////////////////////////////////// + +#ifndef __D3DXCORE_H__ +#define __D3DXCORE_H__ + +#include +#include +#include "d3dxerr.h" + + +typedef struct ID3DXContext *LPD3DXCONTEXT; + +// {9B74ED7A-BBEF-11d2-9F8E-0000F8080835} +DEFINE_GUID(IID_ID3DXContext, + 0x9b74ed7a, 0xbbef, 0x11d2, 0x9f, 0x8e, 0x0, 0x0, 0xf8, 0x8, 0x8, 0x35); + + +/////////////////////////////////////////////////////////////////////////// +// Defines and Enumerators used below: +/////////////////////////////////////////////////////////////////////////// + +//------------------------------------------------------------------------- +// D3DX_DEFAULT: +// --------- +// A predefined value that could be used for any parameter in D3DX APIs or +// member functions that is an enumerant or a handle. The D3DX +// documentation indicates wherever D3DX_DEFAULT may be used, +// and how it will be interpreted in each situation. +//------------------------------------------------------------------------- +#define D3DX_DEFAULT ULONG_MAX + +//------------------------------------------------------------------------- +// D3DX_DEFAULT_FLOAT: +// ------------------ +// Similar to D3DX_DEFAULT, but used for floating point parameters. +// The D3DX documentation indicates wherever D3DX_DEFAULT_FLOAT may be used, +// and how it will be interpreted in each situation. +//------------------------------------------------------------------------- +#define D3DX_DEFAULT_FLOAT FLT_MAX + +//------------------------------------------------------------------------- +// Hardware Acceleration Level: +// --------------------------- +// These constants represent pre-defined hardware acceleration levels, +// and may be used as a default anywhere a (DWORD) deviceIndex is required. +// Each pre-define indicates a different level of hardware acceleration. +// They are an alternative to using explicit deviceIndices retrieved by +// D3DXGetDeviceDescription(). +// +// The only case these pre-defines should be used as device indices is if +// a particular level of acceleration is required, and given more than +// one capable device on the computer, it does not matter which one +// is used. +// +// The method of selection is as follows: If one of the D3DX devices on +// the primary DDraw device supports a requested hardware acceleration +// level, it will be used. Otherwise, the first matching device discovered +// by D3DX will be used. +// +// Of course, it is possible for no match to exist for any of the +// pre-defines on a particular computer. Passing such a value into the +// D3DX apis will simply cause them to fail, reporting that no match +// is available. +// +// D3DX_HWLEVEL_NULL: Null implementation (draws nothing) +// D3DX_HWLEVEL_REFERENCE: Reference implementation (slowest) +// D3DX_HWLEVEL_2D: 2D acceleration only (RGB rasterizer used) +// D3DX_HWLEVEL_RASTER: Rasterization acceleration (likely most useful) +// D3DX_HWLEVEL_TL: Transform and lighting acceleration +// D3DX_DEFAULT: The highest level of acceleration available +// on the primary DDraw device. +//------------------------------------------------------------------------- +#define D3DX_HWLEVEL_NULL (D3DX_DEFAULT - 1) +#define D3DX_HWLEVEL_REFERENCE (D3DX_DEFAULT - 2) +#define D3DX_HWLEVEL_2D (D3DX_DEFAULT - 3) +#define D3DX_HWLEVEL_RASTER (D3DX_DEFAULT - 4) +#define D3DX_HWLEVEL_TL (D3DX_DEFAULT - 5) + +//------------------------------------------------------------------------- +// Surface Class: +// ------------- +// These are the various types of 2D-surfaces classified according to their +// usage. Note that a number of them overlap. e.g. STENCILBUFFERS and +// DEPTHBUFFERS overlap (since in DX7 implementation the stencil and depth +// bits are part of the same pixel format). +// +// Mapping to the DX7 DDPIXELFORMAT concepts: +// ----------------------------------------- +// D3DX_SC_DEPTHBUFFER: All ddpfs which have the DDPF_ZPIXELS or the +// DDPF_ZBUFFER flags set. +// D3DX_SC_STENCILBUFFER: All ddpfs which have the DDPF_STENCILBUFFER +// flag set. +// D3DX_SC_BUMPMAP: All ddpfs which have the DDPF_BUMPLUMINANCE +// or the DDPF_BUMPDUDV flags set. +// D3DX_SC_LUMINANCEMAP: All ddpfs which have the DDPF_BUMPLUMINANCE +// or the DDPF_LUMINANCE flags set. +// D3DX_SC_COLORTEXTURE: All the surfaces that have color information in +// them and can be used for texturing. +// D3DX_SC_COLORRENDERTGT: All the surfaces that contain color +// information and can be used as render targets. +//------------------------------------------------------------------------- +#define D3DX_SC_DEPTHBUFFER 0x01 +#define D3DX_SC_STENCILBUFFER 0x02 +#define D3DX_SC_COLORTEXTURE 0x04 +#define D3DX_SC_BUMPMAP 0x08 +#define D3DX_SC_LUMINANCEMAP 0x10 +#define D3DX_SC_COLORRENDERTGT 0x20 + +//------------------------------------------------------------------------- +// Surface Formats: +// --------------- +// These are the various types of surface formats that can be enumerated, +// there is no DDPIXELFORMAT structure in D3DX, the enums carry the meaning +// (like FOURCCs). +// +// All the surface classes are represented here. +// +//------------------------------------------------------------------------- +typedef enum _D3DX_SURFACEFORMAT +{ + D3DX_SF_UNKNOWN = 0, + D3DX_SF_R8G8B8 = 1, + D3DX_SF_A8R8G8B8 = 2, + D3DX_SF_X8R8G8B8 = 3, + D3DX_SF_R5G6B5 = 4, + D3DX_SF_R5G5B5 = 5, + D3DX_SF_PALETTE4 = 6, + D3DX_SF_PALETTE8 = 7, + D3DX_SF_A1R5G5B5 = 8, + D3DX_SF_X4R4G4B4 = 9, + D3DX_SF_A4R4G4B4 =10, + D3DX_SF_L8 =11, // 8 bit luminance-only + D3DX_SF_A8L8 =12, // 16 bit alpha-luminance + D3DX_SF_U8V8 =13, // 16 bit bump map format + D3DX_SF_U5V5L6 =14, // 16 bit bump map format with luminance + D3DX_SF_U8V8L8 =15, // 24 bit bump map format with luminance + D3DX_SF_UYVY =16, // UYVY format (PC98 compliance) + D3DX_SF_YUY2 =17, // YUY2 format (PC98 compliance) + D3DX_SF_DXT1 =18, // S3 texture compression technique 1 + D3DX_SF_DXT3 =19, // S3 texture compression technique 3 + D3DX_SF_DXT5 =20, // S3 texture compression technique 5 + D3DX_SF_R3G3B2 =21, // 8 bit RGB texture format + D3DX_SF_A8 =22, // 8 bit alpha-only + D3DX_SF_TEXTUREMAX =23, // Last texture format + + D3DX_SF_Z16S0 =256, + D3DX_SF_Z32S0 =257, + D3DX_SF_Z15S1 =258, + D3DX_SF_Z24S8 =259, + D3DX_SF_S1Z15 =260, + D3DX_SF_S8Z24 =261, + D3DX_SF_DEPTHMAX =262, // Last depth format + + D3DX_SF_FORCEMAX = (DWORD)(-1) +} D3DX_SURFACEFORMAT; + +//------------------------------------------------------------------------- +// Filtering types for Texture APIs +// +// ------------- +// These are the various filter types for generation of mip-maps +// +// D3DX_FILTERTYPE +// ----------------------------------------- +// D3DX_FT_POINT: Point sampling only - no filtering +// D3DX_FT_LINEAR: Bi-linear filtering +// +//------------------------------------------------------------------------- +typedef enum _D3DX_FILTERTYPE +{ + D3DX_FT_POINT = 0x01, + D3DX_FT_LINEAR = 0x02, + D3DX_FT_DEFAULT = D3DX_DEFAULT +} D3DX_FILTERTYPE; + +/////////////////////////////////////////////////////////////////////////// +// Structures used below: +/////////////////////////////////////////////////////////////////////////// + +//------------------------------------------------------------------------- +// D3DX_VIDMODEDESC: Display mode description. +// ---------------- +// width: Screen Width +// height: Screen Height +// bpp: Bits per pixel +// refreshRate: Refresh rate +//------------------------------------------------------------------------- +typedef struct _D3DX_VIDMODEDESC +{ + DWORD width; + DWORD height; + DWORD bpp; + DWORD refreshRate; +} D3DX_VIDMODEDESC; + +//------------------------------------------------------------------------- +// D3DX_DEVICEDESC: Description of a device that can do 3D +// --------------- +// deviceIndex: Unique (DWORD) number for the device. +// hwLevel: Level of acceleration afforded. This is one of the +// predefined Device Indices, and exists in this +// structure for informational purposes only. More than +// one device on the system may have the same hwLevel. +// To refer to a particular device with the D3DX apis, +// use the value in the deviceIndex member instead. +// ddGuid: The ddraw GUID +// d3dDeviceGuid: Direct3D Device GUID +// ddDeviceID: DDraw's GetDeviceIdentifier GUID. This GUID is unique to +// a particular driver revision on a particular video card. +// driverDesc: String describing the driver +// monitor: Handle to the video monitor used by this device (multimon +// specific). Devices that use different monitors on a +// multimon system report different values in this field. +// Therefore, to test for a multimon system, an application +// should look for more than one different monitor handle in +// the list of D3DX devices. +// onPrimary: Indicates if this device is on the primary monitor +// (multimon specific). +//------------------------------------------------------------------------- +#define D3DX_DRIVERDESC_LENGTH 256 + +typedef struct _D3DX_DEVICEDESC +{ + DWORD deviceIndex; + DWORD hwLevel; + GUID ddGuid; + GUID d3dDeviceGuid; + GUID ddDeviceID; + char driverDesc[D3DX_DRIVERDESC_LENGTH]; + HMONITOR monitor; + BOOL onPrimary; +} D3DX_DEVICEDESC; + +/////////////////////////////////////////////////////////////////////////// +// APIs: +/////////////////////////////////////////////////////////////////////////// +#ifdef __cplusplus +extern "C" { +#endif //__cplusplus + +//------------------------------------------------------------------------- +// D3DXInitialize: The very first call a D3DX app must make. +//------------------------------------------------------------------------- +HRESULT WINAPI + D3DXInitialize(); + +//------------------------------------------------------------------------- +// D3DXUninitialize: The very last call a D3DX app must make. +//------------------------------------------------------------------------- +HRESULT WINAPI + D3DXUninitialize(); + +//------------------------------------------------------------------------- +// D3DXGetDeviceCount: Returns the maximum number of D3DXdevices +// ------------------ available. +// +// D3DXGetDeviceDescription: Lists the 2D and 3D capabilities of the devices. +// ------------------------ Also, the various guids needed by ddraw and d3d. +// +// Params: +// [in] DWORD deviceIndex: Which device? Starts at 0. +// [in] D3DX_DEVICEDESC* pd3dxDevice: Pointer to the D3DX_DEVICEDESC +// structure to be filled in. +//------------------------------------------------------------------------- +DWORD WINAPI + D3DXGetDeviceCount(); + +HRESULT WINAPI + D3DXGetDeviceDescription(DWORD deviceIndex, + D3DX_DEVICEDESC* pd3dxDeviceDesc); + +//------------------------------------------------------------------------- +// D3DXGetMaxNumVideoModes: Returns the maximum number of video-modes . +// ----------------------- +// +// Params: +// [in] DWORD deviceIndex: The device being referred to. +// [in] DWORD flags: If D3DX_GVM_REFRESHRATE is set, then the refresh +// rates are not ignored. +// +// D3DXGetVideoMode: Describes a particular video mode for this device +// ---------------- +// +// Note: These queries will simply give you a list of modes that the +// display adapter tells DirectX that it supports. +// There is no guarantee that D3DXCreateContext(Ex) will succeed +// with all listed video modes. This is a fundamental limitation +// of the current DirectX architecture which D3DX cannot hide in +// any clean way. +// +// Params: +// [in] DWORD deviceIndex: The device being referred to. +// [in] DWORD flags: If D3DX_GVM_REFRESHRATE is set, then the refresh +// rates are returned +// [in] DWORD which: Which VideoMode ? Starts at 0. +// [out] D3DX_VIDMODEDESC* pModeList: Pointer to the D3DX_VIDMODEDESC +// structure that will be filled in. +//------------------------------------------------------------------------- +DWORD WINAPI + D3DXGetMaxNumVideoModes(DWORD deviceIndex, + DWORD flags); + +HRESULT WINAPI + D3DXGetVideoMode(DWORD deviceIndex, + DWORD flags, + DWORD modeIndex, + D3DX_VIDMODEDESC* pModeDesc); + +#define D3DX_GVM_REFRESHRATE 0x00000001 +//------------------------------------------------------------------------- +// D3DXGetMaxSurfaceFormats: Returns the maximum number of surface +// ------------------------ formats supported by the device at that +// video mode. +// +// D3DXGetSurfaceFormat: Describes one of the supported surface formats. +// --------------------- +// +// Params: +// [in] DWORD deviceIndex: The device being referred to. +// [in] D3DX_VIDMODEDESC* pDesc: The display mode at which the supported +// surface formats are requested. If it is +// NULL, the current display mode is +// assumed. +// [in] DWORD surfClassFlags: Required surface classes. Only surface +// formats which support all specified +// surface classes will be returned. +// (Multiple surface classes may be specified +// using bitwise OR.) +// [in] DWORD which: Which surface formats to retrieve. Starts at 0. +// [out] D3DX_SURFACEFORMAT* pFormat: The surface format +//------------------------------------------------------------------------- +DWORD WINAPI + D3DXGetMaxSurfaceFormats(DWORD deviceIndex, + D3DX_VIDMODEDESC* pDesc, + DWORD surfClassFlags); +HRESULT WINAPI + D3DXGetSurfaceFormat(DWORD deviceIndex, + D3DX_VIDMODEDESC* pDesc, + DWORD surfClassFlags, + DWORD surfaceIndex, + D3DX_SURFACEFORMAT* pFormat); + + +//------------------------------------------------------------------------- +// D3DXGetCurrentVideoMode: Retrieves the current video mode for this device. +// ------------------- +// +// Params: +// [in] DWORD deviceIndex: The device being referred to. +// [out] D3DX_VIDMODEDESC* pVidMode: The current video mode +//------------------------------------------------------------------------- +HRESULT WINAPI + D3DXGetCurrentVideoMode(DWORD deviceIndex, + D3DX_VIDMODEDESC* pVidMode); + +//------------------------------------------------------------------------- +// D3DXGetDeviceCaps: Lists all the capabilities of a device at a display +// mode. +// ---------------- +// +// Params: +// [in] DWORD deviceIndex: The device being referred to. +// [in] D3DX_VIDMODEDESC* pDesc: If this is NULL, we will return the +// caps at the current display mode of +// the device. +// [out] D3DDEVICEDESC7* pD3DDeviceDesc7: D3D Caps ( NULL to ignore +// parameter) +// [out] DDCAPS7* pDDHalCaps: DDraw HAL Caps (NULL to ignore parameter) +// [out] DDCAPS7* pDDHelCaps: DDraw HEL Caps (NULL to ignore paramter) +//------------------------------------------------------------------------- +HRESULT WINAPI + D3DXGetDeviceCaps(DWORD deviceIndex, + D3DX_VIDMODEDESC* pVidMode, + D3DDEVICEDESC7* pD3DCaps, + DDCAPS* pDDHALCaps, + DDCAPS* pDDHELCaps); + +//------------------------------------------------------------------------- +// D3DXCreateContext: Initializes the chosen device. It is the simplest init +// ----------------- function available. Parameters are treated the same +// as the matching subset of parameters in +// D3DXCreateContextEx, documented below. +// Remaining D3DXCreateContextEx parameters that are +// not present in D3DXCreateContext are treated as +// D3DX_DEFAULT. Note that multimon is not supported +// with D3DXCreateContext. +// +// D3DXCreateContextEx: A more advanced function to initialize the device. +// ------------------- Also accepts D3DX_DEFAULT for most of the parameters +// and then will do what D3DXCreateContext did. +// +// Note: Do not expect D3DXCreateContext(Ex) to be fail-safe (as with any +// API). Supported device capablilites should be used as a guide +// for choosing parameter values. Keep in mind that there will +// inevitably be some combinations of parameters that just do not work. +// +// Params: +// [in] DWORD deviceIndex: The device being referred to. +// [in] DWORD flags: The valid flags are D3DX_CONTEXT_FULLSCREEN, and +// D3DX_CONTEXT_OFFSCREEN. These flags cannot both +// be specified. If no flags are specified, the +// context defaults to windowed mode. +// +// [in] HWND hwnd: Device window. See note. +// [in] HWND hwndFocus: Window which receives keyboard messages from +// the device window. The device window should be +// a child of focus window. Useful for multimon +// applications. See note. +// NOTE: +// windowed: +// hwnd must be a valid window. hwndFocus must be NULL or +// D3DX_DEFAULT. +// +// fullscreen: +// Either hwnd or hwndFocus must be a valid window. (Both cannot +// be NULL or D3DX_DEFAULT). If hwnd is NULL or D3DX_DEFAULT, +// a default device window will be created as a child of hwndFocus. +// +// offscreen: +// Both hwnd and hwndFocus must be NULL or D3DX_DEFAULT +// +// [in] DWORD numColorBits: If D3DX_DEFAULT is passed for windowed mode, +// the current desktop's color depth is chosen. +// For full screen mode, D3DX_DEFAULT causes 16 +// bit color to be used. +// [in] DWORD numAlphaBits: If D3DX_DEFAULT is passed, 0 is chosen. +// [in] DWORD numDepthbits: If D3DX_DEFAULT is passed, +// the highest available number of depth bits +// is chosen. See note. +// [in] DWORD numStencilBits: If D3DX_DEFAULT is passed, the highest +// available number of stencil bits is chosen. +// See note. +// +// NOTE: If both numDepthBits and numStencilBits are D3DX_DEFAULT, +// D3DX first picks the highest available number of stencil +// bits. Then, for the chosen number of stencil bits, +// the highest available number of depth bits is chosen. +// If only one of numStencilBits or numDepthBits +// is D3DX_DEFAULT, the highest number of bits available +// for this parameter is chosen out of only the formats +// that support the number of bits requested for the +// fixed parameter. +// +// [in] DWORD numBackBuffers: Number of back buffers, or D3DX_DEFAULT. +// See note. +// +// NOTE: +// windowed: D3DX_DEFAULT means 1. You must specify one back buffer. +// +// fullscreen: D3DX_DEFAULT means 1. Any number of back buffers can be +// specified. +// +// offscreen: D3DX_DEFAULT means 0. You cannot specify additional back +// buffers. +// +// [in] DWORD width: Width, in pixels, or D3DX_DEFAULT. See note. +// [in] DWORD height: Height, in pixels, or D3DX_DEFAULT. See note. +// +// NOTE: +// windowed: If either width or height is D3DX_DEFAULT, both values +// default to the dimensions of the client area of hwnd. +// +// fullscreen: If either width or height is D3DX_DEFAULT, width +// defaults to 640, and height defaults to 480. +// +// offscreen: An error is returned if either width or height is +// D3DX_DEFAULT. +// +// [in] DWORD refreshRate: D3DX_DEFAULT means we let ddraw choose for +// us. Ignored for windowed and offscreen modes. +// [out] LPD3DXCONTEXT* ppCtx: This is the Context object that is used for +// rendering on that device. +// +//------------------------------------------------------------------------- +HRESULT WINAPI + D3DXCreateContext(DWORD deviceIndex, + DWORD flags, + HWND hwnd, + DWORD width, + DWORD height, + LPD3DXCONTEXT* ppCtx); + +HRESULT WINAPI + D3DXCreateContextEx(DWORD deviceIndex, + DWORD flags, + HWND hwnd, + HWND hwndFocus, + DWORD numColorBits, + DWORD numAlphaBits, + DWORD numDepthbits, + DWORD numStencilBits, + DWORD numBackBuffers, + DWORD width, + DWORD height, + DWORD refreshRate, + LPD3DXCONTEXT* ppCtx); + +// The D3DXCreateContext(Ex) flags are: +#define D3DX_CONTEXT_FULLSCREEN 0x00000001 +#define D3DX_CONTEXT_OFFSCREEN 0x00000002 + +//------------------------------------------------------------------------- +// D3DXGetErrorString: Prints out the error string given an hresult. Prints +// ------------------ Win32 as well as DX6 error messages besides the D3DX +// messages. +// +// Params: +// [in] HRESULT hr: The error code to be deciphered. +// [in] DWORD strLength: Length of the string passed in. +// [out] LPSTR pStr: The string output. This string of appropriate +// size needs to be passed in. +//------------------------------------------------------------------------- +void WINAPI + D3DXGetErrorString(HRESULT hr, + DWORD strLength, + LPSTR pStr); + +//------------------------------------------------------------------------- +// D3DXMakeDDPixelFormat: Fills in a DDPIXELFORMAT structure based on the +// --------------------- D3DX surface format requested. +// +// Params: +// [in] D3DX_SURFACEFORMAT d3dxFormat: Surface format. +// [out] DDPIXELFORMAT* pddpf: Pixel format matching the given +// surface format. +//------------------------------------------------------------------------- +HRESULT WINAPI + D3DXMakeDDPixelFormat(D3DX_SURFACEFORMAT d3dxFormat, + DDPIXELFORMAT* pddpf); + +//------------------------------------------------------------------------- +// D3DXMakeSurfaceFormat: Determines the surface format corresponding to +// --------------------- a given DDPIXELFORMAT. +// +// Params: +// [in] DDPIXELFORMAT* pddpf: Pixel format. +// Return Value: +// D3DX_SURFACEFORMAT: Surface format matching the given pixel format. +// D3DX_SF_UNKNOWN if the format is not supported +//------------------------------------------------------------------------- +D3DX_SURFACEFORMAT WINAPI + D3DXMakeSurfaceFormat(DDPIXELFORMAT* pddpf); + +#ifdef __cplusplus +} +#endif //__cplusplus + +/////////////////////////////////////////////////////////////////////////// +// Interfaces: +/////////////////////////////////////////////////////////////////////////// + +//------------------------------------------------------------------------- +// ID3DXContext interface: +// +// This encapsulates all the stuff that the app might +// want to do at initialization time and any global control over d3d and +// ddraw. +//------------------------------------------------------------------------- + + +DECLARE_INTERFACE_(ID3DXContext, IUnknown) +{ + // + // IUnknown methods + // + STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + + // Get the DDraw and Direct3D objects to call DirectDraw or + // Direct3D Immediate Mode functions. + // If the objects don't exist (because they have not + // been created for some reason) NULL is returned. + // All the objects returned in the following Get* functions + // are addref'ed. It is the application's responsibility to + // release them when no longer needed. + STDMETHOD_(LPDIRECTDRAW7,GetDD)(THIS) PURE; + STDMETHOD_(LPDIRECT3D7,GetD3D)(THIS) PURE; + STDMETHOD_(LPDIRECT3DDEVICE7,GetD3DDevice)(THIS) PURE; + + // Get the various buffers that get created at the init time + // These are addref'ed as well. It is the application's responsibility + // to release them before the app quits or when it needs a resize. + STDMETHOD_(LPDIRECTDRAWSURFACE7,GetPrimary)(THIS) PURE; + STDMETHOD_(LPDIRECTDRAWSURFACE7,GetZBuffer)(THIS) PURE; + STDMETHOD_(LPDIRECTDRAWSURFACE7,GetBackBuffer)(THIS_ DWORD which) PURE; + + // Get the associated window handles + STDMETHOD_(HWND,GetWindow)(THIS) PURE; + STDMETHOD_(HWND,GetFocusWindow)(THIS) PURE; + + // + // Various Get methods, in case the user had specified default + // parameters + // + STDMETHOD(GetDeviceIndex)(THIS_ + LPDWORD pDeviceIndex, + LPDWORD pHwLevel) PURE; + + STDMETHOD_(DWORD, GetNumBackBuffers)(THIS) PURE; + + STDMETHOD(GetNumBits)(THIS_ + LPDWORD pColorBits, + LPDWORD pDepthBits, + LPDWORD pAlphaBits, + LPDWORD pStencilBits) PURE; + + STDMETHOD(GetBufferSize)(THIS_ + LPDWORD pWidth, + LPDWORD pHeight) PURE; + + // Get the flags that were used to create this context + STDMETHOD_(DWORD, GetCreationFlags)(THIS) PURE; + STDMETHOD_(DWORD, GetRefreshRate)(THIS) PURE; + + // Restoring surfaces in case stuff is lost + STDMETHOD(RestoreSurfaces)(THIS) PURE; + + // Resize all the buffers to the new width and height + STDMETHOD(Resize)(THIS_ DWORD width, DWORD height) PURE; + + // Update the frame using a flip or a blit, + // If the D3DX_UPDATE_NOVSYNC flag is set, blit is used if the + // driver cannot flip without waiting for vsync in full-screen mode. + STDMETHOD(UpdateFrame)(THIS_ DWORD flags) PURE; + + // Render a string at the specified coordinates, with the specified + // colour. This is only provided as a convenience for + // debugging/information during development. + // topLeftX and topLeftY represent the location of the top left corner + // of the string, on the render target. + // The coordinate and color parameters each have a range of 0.0-1.0 + STDMETHOD(DrawDebugText)(THIS_ + float topLeftX, + float topLeftY, + D3DCOLOR color, + LPSTR pString) PURE; + + // Clears to the current viewport + // The following are the valid flags: + // D3DCLEAR_TARGET (to clear the render target ) + // D3DCLEAR_ZBUFFER (to clear the depth-buffer ) + // D3DCLEAR_STENCIL (to clear the stencil-buffer ) + STDMETHOD(Clear)(THIS_ DWORD ClearFlags) PURE; + + STDMETHOD(SetClearColor)(THIS_ D3DCOLOR color ) PURE; + STDMETHOD(SetClearDepth)(THIS_ float z) PURE; + STDMETHOD(SetClearStencil)(THIS_ DWORD stencil) PURE; +}; + + +//------------------------------------------------------------------------- +// Flags for Update member function: +// + +// Flag to indicate that blit should be used instead of a flip +// for full-screen rendering. +#define D3DX_UPDATE_NOVSYNC (1<<0) + +/////////////////////////////////////////////////////////////////////////// +// Texturing APIs: +/////////////////////////////////////////////////////////////////////////// +#ifdef __cplusplus +extern "C" { +#endif //__cplusplus + +//------------------------------------------------------------------------- +// D3DXCheckTextureRequirements: Return information about texture creation +// ---------------------------- (used by CreateTexture, CreateTextureFromFile +// and CreateCubeMapTexture) +// +// Parameters: +// +// pd3dDevice +// The D3D device with which the texture is going to be used. +// pFlags +// allows specification of D3DX_TEXTURE_NOMIPMAP +// D3DX_TEXTURE_NOMIPMAP may be returned in the case where mipmap creation +// is not supported. +// pWidth +// width in pixels or NULL +// returns corrected width +// pHeight +// height in pixels or NULL +// returns corrected height +// pPixelFormat +// surface format +// returns best match to input format +// +// Notes: 1. Unless the flags is set to specifically prevent creating +// mipmaps, mipmaps are generated all the way till 1x1 surface. +// 2. width, height and pixelformat are altered based on available +// hardware. For example: +// a. Texture dimensions may be required to be powers of 2 +// b. We may require width == height for some devices +// c. If PixelFormat is unavailable, a best fit is made +//------------------------------------------------------------------------- +HRESULT WINAPI + D3DXCheckTextureRequirements( LPDIRECT3DDEVICE7 pd3dDevice, + LPDWORD pFlags, + LPDWORD pWidth, + LPDWORD pHeight, + D3DX_SURFACEFORMAT* pPixelFormat); + +//------------------------------------------------------------------------- +// D3DXCreateTexture: Create an empty texture object +// ----------------- +// +// Parameters: +// +// pd3dDevice +// The D3D device with which the texture is going to be used. +// pFlags +// allows specification of D3DX_TEXTURE_NOMIPMAP +// D3DX_TEXTURE_NOMIPMAP may be returned in the case where mipmap creation +// is not supported. Additionally, D3DX_TEXTURE_STAGE can be specified +// to indicate which texture stage the texture is for e.g. +// D3D_TEXTURE_STAGE1 indicates that the texture is for use with texture +// stage one. Stage Zero is the default if no TEXTURE_STAGE flags are +// set. +// pWidth +// width in pixels; 0 or NULL is unacceptable +// returns corrected width +// pHeight +// height in pixels; 0 or NULL is unacceptable +// returns corrected height +// pPixelFormat +// surface format. D3DX_DEFAULT is unacceptable. +// returns actual format that was used +// pDDPal +// DDraw palette that is set (if present) on paletted surfaces. +// It is ignored even if it is set, for non-paletted surfaces. +// ppDDSurf +// The ddraw surface that will be created +// pNumMipMaps +// the number of mipmaps actually generated +// +// Notes: See notes for D3DXCheckTextureRequirements. +//------------------------------------------------------------------------- +HRESULT WINAPI + D3DXCreateTexture( LPDIRECT3DDEVICE7 pd3dDevice, + LPDWORD pFlags, + LPDWORD pWidth, + LPDWORD pHeight, + D3DX_SURFACEFORMAT* pPixelFormat, + LPDIRECTDRAWPALETTE pDDPal, + LPDIRECTDRAWSURFACE7* ppDDSurf, + LPDWORD pNumMipMaps); + +//------------------------------------------------------------------------- +// D3DXCreateCubeMapTexture: Create blank cube-map texture +// ------------------------ +// +// Parameters: +// +// pd3dDevice +// The D3D device with which the texture is going to be used. +// pFlags +// allows specification of D3DX_TEXTURE_NOMIPMAP +// D3DX_TEXTURE_NOMIPMAP may be returned in the case where mipmap creation +// is not supported. Additionally, D3DX_TEXTURE_STAGE can be specified +// to indicate which texture stage the texture is for e.g. +// D3D_TEXTURE_STAGE1 indicates that the texture is for use with texture +// stage one. Stage Zero is the default if no TEXTURE_STAGE flags are +// set. +// cubefaces +// allows specification of which faces of the cube-map to generate. +// D3DX_DEFAULT, 0, and DDSCAPS2_CUBEMAP_ALLFACES all mean +// "create all 6 faces of the cubemap". Any combination of +// DDSCAPS2_CUBEMAP_POSITIVEX, DDSCAPS2_CUBEMAP_NEGATIVEX, +// DDSCAPS2_CUBEMAP_POSITIVEY, DDSCAPS2_CUBEMAP_NEGATIVEY, +// DDSCAPS2_CUBEMAP_POSITIVEZ, or DDSCAPS2_CUBEMAP_NEGATIVEZ, is +// valid. +// colorEmptyFaces +// allows specification of the color to use for the faces that were not +// specified in the cubefaces parameter. +// pWidth +// width in pixels; 0 or NULL is unacceptable +// returns corrected width +// pHeight +// height in pixels; 0 or NULL is unacceptable +// returns corrected height +// pPixelFormat +// surface format. D3DX_DEFAULT is unacceptable. +// returns actual format that was used +// pDDPal +// DDraw palette that is set (if present) on paletted surfaces. +// It is ignored even if it is set, for non-paletted surfaces. +// ppDDSurf +// the ddraw surface that will be created +// pNumMipMaps +// the number of mipmaps generated for a particular face of the +// cubemap. +// +// Notes: See notes for D3DXCheckTextureRequirements. +//------------------------------------------------------------------------- +HRESULT WINAPI + D3DXCreateCubeMapTexture( LPDIRECT3DDEVICE7 pd3dDevice, + LPDWORD pFlags, + DWORD cubefaces, + D3DCOLOR colorEmptyFaces, + LPDWORD pWidth, + LPDWORD pHeight, + D3DX_SURFACEFORMAT *pPixelFormat, + LPDIRECTDRAWPALETTE pDDPal, + LPDIRECTDRAWSURFACE7* ppDDSurf, + LPDWORD pNumMipMaps); + + +//------------------------------------------------------------------------- +// D3DXCreateTextureFromFile: Create a texture object from a file or from the +// ------------------------- resource. Only BMP and DIB are supported from the +// resource portion of the executable. +// +// Parameters: +// +// pd3dDevice +// The D3D device with which the texture is going to be used. +// pFlags +// allows specification of D3DX_TEXTURE_NOMIPMAP +// D3DX_TEXTURE_NOMIPMAP may be returned in the case where mipmap creation +// is not supported. Additionally, D3DX_TEXTURE_STAGE can be specified +// to indicate which texture stage the texture is for e.g. +// D3D_TEXTURE_STAGE1 indicates that the texture is for use with texture +// stage one. Stage Zero is the default if no TEXTURE_STAGE flags are +// set. +// pWidth +// Width in pixels. If 0 or D3DX_DEFAULT, the width will be taken +// from the file +// returns corrected width +// pHeight +// Height in pixels. If 0 or D3DX_DEFAULT, the height will be taken +// from the file +// returns corrected height +// pPixelFormat +// If D3DX_SF_UNKNOWN is passed in, pixel format closest to the bitmap +// will be chosen +// returns actual format that was used +// pDDPal +// DDraw palette that is set (if present) on paletted surfaces. +// It is ignored even if it is set, for non-paletted surfaces. +// ppDDSurf +// The ddraw surface that will be created. +// pNumMipMaps +// The number of mipmaps generated. +// pSrcName +// File name. BMP, DIB, DDS, are supported. +// +// TGA is supported for the following cases: 16, 24, 32bpp direct color and 8bpp palettized. +// Also, 8, 16bpp grayscale is supported. RLE versions of the above +// TGA formats are also supported. ColorKey and Premultiplied Alpha +// are not currently supported for TGA files. +// returns created format +// +// Notes: See notes for D3DXCheckTextureRequirements. +//------------------------------------------------------------------------- +HRESULT WINAPI + D3DXCreateTextureFromFile( LPDIRECT3DDEVICE7 pd3dDevice, + LPDWORD pFlags, + LPDWORD pWidth, + LPDWORD pHeight, + D3DX_SURFACEFORMAT* pPixelFormat, + LPDIRECTDRAWPALETTE pDDPal, + LPDIRECTDRAWSURFACE7* ppDDSurf, + LPDWORD pNumMipMaps, + LPSTR pSrcName, + D3DX_FILTERTYPE filterType); + +//------------------------------------------------------------------------- +// D3DXLoadTextureFromFile: Load from a file into a mipmap level. Doing the +// ----------------------- necessary color conversion and rescaling. File +// format support is identical to +// D3DXCreateTextureFromFile's. +// +// pd3dDevice +// The D3D device with which the texture is going to be used. +// pTexture +// a pointer to a DD7Surface which was created with either +// CreateTextureFromFile or CreateTexture. +// mipMapLevel +// indicates mipmap level +// Note: +// 1. Error if mipmap level doesn't exist +// 2. If D3DX_DEFAULT and equal number of mipmap levels exist +// then all the source mip-levels are loaded +// 3. If the source has mipmaps and the dest doesn't, use the top one +// 4. If the dest has miplevels and source doesn't, we expand +// 5. If there are unequal numbers of miplevels, we expand +// pSrcName +// File name. BMP, DIB, DDS, are supported. +// For details on TGA support, refer to the comments for +// D3DXCreateTextureFromFile +// pSrcRect +// the source rectangle or null (whole surface) +// pDestRect +// the destination rectangle or null (whole surface) +// filterType +// filter used for mipmap generation +//------------------------------------------------------------------------- +HRESULT WINAPI + D3DXLoadTextureFromFile( LPDIRECT3DDEVICE7 pd3dDevice, + LPDIRECTDRAWSURFACE7 pTexture, + DWORD mipMapLevel, + LPSTR pSrcName, + RECT* pSrcRect, + RECT* pDestRect, + D3DX_FILTERTYPE filterType); + +//------------------------------------------------------------------------- +// D3DXLoadTextureFromSurface: Load from a DDraw Surface into a mipmap level. +// -------------------------- Doing the necessary color conversion. +// +// pd3dDevice +// The D3D device with which the texture is going to be used. +// pTexture +// a pointer to a DD7Surface which was created with either +// CreateTextureFromFile or CreateTexture. +// mipMapLevel +// indicates mipmap level +// Note: +// 1. Error if mipmap level doesn't exist +// 2. If D3DX_DEFAULT and equal number of mipmap levels exist +// then all the source mip-levels are loaded +// 3. If the source has mipmaps and the dest doesn't, use the top one +// 4. If the dest has miplevels and source doesn't, we expand +// 5. If there are unequal numbers of miplevels, we expand +// pSurfaceSrc +// the source surface +// pSrcRect +// the source rectangle or null (whole surface) +// pDestRect +// the destination rectangle or null (whole surface) +// filterType +// filter used for mipmap generation +//------------------------------------------------------------------------- +HRESULT WINAPI + D3DXLoadTextureFromSurface( LPDIRECT3DDEVICE7 pd3dDevice, + LPDIRECTDRAWSURFACE7 pTexture, + DWORD mipMapLevel, + LPDIRECTDRAWSURFACE7 pSurfaceSrc, + RECT* pSrcRect, + RECT* pDestRect, + D3DX_FILTERTYPE filterType); + +//------------------------------------------------------------------------- +// D3DXLoadTextureFromMemory: Load a mip level from memory. Doing the necessary +// ------------------------- color conversion. +// +// pd3dDevice +// The D3D device with which the texture is going to be used. +// pTexture +// a pointer to a DD7Surface which was created with either +// CreateTextureFromFile or CreateTexture. +// mipMapLevel +// indicates mipmap level +// Note: +// 1. Error if mipmap level doesn't exist +// 2. If D3DX_DEFAULT and equal number of mipmap levels exist +// then all the source mip-levels are loaded +// 3. If the source has mipmaps and the dest doesn't, use the top one +// 4. If the dest has miplevels and source doesn't, we expand +// 5. If there are unequal numbers of miplevels, we expand +// pMemory +// pointer to source memory from which the texture will be loaded +// pDDPal +// DirectDraw Palette, that the app passes in optionally if the memory is +// supposed to be paletteized. +// srcPixelFormat +// PixelFormat of the source. +// srcPitch +// The pitch of the memory or D3DX_DEFAULT (based on srcPixelFormat) +// pDestRect +// The destination rectangle or null (whole surface) +// filterType +// filter used for mipmap generation +// +// Assumptions: The source (memory) is loaded in full +//------------------------------------------------------------------------- +HRESULT WINAPI + D3DXLoadTextureFromMemory( LPDIRECT3DDEVICE7 pd3dDevice, + LPDIRECTDRAWSURFACE7 pTexture, + DWORD mipMapLevel, + LPVOID pMemory, + LPDIRECTDRAWPALETTE pDDPal, + D3DX_SURFACEFORMAT srcPixelFormat, + DWORD srcPitch, + RECT* pDestRect, + D3DX_FILTERTYPE filterType); + +#ifdef __cplusplus +} +#endif //__cplusplus + +//------------------------------------------------------------------------- +// Flags for texture create functions; applies to +// D3DXCreateTexture, D3DXCreateCubeMapTexture and D3DXCreateTextureFromFile. +// + +// Flag to indicate that mipmap generation is not desired. +#define D3DX_TEXTURE_NOMIPMAP (1 << 8) + +// Flags to indicate which texture stage the texture is +// intended for use with. Specifying the stage is necessary at +// texture creation time for HW devices that expose the +// D3DDEVCAPS_SEPARATETEXTUREMEMORIES bit in their D3DDEVICEDESC +// structure. +#define D3DX_TEXTURE_STAGE0 (0) +#define D3DX_TEXTURE_STAGE1 (1) +#define D3DX_TEXTURE_STAGE2 (2) +#define D3DX_TEXTURE_STAGE3 (3) +#define D3DX_TEXTURE_STAGE4 (4) +#define D3DX_TEXTURE_STAGE5 (5) +#define D3DX_TEXTURE_STAGE6 (6) +#define D3DX_TEXTURE_STAGE7 (7) + +// Mask to extract the texture stage value out of the flags to +// the texture create functions. +#define D3DX_TEXTURE_STAGE_MASK (0x7) + +#endif //__D3DXCORE_H__ diff --git a/engine/libs/dxsdk7/include/d3dxerr.h b/engine/libs/dxsdk7/include/d3dxerr.h new file mode 100644 index 000000000..f1b4b6593 --- /dev/null +++ b/engine/libs/dxsdk7/include/d3dxerr.h @@ -0,0 +1,407 @@ +//---------------------------------------------------------------------- +// +// d3dxerr.h -- 0xC code definitions for the D3DX API +// +// Copyright (c) 1991-1999, Microsoft Corp. All rights reserved. +// +//---------------------------------------------------------------------- +#ifndef __D3DXERR_H__ +#define __D3DXERR_H__ + +// +// +// Values are 32 bit values layed out as follows: +// +// 3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 +// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 +// +---+-+-+-----------------------+-------------------------------+ +// |Sev|C|R| Facility | Code | +// +---+-+-+-----------------------+-------------------------------+ +// +// where +// +// Sev - is the severity code +// +// 00 - Success +// 01 - Informational +// 10 - Warning +// 11 - Error +// +// C - is the Customer code flag +// +// R - is a reserved bit +// +// Facility - is the facility code +// +// Code - is the facility's status code +// +// +// Define the facility codes +// +#define FACILITY_D3DX 0x877 + + + +// +// MessageId: D3DXERR_NOMEMORY +// +// MessageText: +// +// Out of memory. +// +#define D3DXERR_NOMEMORY ((HRESULT)0xC8770BB8L) + + +// +// MessageId: D3DXERR_NULLPOINTER +// +// MessageText: +// +// A NULL pointer was passed as a parameter. +// +#define D3DXERR_NULLPOINTER ((HRESULT)0xC8770BB9L) + + +// +// MessageId: D3DXERR_INVALIDD3DXDEVICEINDEX +// +// MessageText: +// +// The Device Index passed in is invalid. +// +#define D3DXERR_INVALIDD3DXDEVICEINDEX ((HRESULT)0xC8770BBAL) + + +// +// MessageId: D3DXERR_NODIRECTDRAWAVAILABLE +// +// MessageText: +// +// DirectDraw has not been created. +// +#define D3DXERR_NODIRECTDRAWAVAILABLE ((HRESULT)0xC8770BBBL) + + +// +// MessageId: D3DXERR_NODIRECT3DAVAILABLE +// +// MessageText: +// +// Direct3D has not been created. +// +#define D3DXERR_NODIRECT3DAVAILABLE ((HRESULT)0xC8770BBCL) + + +// +// MessageId: D3DXERR_NODIRECT3DDEVICEAVAILABLE +// +// MessageText: +// +// Direct3D device has not been created. +// +#define D3DXERR_NODIRECT3DDEVICEAVAILABLE ((HRESULT)0xC8770BBDL) + + +// +// MessageId: D3DXERR_NOPRIMARYAVAILABLE +// +// MessageText: +// +// Primary surface has not been created. +// +#define D3DXERR_NOPRIMARYAVAILABLE ((HRESULT)0xC8770BBEL) + + +// +// MessageId: D3DXERR_NOZBUFFERAVAILABLE +// +// MessageText: +// +// Z buffer has not been created. +// +#define D3DXERR_NOZBUFFERAVAILABLE ((HRESULT)0xC8770BBFL) + + +// +// MessageId: D3DXERR_NOBACKBUFFERAVAILABLE +// +// MessageText: +// +// Backbuffer has not been created. +// +#define D3DXERR_NOBACKBUFFERAVAILABLE ((HRESULT)0xC8770BC0L) + + +// +// MessageId: D3DXERR_COULDNTUPDATECAPS +// +// MessageText: +// +// Failed to update caps database after changing display mode. +// +#define D3DXERR_COULDNTUPDATECAPS ((HRESULT)0xC8770BC1L) + + +// +// MessageId: D3DXERR_NOZBUFFER +// +// MessageText: +// +// Could not create Z buffer. +// +#define D3DXERR_NOZBUFFER ((HRESULT)0xC8770BC2L) + + +// +// MessageId: D3DXERR_INVALIDMODE +// +// MessageText: +// +// Display mode is not valid. +// +#define D3DXERR_INVALIDMODE ((HRESULT)0xC8770BC3L) + + +// +// MessageId: D3DXERR_INVALIDPARAMETER +// +// MessageText: +// +// One or more of the parameters passed is invalid. +// +#define D3DXERR_INVALIDPARAMETER ((HRESULT)0xC8770BC4L) + + +// +// MessageId: D3DXERR_INITFAILED +// +// MessageText: +// +// D3DX failed to initialize itself. +// +#define D3DXERR_INITFAILED ((HRESULT)0xC8770BC5L) + + +// +// MessageId: D3DXERR_STARTUPFAILED +// +// MessageText: +// +// D3DX failed to start up. +// +#define D3DXERR_STARTUPFAILED ((HRESULT)0xC8770BC6L) + + +// +// MessageId: D3DXERR_D3DXNOTSTARTEDYET +// +// MessageText: +// +// D3DXInitialize() must be called first. +// +#define D3DXERR_D3DXNOTSTARTEDYET ((HRESULT)0xC8770BC7L) + + +// +// MessageId: D3DXERR_NOTINITIALIZED +// +// MessageText: +// +// D3DX is not initialized yet. +// +#define D3DXERR_NOTINITIALIZED ((HRESULT)0xC8770BC8L) + + +// +// MessageId: D3DXERR_FAILEDDRAWTEXT +// +// MessageText: +// +// Failed to render text to the surface. +// +#define D3DXERR_FAILEDDRAWTEXT ((HRESULT)0xC8770BC9L) + + +// +// MessageId: D3DXERR_BADD3DXCONTEXT +// +// MessageText: +// +// Bad D3DX context. +// +#define D3DXERR_BADD3DXCONTEXT ((HRESULT)0xC8770BCAL) + + +// +// MessageId: D3DXERR_CAPSNOTSUPPORTED +// +// MessageText: +// +// The requested device capabilities are not supported. +// +#define D3DXERR_CAPSNOTSUPPORTED ((HRESULT)0xC8770BCBL) + + +// +// MessageId: D3DXERR_UNSUPPORTEDFILEFORMAT +// +// MessageText: +// +// The image file format is unrecognized. +// +#define D3DXERR_UNSUPPORTEDFILEFORMAT ((HRESULT)0xC8770BCCL) + + +// +// MessageId: D3DXERR_IFLERROR +// +// MessageText: +// +// The image file loading library error. +// +#define D3DXERR_IFLERROR ((HRESULT)0xC8770BCDL) + + +// +// MessageId: D3DXERR_FAILEDGETCAPS +// +// MessageText: +// +// Could not obtain device caps. +// +#define D3DXERR_FAILEDGETCAPS ((HRESULT)0xC8770BCEL) + + +// +// MessageId: D3DXERR_CANNOTRESIZEFULLSCREEN +// +// MessageText: +// +// Resize does not work for full-screen. +// +#define D3DXERR_CANNOTRESIZEFULLSCREEN ((HRESULT)0xC8770BCFL) + + +// +// MessageId: D3DXERR_CANNOTRESIZENONWINDOWED +// +// MessageText: +// +// Resize does not work for non-windowed contexts. +// +#define D3DXERR_CANNOTRESIZENONWINDOWED ((HRESULT)0xC8770BD0L) + + +// +// MessageId: D3DXERR_FRONTBUFFERALREADYEXISTS +// +// MessageText: +// +// Front buffer already exists. +// +#define D3DXERR_FRONTBUFFERALREADYEXISTS ((HRESULT)0xC8770BD1L) + + +// +// MessageId: D3DXERR_FULLSCREENPRIMARYEXISTS +// +// MessageText: +// +// The app is using the primary in full-screen mode. +// +#define D3DXERR_FULLSCREENPRIMARYEXISTS ((HRESULT)0xC8770BD2L) + + +// +// MessageId: D3DXERR_GETDCFAILED +// +// MessageText: +// +// Could not get device context. +// +#define D3DXERR_GETDCFAILED ((HRESULT)0xC8770BD3L) + + +// +// MessageId: D3DXERR_BITBLTFAILED +// +// MessageText: +// +// Could not bitBlt. +// +#define D3DXERR_BITBLTFAILED ((HRESULT)0xC8770BD4L) + + +// +// MessageId: D3DXERR_NOTEXTURE +// +// MessageText: +// +// There is no surface backing up this texture. +// +#define D3DXERR_NOTEXTURE ((HRESULT)0xC8770BD5L) + + +// +// MessageId: D3DXERR_MIPLEVELABSENT +// +// MessageText: +// +// There is no such miplevel for this surface. +// +#define D3DXERR_MIPLEVELABSENT ((HRESULT)0xC8770BD6L) + + +// +// MessageId: D3DXERR_SURFACENOTPALETTED +// +// MessageText: +// +// The surface is not paletted. +// +#define D3DXERR_SURFACENOTPALETTED ((HRESULT)0xC8770BD7L) + + +// +// MessageId: D3DXERR_ENUMFORMATSFAILED +// +// MessageText: +// +// An error occured while enumerating surface formats. +// +#define D3DXERR_ENUMFORMATSFAILED ((HRESULT)0xC8770BD8L) + + +// +// MessageId: D3DXERR_COLORDEPTHTOOLOW +// +// MessageText: +// +// D3DX only supports color depths of 16 bit or greater. +// +#define D3DXERR_COLORDEPTHTOOLOW ((HRESULT)0xC8770BD9L) + + +// +// MessageId: D3DXERR_INVALIDFILEFORMAT +// +// MessageText: +// +// The file format is invalid. +// +#define D3DXERR_INVALIDFILEFORMAT ((HRESULT)0xC8770BDAL) + + +// +// MessageId: D3DXERR_NOMATCHFOUND +// +// MessageText: +// +// No suitable match found. +// +#define D3DXERR_NOMATCHFOUND ((HRESULT)0xC8770BDBL) + + + +#endif //__D3DXERR_H__ + diff --git a/engine/libs/dxsdk7/include/d3dxmath.h b/engine/libs/dxsdk7/include/d3dxmath.h new file mode 100644 index 000000000..7a2bd010c --- /dev/null +++ b/engine/libs/dxsdk7/include/d3dxmath.h @@ -0,0 +1,1085 @@ +////////////////////////////////////////////////////////////////////////////// +// +// Copyright (C) 1998 Microsoft Corporation. All Rights Reserved. +// +// File: d3dxmath.h +// Content: D3DX math types and functions +// +////////////////////////////////////////////////////////////////////////////// + +#ifndef __D3DXMATH_H__ +#define __D3DXMATH_H__ + +#include +#include +#include +#include "d3dxerr.h" + +#ifndef D3DXINLINE +#ifdef __cplusplus +#define D3DXINLINE inline +#else +#define D3DXINLINE _inline +#endif +#endif + +#pragma warning(disable:4201) // anonymous unions warning + + + +typedef struct ID3DXMatrixStack *LPD3DXMATRIXSTACK; + +// {E3357330-CC5E-11d2-A434-00A0C90629A8} +DEFINE_GUID( IID_ID3DXMatrixStack, + 0xe3357330, 0xcc5e, 0x11d2, 0xa4, 0x34, 0x0, 0xa0, 0xc9, 0x6, 0x29, 0xa8); + + +//=========================================================================== +// +// General purpose utilities +// +//=========================================================================== +#define D3DX_PI ((float) 3.141592654f) +#define D3DX_1BYPI ((float) 0.318309886f) + +#define D3DXToRadian( degree ) ((degree) * (D3DX_PI / 180.0f)) +#define D3DXToDegree( radian ) ((radian) * (180.0f / D3DX_PI)) + + + +//=========================================================================== +// +// Vectors +// +//=========================================================================== + +//-------------------------- +// 2D Vector +//-------------------------- +typedef struct D3DXVECTOR2 +{ +#ifdef __cplusplus +public: + D3DXVECTOR2() {}; + D3DXVECTOR2( const float * ); + D3DXVECTOR2( float x, float y ); + + // casting + operator float* (); + operator const float* () const; + + // assignment operators + D3DXVECTOR2& operator += ( const D3DXVECTOR2& ); + D3DXVECTOR2& operator -= ( const D3DXVECTOR2& ); + D3DXVECTOR2& operator *= ( float ); + D3DXVECTOR2& operator /= ( float ); + + // unary operators + D3DXVECTOR2 operator + () const; + D3DXVECTOR2 operator - () const; + + // binary operators + D3DXVECTOR2 operator + ( const D3DXVECTOR2& ) const; + D3DXVECTOR2 operator - ( const D3DXVECTOR2& ) const; + D3DXVECTOR2 operator * ( float ) const; + D3DXVECTOR2 operator / ( float ) const; + + friend D3DXVECTOR2 operator * ( float, const D3DXVECTOR2& ); + + BOOL operator == ( const D3DXVECTOR2& ) const; + BOOL operator != ( const D3DXVECTOR2& ) const; + + +public: +#endif //__cplusplus + float x, y; +} D3DXVECTOR2, *LPD3DXVECTOR2; + + +//-------------------------- +// 3D Vector +//-------------------------- +typedef struct D3DXVECTOR3 +{ +#ifdef __cplusplus +public: + D3DXVECTOR3() {}; + D3DXVECTOR3( const float * ); + D3DXVECTOR3( const D3DVECTOR& ); + D3DXVECTOR3( float x, float y, float z ); + + // casting + operator float* (); + operator const float* () const; + + operator D3DVECTOR* (); + operator const D3DVECTOR* () const; + + operator D3DVECTOR& (); + operator const D3DVECTOR& () const; + + // assignment operators + D3DXVECTOR3& operator += ( const D3DXVECTOR3& ); + D3DXVECTOR3& operator -= ( const D3DXVECTOR3& ); + D3DXVECTOR3& operator *= ( float ); + D3DXVECTOR3& operator /= ( float ); + + // unary operators + D3DXVECTOR3 operator + () const; + D3DXVECTOR3 operator - () const; + + // binary operators + D3DXVECTOR3 operator + ( const D3DXVECTOR3& ) const; + D3DXVECTOR3 operator - ( const D3DXVECTOR3& ) const; + D3DXVECTOR3 operator * ( float ) const; + D3DXVECTOR3 operator / ( float ) const; + + friend D3DXVECTOR3 operator * ( float, const struct D3DXVECTOR3& ); + + BOOL operator == ( const D3DXVECTOR3& ) const; + BOOL operator != ( const D3DXVECTOR3& ) const; + +public: +#endif //__cplusplus + float x, y, z; +} D3DXVECTOR3, *LPD3DXVECTOR3; + + +//-------------------------- +// 4D Vector +//-------------------------- +typedef struct D3DXVECTOR4 +{ +#ifdef __cplusplus +public: + D3DXVECTOR4() {}; + D3DXVECTOR4( const float* ); + D3DXVECTOR4( float x, float y, float z, float w ); + + // casting + operator float* (); + operator const float* () const; + + // assignment operators + D3DXVECTOR4& operator += ( const D3DXVECTOR4& ); + D3DXVECTOR4& operator -= ( const D3DXVECTOR4& ); + D3DXVECTOR4& operator *= ( float ); + D3DXVECTOR4& operator /= ( float ); + + // unary operators + D3DXVECTOR4 operator + () const; + D3DXVECTOR4 operator - () const; + + // binary operators + D3DXVECTOR4 operator + ( const D3DXVECTOR4& ) const; + D3DXVECTOR4 operator - ( const D3DXVECTOR4& ) const; + D3DXVECTOR4 operator * ( float ) const; + D3DXVECTOR4 operator / ( float ) const; + + friend D3DXVECTOR4 operator * ( float, const D3DXVECTOR4& ); + + BOOL operator == ( const D3DXVECTOR4& ) const; + BOOL operator != ( const D3DXVECTOR4& ) const; + +public: +#endif //__cplusplus + float x, y, z, w; +} D3DXVECTOR4, *LPD3DXVECTOR4; + + +//=========================================================================== +// +// Matrices +// +//=========================================================================== +typedef struct D3DXMATRIX +{ +#ifdef __cplusplus +public: + D3DXMATRIX() {}; + D3DXMATRIX( const float * ); + D3DXMATRIX( const D3DMATRIX& ); + D3DXMATRIX( float m00, float m01, float m02, float m03, + float m10, float m11, float m12, float m13, + float m20, float m21, float m22, float m23, + float m30, float m31, float m32, float m33 ); + + + // access grants + float& operator () ( UINT iRow, UINT iCol ); + float operator () ( UINT iRow, UINT iCol ) const; + + // casting operators + operator float* (); + operator const float* () const; + + operator D3DMATRIX* (); + operator const D3DMATRIX* () const; + + operator D3DMATRIX& (); + operator const D3DMATRIX& () const; + + // assignment operators + D3DXMATRIX& operator *= ( const D3DXMATRIX& ); + D3DXMATRIX& operator += ( const D3DXMATRIX& ); + D3DXMATRIX& operator -= ( const D3DXMATRIX& ); + D3DXMATRIX& operator *= ( float ); + D3DXMATRIX& operator /= ( float ); + + // unary operators + D3DXMATRIX operator + () const; + D3DXMATRIX operator - () const; + + // binary operators + D3DXMATRIX operator * ( const D3DXMATRIX& ) const; + D3DXMATRIX operator + ( const D3DXMATRIX& ) const; + D3DXMATRIX operator - ( const D3DXMATRIX& ) const; + D3DXMATRIX operator * ( float ) const; + D3DXMATRIX operator / ( float ) const; + + friend D3DXMATRIX operator * ( float, const D3DXMATRIX& ); + + BOOL operator == ( const D3DXMATRIX& ) const; + BOOL operator != ( const D3DXMATRIX& ) const; + + +#endif //__cplusplus + + union + { + float m[4][4]; +#ifdef __cplusplus + struct + { + float m00, m01, m02, m03; + float m10, m11, m12, m13; + float m20, m21, m22, m23; + float m30, m31, m32, m33; + }; +#endif //__cplusplus + }; +} D3DXMATRIX, *LPD3DXMATRIX; + + +//=========================================================================== +// +// Quaternions +// +//=========================================================================== +typedef struct D3DXQUATERNION +{ +#ifdef __cplusplus +public: + D3DXQUATERNION() {} + D3DXQUATERNION( const float * ); + D3DXQUATERNION( float x, float y, float z, float w ); + + // casting + operator float* (); + operator const float* () const; + + // assignment operators + D3DXQUATERNION& operator += ( const D3DXQUATERNION& ); + D3DXQUATERNION& operator -= ( const D3DXQUATERNION& ); + D3DXQUATERNION& operator *= ( const D3DXQUATERNION& ); + D3DXQUATERNION& operator *= ( float ); + D3DXQUATERNION& operator /= ( float ); + + // unary operators + D3DXQUATERNION operator + () const; + D3DXQUATERNION operator - () const; + + // binary operators + D3DXQUATERNION operator + ( const D3DXQUATERNION& ) const; + D3DXQUATERNION operator - ( const D3DXQUATERNION& ) const; + D3DXQUATERNION operator * ( const D3DXQUATERNION& ) const; + D3DXQUATERNION operator * ( float ) const; + D3DXQUATERNION operator / ( float ) const; + + friend D3DXQUATERNION operator * (float, const D3DXQUATERNION& ); + + BOOL operator == ( const D3DXQUATERNION& ) const; + BOOL operator != ( const D3DXQUATERNION& ) const; + +#endif //__cplusplus + float x, y, z, w; +} D3DXQUATERNION, *LPD3DXQUATERNION; + + +//=========================================================================== +// +// Planes +// +//=========================================================================== +typedef struct D3DXPLANE +{ +#ifdef __cplusplus +public: + D3DXPLANE() {} + D3DXPLANE( const float* ); + D3DXPLANE( float a, float b, float c, float d ); + + // casting + operator float* (); + operator const float* () const; + + // unary operators + D3DXPLANE operator + () const; + D3DXPLANE operator - () const; + + // binary operators + BOOL operator == ( const D3DXPLANE& ) const; + BOOL operator != ( const D3DXPLANE& ) const; + +#endif //__cplusplus + float a, b, c, d; +} D3DXPLANE, *LPD3DXPLANE; + + +//=========================================================================== +// +// Colors +// +//=========================================================================== + +typedef struct D3DXCOLOR +{ +#ifdef __cplusplus +public: + D3DXCOLOR() {} + D3DXCOLOR( DWORD argb ); + D3DXCOLOR( const float * ); + D3DXCOLOR( const D3DCOLORVALUE& ); + D3DXCOLOR( float r, float g, float b, float a ); + + // casting + operator DWORD () const; + + operator float* (); + operator const float* () const; + + operator D3DCOLORVALUE* (); + operator const D3DCOLORVALUE* () const; + + operator D3DCOLORVALUE& (); + operator const D3DCOLORVALUE& () const; + + // assignment operators + D3DXCOLOR& operator += ( const D3DXCOLOR& ); + D3DXCOLOR& operator -= ( const D3DXCOLOR& ); + D3DXCOLOR& operator *= ( float ); + D3DXCOLOR& operator /= ( float ); + + // unary operators + D3DXCOLOR operator + () const; + D3DXCOLOR operator - () const; + + // binary operators + D3DXCOLOR operator + ( const D3DXCOLOR& ) const; + D3DXCOLOR operator - ( const D3DXCOLOR& ) const; + D3DXCOLOR operator * ( float ) const; + D3DXCOLOR operator / ( float ) const; + + friend D3DXCOLOR operator * (float, const D3DXCOLOR& ); + + BOOL operator == ( const D3DXCOLOR& ) const; + BOOL operator != ( const D3DXCOLOR& ) const; + +#endif //__cplusplus + FLOAT r, g, b, a; +} D3DXCOLOR, *LPD3DXCOLOR; + + + +//=========================================================================== +// +// D3DX math functions: +// +// NOTE: +// * All these functions can take the same object as in and out parameters. +// +// * Out parameters are typically also returned as return values, so that +// the output of one function may be used as a parameter to another. +// +//=========================================================================== + +//-------------------------- +// 2D Vector +//-------------------------- + +// inline + +float D3DXVec2Length + ( const D3DXVECTOR2 *pV ); + +float D3DXVec2LengthSq + ( const D3DXVECTOR2 *pV ); + +float D3DXVec2Dot + ( const D3DXVECTOR2 *pV1, const D3DXVECTOR2 *pV2 ); + +// Z component of ((x1,y1,0) cross (x2,y2,0)) +float D3DXVec2CCW + ( const D3DXVECTOR2 *pV1, const D3DXVECTOR2 *pV2 ); + +D3DXVECTOR2* D3DXVec2Add + ( D3DXVECTOR2 *pOut, const D3DXVECTOR2 *pV1, const D3DXVECTOR2 *pV2 ); + +D3DXVECTOR2* D3DXVec2Subtract + ( D3DXVECTOR2 *pOut, const D3DXVECTOR2 *pV1, const D3DXVECTOR2 *pV2 ); + +// Minimize each component. x = min(x1, x2), y = min(y1, y2) +D3DXVECTOR2* D3DXVec2Minimize + ( D3DXVECTOR2 *pOut, const D3DXVECTOR2 *pV1, const D3DXVECTOR2 *pV2 ); + +// Maximize each component. x = max(x1, x2), y = max(y1, y2) +D3DXVECTOR2* D3DXVec2Maximize + ( D3DXVECTOR2 *pOut, const D3DXVECTOR2 *pV1, const D3DXVECTOR2 *pV2 ); + +D3DXVECTOR2* D3DXVec2Scale + ( D3DXVECTOR2 *pOut, const D3DXVECTOR2 *pV, float s ); + +// Linear interpolation. V1 + s(V2-V1) +D3DXVECTOR2* D3DXVec2Lerp + ( D3DXVECTOR2 *pOut, const D3DXVECTOR2 *pV1, const D3DXVECTOR2 *pV2, + float s ); + +// non-inline +#ifdef __cplusplus +extern "C" { +#endif + +D3DXVECTOR2* WINAPI D3DXVec2Normalize + ( D3DXVECTOR2 *pOut, const D3DXVECTOR2 *pV ); + +// Hermite interpolation between position V1, tangent T1 (when s == 0) +// and position V2, tangent T2 (when s == 1). +D3DXVECTOR2* WINAPI D3DXVec2Hermite + ( D3DXVECTOR2 *pOut, const D3DXVECTOR2 *pV1, const D3DXVECTOR2 *pT1, + const D3DXVECTOR2 *pV2, const D3DXVECTOR2 *pT2, float s ); + +// Barycentric coordinates. V1 + f(V2-V1) + g(V3-V1) +D3DXVECTOR2* WINAPI D3DXVec2BaryCentric + ( D3DXVECTOR2 *pOut, const D3DXVECTOR2 *pV1, const D3DXVECTOR2 *pV2, + D3DXVECTOR2 *pV3, float f, float g); + +// Transform (x, y, 0, 1) by matrix. +D3DXVECTOR4* WINAPI D3DXVec2Transform + ( D3DXVECTOR4 *pOut, const D3DXVECTOR2 *pV, const D3DXMATRIX *pM ); + +// Transform (x, y, 0, 1) by matrix, project result back into w=1. +D3DXVECTOR2* WINAPI D3DXVec2TransformCoord + ( D3DXVECTOR2 *pOut, const D3DXVECTOR2 *pV, const D3DXMATRIX *pM ); + +// Transform (x, y, 0, 0) by matrix. +D3DXVECTOR2* WINAPI D3DXVec2TransformNormal + ( D3DXVECTOR2 *pOut, const D3DXVECTOR2 *pV, const D3DXMATRIX *pM ); + +#ifdef __cplusplus +} +#endif + + +//-------------------------- +// 3D Vector +//-------------------------- + +// inline + +float D3DXVec3Length + ( const D3DXVECTOR3 *pV ); + +float D3DXVec3LengthSq + ( const D3DXVECTOR3 *pV ); + +float D3DXVec3Dot + ( const D3DXVECTOR3 *pV1, const D3DXVECTOR3 *pV2 ); + +D3DXVECTOR3* D3DXVec3Cross + ( D3DXVECTOR3 *pOut, const D3DXVECTOR3 *pV1, const D3DXVECTOR3 *pV2 ); + +D3DXVECTOR3* D3DXVec3Add + ( D3DXVECTOR3 *pOut, const D3DXVECTOR3 *pV1, const D3DXVECTOR3 *pV2 ); + +D3DXVECTOR3* D3DXVec3Subtract + ( D3DXVECTOR3 *pOut, const D3DXVECTOR3 *pV1, const D3DXVECTOR3 *pV2 ); + +// Minimize each component. x = min(x1, x2), y = min(y1, y2), ... +D3DXVECTOR3* D3DXVec3Minimize + ( D3DXVECTOR3 *pOut, const D3DXVECTOR3 *pV1, const D3DXVECTOR3 *pV2 ); + +// Maximize each component. x = max(x1, x2), y = max(y1, y2), ... +D3DXVECTOR3* D3DXVec3Maximize + ( D3DXVECTOR3 *pOut, const D3DXVECTOR3 *pV1, const D3DXVECTOR3 *pV2 ); + +D3DXVECTOR3* D3DXVec3Scale + ( D3DXVECTOR3 *pOut, const D3DXVECTOR3 *pV, float s); + +// Linear interpolation. V1 + s(V2-V1) +D3DXVECTOR3* D3DXVec3Lerp + ( D3DXVECTOR3 *pOut, const D3DXVECTOR3 *pV1, const D3DXVECTOR3 *pV2, + float s ); + +// non-inline +#ifdef __cplusplus +extern "C" { +#endif + +D3DXVECTOR3* WINAPI D3DXVec3Normalize + ( D3DXVECTOR3 *pOut, const D3DXVECTOR3 *pV ); + +// Hermite interpolation between position V1, tangent T1 (when s == 0) +// and position V2, tangent T2 (when s == 1). +D3DXVECTOR3* WINAPI D3DXVec3Hermite + ( D3DXVECTOR3 *pOut, const D3DXVECTOR3 *pV1, const D3DXVECTOR3 *pT1, + const D3DXVECTOR3 *pV2, const D3DXVECTOR3 *pT2, float s ); + +// Barycentric coordinates. V1 + f(V2-V1) + g(V3-V1) +D3DXVECTOR3* WINAPI D3DXVec3BaryCentric + ( D3DXVECTOR3 *pOut, const D3DXVECTOR3 *pV1, const D3DXVECTOR3 *pV2, + const D3DXVECTOR3 *pV3, float f, float g); + +// Transform (x, y, z, 1) by matrix. +D3DXVECTOR4* WINAPI D3DXVec3Transform + ( D3DXVECTOR4 *pOut, const D3DXVECTOR3 *pV, const D3DXMATRIX *pM ); + +// Transform (x, y, z, 1) by matrix, project result back into w=1. +D3DXVECTOR3* WINAPI D3DXVec3TransformCoord + ( D3DXVECTOR3 *pOut, const D3DXVECTOR3 *pV, const D3DXMATRIX *pM ); + +// Transform (x, y, z, 0) by matrix. +D3DXVECTOR3* WINAPI D3DXVec3TransformNormal + ( D3DXVECTOR3 *pOut, const D3DXVECTOR3 *pV, const D3DXMATRIX *pM ); + +#ifdef __cplusplus +} +#endif + + + +//-------------------------- +// 4D Vector +//-------------------------- + +// inline + +float D3DXVec4Length + ( const D3DXVECTOR4 *pV ); + +float D3DXVec4LengthSq + ( const D3DXVECTOR4 *pV ); + +float D3DXVec4Dot + ( const D3DXVECTOR4 *pV1, const D3DXVECTOR4 *pV2 ); + +D3DXVECTOR4* D3DXVec4Add + ( D3DXVECTOR4 *pOut, const D3DXVECTOR4 *pV1, const D3DXVECTOR4 *pV2); + +D3DXVECTOR4* D3DXVec4Subtract + ( D3DXVECTOR4 *pOut, const D3DXVECTOR4 *pV1, const D3DXVECTOR4 *pV2); + +// Minimize each component. x = min(x1, x2), y = min(y1, y2), ... +D3DXVECTOR4* D3DXVec4Minimize + ( D3DXVECTOR4 *pOut, const D3DXVECTOR4 *pV1, const D3DXVECTOR4 *pV2); + +// Maximize each component. x = max(x1, x2), y = max(y1, y2), ... +D3DXVECTOR4* D3DXVec4Maximize + ( D3DXVECTOR4 *pOut, const D3DXVECTOR4 *pV1, const D3DXVECTOR4 *pV2); + +D3DXVECTOR4* D3DXVec4Scale + ( D3DXVECTOR4 *pOut, const D3DXVECTOR4 *pV, float s); + +// Linear interpolation. V1 + s(V2-V1) +D3DXVECTOR4* D3DXVec4Lerp + ( D3DXVECTOR4 *pOut, const D3DXVECTOR4 *pV1, const D3DXVECTOR4 *pV2, + float s ); + +// non-inline +#ifdef __cplusplus +extern "C" { +#endif + +// Cross-product in 4 dimensions. +D3DXVECTOR4* WINAPI D3DXVec4Cross + ( D3DXVECTOR4 *pOut, const D3DXVECTOR4 *pV1, const D3DXVECTOR4 *pV2, + const D3DXVECTOR4 *pV3); + +D3DXVECTOR4* WINAPI D3DXVec4Normalize + ( D3DXVECTOR4 *pOut, const D3DXVECTOR4 *pV ); + +// Hermite interpolation between position V1, tangent T1 (when s == 0) +// and position V2, tangent T2 (when s == 1). +D3DXVECTOR4* WINAPI D3DXVec4Hermite + ( D3DXVECTOR4 *pOut, const D3DXVECTOR4 *pV1, const D3DXVECTOR4 *pT1, + const D3DXVECTOR4 *pV2, const D3DXVECTOR4 *pT2, float s ); + +// Barycentric coordinates. V1 + f(V2-V1) + g(V3-V1) +D3DXVECTOR4* WINAPI D3DXVec4BaryCentric + ( D3DXVECTOR4 *pOut, const D3DXVECTOR4 *pV1, const D3DXVECTOR4 *pV2, + const D3DXVECTOR4 *pV3, float f, float g); + +// Transform vector by matrix. +D3DXVECTOR4* WINAPI D3DXVec4Transform + ( D3DXVECTOR4 *pOut, const D3DXVECTOR4 *pV, const D3DXMATRIX *pM ); + +#ifdef __cplusplus +} +#endif + + +//-------------------------- +// 4D Matrix +//-------------------------- + +// inline + +D3DXMATRIX* D3DXMatrixIdentity + ( D3DXMATRIX *pOut ); + +BOOL D3DXMatrixIsIdentity + ( const D3DXMATRIX *pM ); + + +// non-inline +#ifdef __cplusplus +extern "C" { +#endif + +float WINAPI D3DXMatrixfDeterminant + ( const D3DXMATRIX *pM ); + +// Matrix multiplication. The result represents the transformation M2 +// followed by the transformation M1. (Out = M1 * M2) +D3DXMATRIX* WINAPI D3DXMatrixMultiply + ( D3DXMATRIX *pOut, const D3DXMATRIX *pM1, const D3DXMATRIX *pM2 ); + +D3DXMATRIX* WINAPI D3DXMatrixTranspose + ( D3DXMATRIX *pOut, const D3DXMATRIX *pM ); + +// Calculate inverse of matrix. Inversion my fail, in which case NULL will +// be returned. The determinant of pM is also returned it pfDeterminant +// is non-NULL. +D3DXMATRIX* WINAPI D3DXMatrixInverse + ( D3DXMATRIX *pOut, float *pfDeterminant, const D3DXMATRIX *pM ); + +// Build a matrix which scales by (sx, sy, sz) +D3DXMATRIX* WINAPI D3DXMatrixScaling + ( D3DXMATRIX *pOut, float sx, float sy, float sz ); + +// Build a matrix which translates by (x, y, z) +D3DXMATRIX* WINAPI D3DXMatrixTranslation + ( D3DXMATRIX *pOut, float x, float y, float z ); + +// Build a matrix which rotates around the X axis +D3DXMATRIX* WINAPI D3DXMatrixRotationX + ( D3DXMATRIX *pOut, float angle ); + +// Build a matrix which rotates around the Y axis +D3DXMATRIX* WINAPI D3DXMatrixRotationY + ( D3DXMATRIX *pOut, float angle ); + +// Build a matrix which rotates around the Z axis +D3DXMATRIX* WINAPI D3DXMatrixRotationZ + ( D3DXMATRIX *pOut, float angle ); + +// Build a matrix which rotates around an arbitrary axis +D3DXMATRIX* WINAPI D3DXMatrixRotationAxis + ( D3DXMATRIX *pOut, const D3DXVECTOR3 *pV, float angle ); + +// Build a matrix from a quaternion +D3DXMATRIX* WINAPI D3DXMatrixRotationQuaternion + ( D3DXMATRIX *pOut, const D3DXQUATERNION *pQ); + +// Yaw around the Y axis, a pitch around the X axis, +// and a roll around the Z axis. +D3DXMATRIX* WINAPI D3DXMatrixRotationYawPitchRoll + ( D3DXMATRIX *pOut, float yaw, float pitch, float roll ); + + +// Build transformation matrix. NULL arguments are treated as identity. +// Mout = Msc-1 * Msr-1 * Ms * Msr * Msc * Mrc-1 * Mr * Mrc * Mt +D3DXMATRIX* WINAPI D3DXMatrixTransformation + ( D3DXMATRIX *pOut, const D3DXVECTOR3 *pScalingCenter, + const D3DXQUATERNION *pScalingRotation, const D3DXVECTOR3 *pScaling, + const D3DXVECTOR3 *pRotationCenter, const D3DXQUATERNION *pRotation, + const D3DXVECTOR3 *pTranslation); + +// Build affine transformation matrix. NULL arguments are treated as identity. +// Mout = Ms * Mrc-1 * Mr * Mrc * Mt +D3DXMATRIX* WINAPI D3DXMatrixAffineTransformation + ( D3DXMATRIX *pOut, float Scaling, const D3DXVECTOR3 *pRotationCenter, + const D3DXQUATERNION *pRotation, const D3DXVECTOR3 *pTranslation); + +// Build a lookat matrix. (right-handed) +D3DXMATRIX* WINAPI D3DXMatrixLookAt + ( D3DXMATRIX *pOut, const D3DXVECTOR3 *pEye, const D3DXVECTOR3 *pAt, + const D3DXVECTOR3 *pUp ); + +// Build a lookat matrix. (left-handed) +D3DXMATRIX* WINAPI D3DXMatrixLookAtLH + ( D3DXMATRIX *pOut, const D3DXVECTOR3 *pEye, const D3DXVECTOR3 *pAt, + const D3DXVECTOR3 *pUp ); + +// Build a perspective projection matrix. (right-handed) +D3DXMATRIX* WINAPI D3DXMatrixPerspective + ( D3DXMATRIX *pOut, float w, float h, float zn, float zf ); + +// Build a perspective projection matrix. (left-handed) +D3DXMATRIX* WINAPI D3DXMatrixPerspectiveLH + ( D3DXMATRIX *pOut, float w, float h, float zn, float zf ); + +// Build a perspective projection matrix. (right-handed) +D3DXMATRIX* WINAPI D3DXMatrixPerspectiveFov + ( D3DXMATRIX *pOut, float fovy, float aspect, float zn, float zf ); + +// Build a perspective projection matrix. (left-handed) +D3DXMATRIX* WINAPI D3DXMatrixPerspectiveFovLH + ( D3DXMATRIX *pOut, float fovy, float aspect, float zn, float zf ); + +// Build a perspective projection matrix. (right-handed) +D3DXMATRIX* WINAPI D3DXMatrixPerspectiveOffCenter + ( D3DXMATRIX *pOut, float l, float r, float b, float t, float zn, + float zf ); + +// Build a perspective projection matrix. (left-handed) +D3DXMATRIX* WINAPI D3DXMatrixPerspectiveOffCenterLH + ( D3DXMATRIX *pOut, float l, float r, float b, float t, float zn, + float zf ); + +// Build an ortho projection matrix. (right-handed) +D3DXMATRIX* WINAPI D3DXMatrixOrtho + ( D3DXMATRIX *pOut, float w, float h, float zn, float zf ); + +// Build an ortho projection matrix. (left-handed) +D3DXMATRIX* WINAPI D3DXMatrixOrthoLH + ( D3DXMATRIX *pOut, float w, float h, float zn, float zf ); + +// Build an ortho projection matrix. (right-handed) +D3DXMATRIX* WINAPI D3DXMatrixOrthoOffCenter + ( D3DXMATRIX *pOut, float l, float r, float b, float t, float zn, + float zf ); + +// Build an ortho projection matrix. (left-handed) +D3DXMATRIX* WINAPI D3DXMatrixOrthoOffCenterLH + ( D3DXMATRIX *pOut, float l, float r, float b, float t, float zn, + float zf ); + +// Build a matrix which flattens geometry into a plane, as if casting +// a shadow from a light. +D3DXMATRIX* WINAPI D3DXMatrixShadow + ( D3DXMATRIX *pOut, const D3DXVECTOR4 *pLight, + const D3DXPLANE *pPlane ); + +// Build a matrix which reflects the coordinate system about a plane +D3DXMATRIX* WINAPI D3DXMatrixReflect + ( D3DXMATRIX *pOut, const D3DXPLANE *pPlane ); + +#ifdef __cplusplus +} +#endif + + +//-------------------------- +// Quaternion +//-------------------------- + +// inline + +float D3DXQuaternionLength + ( const D3DXQUATERNION *pQ ); + +// Length squared, or "norm" +float D3DXQuaternionLengthSq + ( const D3DXQUATERNION *pQ ); + +float D3DXQuaternionDot + ( const D3DXQUATERNION *pQ1, const D3DXQUATERNION *pQ2 ); + +// (0, 0, 0, 1) +D3DXQUATERNION* D3DXQuaternionIdentity + ( D3DXQUATERNION *pOut ); + +BOOL D3DXQuaternionIsIdentity + ( const D3DXQUATERNION *pQ ); + +// (-x, -y, -z, w) +D3DXQUATERNION* D3DXQuaternionConjugate + ( D3DXQUATERNION *pOut, const D3DXQUATERNION *pQ ); + + +// non-inline +#ifdef __cplusplus +extern "C" { +#endif + +// Compute a quaternin's axis and angle of rotation. Expects unit quaternions. +void WINAPI D3DXQuaternionToAxisAngle + ( const D3DXQUATERNION *pQ, D3DXVECTOR3 *pAxis, float *pAngle ); + +// Build a quaternion from a rotation matrix. +D3DXQUATERNION* WINAPI D3DXQuaternionRotationMatrix + ( D3DXQUATERNION *pOut, const D3DXMATRIX *pM); + +// Rotation about arbitrary axis. +D3DXQUATERNION* WINAPI D3DXQuaternionRotationAxis + ( D3DXQUATERNION *pOut, const D3DXVECTOR3 *pV, float angle ); + +// Yaw around the Y axis, a pitch around the X axis, +// and a roll around the Z axis. +D3DXQUATERNION* WINAPI D3DXQuaternionRotationYawPitchRoll + ( D3DXQUATERNION *pOut, float yaw, float pitch, float roll ); + +// Quaternion multiplication. The result represents the rotation Q2 +// followed by the rotation Q1. (Out = Q2 * Q1) +D3DXQUATERNION* WINAPI D3DXQuaternionMultiply + ( D3DXQUATERNION *pOut, const D3DXQUATERNION *pQ1, + const D3DXQUATERNION *pQ2 ); + +D3DXQUATERNION* WINAPI D3DXQuaternionNormalize + ( D3DXQUATERNION *pOut, const D3DXQUATERNION *pQ ); + +// Conjugate and re-norm +D3DXQUATERNION* WINAPI D3DXQuaternionInverse + ( D3DXQUATERNION *pOut, const D3DXQUATERNION *pQ ); + +// Expects unit quaternions. +// if q = (cos(theta), sin(theta) * v); ln(q) = (0, theta * v) +D3DXQUATERNION* WINAPI D3DXQuaternionLn + ( D3DXQUATERNION *pOut, const D3DXQUATERNION *pQ ); + +// Expects pure quaternions. (w == 0) w is ignored in calculation. +// if q = (0, theta * v); exp(q) = (cos(theta), sin(theta) * v) +D3DXQUATERNION* WINAPI D3DXQuaternionExp + ( D3DXQUATERNION *pOut, const D3DXQUATERNION *pQ ); + +// Spherical linear interpolation between Q1 (s == 0) and Q2 (s == 1). +// Expects unit quaternions. +D3DXQUATERNION* WINAPI D3DXQuaternionSlerp + ( D3DXQUATERNION *pOut, const D3DXQUATERNION *pQ1, + const D3DXQUATERNION *pQ2, float t ); + +// Spherical quadrangle interpolation. +// Slerp(Slerp(Q1, Q4, t), Slerp(Q2, Q3, t), 2t(1-t)) +D3DXQUATERNION* WINAPI D3DXQuaternionSquad + ( D3DXQUATERNION *pOut, const D3DXQUATERNION *pQ1, + const D3DXQUATERNION *pQ2, const D3DXQUATERNION *pQ3, + const D3DXQUATERNION *pQ4, float t ); + +// Slerp(Slerp(Q1, Q2, f+g), Slerp(Q1, Q3, f+g), g/(f+g)) +D3DXQUATERNION* WINAPI D3DXQuaternionBaryCentric + ( D3DXQUATERNION *pOut, const D3DXQUATERNION *pQ1, + const D3DXQUATERNION *pQ2, const D3DXQUATERNION *pQ3, + float f, float g ); + +#ifdef __cplusplus +} +#endif + + +//-------------------------- +// Plane +//-------------------------- + +// inline + +// ax + by + cz + dw +float D3DXPlaneDot + ( const D3DXPLANE *pP, const D3DXVECTOR4 *pV); + +// ax + by + cz + d +float D3DXPlaneDotCoord + ( const D3DXPLANE *pP, const D3DXVECTOR3 *pV); + +// ax + by + cz +float D3DXPlaneDotNormal + ( const D3DXPLANE *pP, const D3DXVECTOR3 *pV); + +// non-inline +#ifdef __cplusplus +extern "C" { +#endif + +// Normalize plane (so that |a,b,c| == 1) +D3DXPLANE* WINAPI D3DXPlaneNormalize + ( D3DXPLANE *pOut, const D3DXPLANE *pP); + +// Find the intersection between a plane and a line. If the line is +// parallel to the plane, NULL is returned. +D3DXVECTOR3* WINAPI D3DXPlaneIntersectLine + ( D3DXVECTOR3 *pOut, const D3DXPLANE *pP, const D3DXVECTOR3 *pV1, + const D3DXVECTOR3 *pV2); + +// Construct a plane from a point and a normal +D3DXPLANE* WINAPI D3DXPlaneFromPointNormal + ( D3DXPLANE *pOut, const D3DXVECTOR3 *pPoint, const D3DXVECTOR3 *pNormal); + +// Construct a plane from 3 points +D3DXPLANE* WINAPI D3DXPlaneFromPoints + ( D3DXPLANE *pOut, const D3DXVECTOR3 *pV1, const D3DXVECTOR3 *pV2, + const D3DXVECTOR3 *pV3); + +// Transform a plane by a matrix. The vector (a,b,c) must be normal. +// M must be an affine transform. +D3DXPLANE* WINAPI D3DXPlaneTransform + ( D3DXPLANE *pOut, const D3DXPLANE *pP, const D3DXMATRIX *pM ); + +#ifdef __cplusplus +} +#endif + + +//-------------------------- +// Color +//-------------------------- + +// inline + +// (1-r, 1-g, 1-b, a) +D3DXCOLOR* D3DXColorNegative + (D3DXCOLOR *pOut, const D3DXCOLOR *pC); + +D3DXCOLOR* D3DXColorAdd + (D3DXCOLOR *pOut, const D3DXCOLOR *pC1, const D3DXCOLOR *pC2); + +D3DXCOLOR* D3DXColorSubtract + (D3DXCOLOR *pOut, const D3DXCOLOR *pC1, const D3DXCOLOR *pC2); + +D3DXCOLOR* D3DXColorScale + (D3DXCOLOR *pOut, const D3DXCOLOR *pC, float s); + +// (r1*r2, g1*g2, b1*b2, a1*a2) +D3DXCOLOR* D3DXColorModulate + (D3DXCOLOR *pOut, const D3DXCOLOR *pC1, const D3DXCOLOR *pC2); + +// Linear interpolation of r,g,b, and a. C1 + s(C2-C1) +D3DXCOLOR* D3DXColorLerp + (D3DXCOLOR *pOut, const D3DXCOLOR *pC1, const D3DXCOLOR *pC2, float s); + +// non-inline +#ifdef __cplusplus +extern "C" { +#endif + +// Interpolate r,g,b between desaturated color and color. +// DesaturatedColor + s(Color - DesaturatedColor) +D3DXCOLOR* WINAPI D3DXColorAdjustSaturation + (D3DXCOLOR *pOut, const D3DXCOLOR *pC, float s); + +// Interpolate r,g,b between 50% grey and color. Grey + s(Color - Grey) +D3DXCOLOR* WINAPI D3DXColorAdjustContrast + (D3DXCOLOR *pOut, const D3DXCOLOR *pC, float c); + +#ifdef __cplusplus +} +#endif + + + + + + +//=========================================================================== +// +// Matrix Stack +// +//=========================================================================== + +DECLARE_INTERFACE_(ID3DXMatrixStack, IUnknown) +{ + // + // IUnknown methods + // + STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + + // + // ID3DXMatrixStack methods + // + + // Pops the top of the stack, returns the current top + // *after* popping the top. + STDMETHOD(Pop)(THIS) PURE; + + // Pushes the stack by one, duplicating the current matrix. + STDMETHOD(Push)(THIS) PURE; + + // Loads identity in the current matrix. + STDMETHOD(LoadIdentity)(THIS) PURE; + + // Loads the given matrix into the current matrix + STDMETHOD(LoadMatrix)(THIS_ const D3DXMATRIX* pM ) PURE; + + // Right-Multiplies the given matrix to the current matrix. + // (transformation is about the current world origin) + STDMETHOD(MultMatrix)(THIS_ const D3DXMATRIX* pM ) PURE; + + // Left-Multiplies the given matrix to the current matrix + // (transformation is about the local origin of the object) + STDMETHOD(MultMatrixLocal)(THIS_ const D3DXMATRIX* pM ) PURE; + + // Right multiply the current matrix with the computed rotation + // matrix, counterclockwise about the given axis with the given angle. + // (rotation is about the current world origin) + STDMETHOD(RotateAxis) + (THIS_ const D3DXVECTOR3* pV, float angle) PURE; + + // Left multiply the current matrix with the computed rotation + // matrix, counterclockwise about the given axis with the given angle. + // (rotation is about the local origin of the object) + STDMETHOD(RotateAxisLocal) + (THIS_ const D3DXVECTOR3* pV, float angle) PURE; + + // Right multiply the current matrix with the computed rotation + // matrix. All angles are counterclockwise. (rotation is about the + // current world origin) + + // The rotation is composed of a yaw around the Y axis, a pitch around + // the X axis, and a roll around the Z axis. + STDMETHOD(RotateYawPitchRoll) + (THIS_ float yaw, float pitch, float roll) PURE; + + // Left multiply the current matrix with the computed rotation + // matrix. All angles are counterclockwise. (rotation is about the + // local origin of the object) + + // The rotation is composed of a yaw around the Y axis, a pitch around + // the X axis, and a roll around the Z axis. + STDMETHOD(RotateYawPitchRollLocal) + (THIS_ float yaw, float pitch, float roll) PURE; + + // Right multiply the current matrix with the computed scale + // matrix. (transformation is about the current world origin) + STDMETHOD(Scale)(THIS_ float x, float y, float z) PURE; + + // Left multiply the current matrix with the computed scale + // matrix. (transformation is about the local origin of the object) + STDMETHOD(ScaleLocal)(THIS_ float x, float y, float z) PURE; + + // Right multiply the current matrix with the computed translation + // matrix. (transformation is about the current world origin) + STDMETHOD(Translate)(THIS_ float x, float y, float z ) PURE; + + // Left multiply the current matrix with the computed translation + // matrix. (transformation is about the local origin of the object) + STDMETHOD(TranslateLocal)(THIS_ float x, float y, float z) PURE; + + // Obtain the current matrix at the top of the stack + STDMETHOD_(D3DXMATRIX*, GetTop)(THIS) PURE; +}; + +#ifdef __cplusplus +extern "C" { +#endif + +HRESULT WINAPI D3DXCreateMatrixStack( DWORD flags, LPD3DXMATRIXSTACK *ppStack ); + +#ifdef __cplusplus +} +#endif + +#include "d3dxmath.inl" + +#pragma warning(default:4201) + +#endif // __D3DXMATH_H__ diff --git a/engine/libs/dxsdk7/include/d3dxmath.inl b/engine/libs/dxsdk7/include/d3dxmath.inl new file mode 100644 index 000000000..b0155e509 --- /dev/null +++ b/engine/libs/dxsdk7/include/d3dxmath.inl @@ -0,0 +1,1809 @@ +////////////////////////////////////////////////////////////////////////////// +// +// Copyright (C) 1998 Microsoft Corporation. All Rights Reserved. +// +// File: d3dxmath.inl +// Content: D3DX math inline functions +// +////////////////////////////////////////////////////////////////////////////// + +#ifndef __D3DXMATH_INL__ +#define __D3DXMATH_INL__ + + +//=========================================================================== +// +// Inline Class Methods +// +//=========================================================================== + +#ifdef __cplusplus + +//-------------------------- +// 2D Vector +//-------------------------- + +D3DXINLINE +D3DXVECTOR2::D3DXVECTOR2( const float *pf ) +{ +#ifdef D3DX_DEBUG + if(!pf) + return; +#endif + + x = pf[0]; + y = pf[1]; +} + +D3DXINLINE +D3DXVECTOR2::D3DXVECTOR2( float fx, float fy ) +{ + x = fx; + y = fy; +} + +// casting +D3DXINLINE +D3DXVECTOR2::operator float* () +{ + return (float *) &x; +} + +D3DXINLINE +D3DXVECTOR2::operator const float* () const +{ + return (const float *) &x; +} + +// assignment operators +D3DXINLINE D3DXVECTOR2& +D3DXVECTOR2::operator += ( const D3DXVECTOR2& v ) +{ + x += v.x; + y += v.y; + return *this; +} + +D3DXINLINE D3DXVECTOR2& +D3DXVECTOR2::operator -= ( const D3DXVECTOR2& v ) +{ + x -= v.x; + y -= v.y; + return *this; +} + +D3DXINLINE D3DXVECTOR2& +D3DXVECTOR2::operator *= ( float f ) +{ + x *= f; + y *= f; + return *this; +} + +D3DXINLINE D3DXVECTOR2& +D3DXVECTOR2::operator /= ( float f ) +{ + float fInv = 1.0f / f; + x *= fInv; + y *= fInv; + return *this; +} + +// unary operators +D3DXINLINE D3DXVECTOR2 +D3DXVECTOR2::operator + () const +{ + return *this; +} + +D3DXINLINE D3DXVECTOR2 +D3DXVECTOR2::operator - () const +{ + return D3DXVECTOR2(-x, -y); +} + +// binary operators +D3DXINLINE D3DXVECTOR2 +D3DXVECTOR2::operator + ( const D3DXVECTOR2& v ) const +{ + return D3DXVECTOR2(x + v.x, y + v.y); +} + +D3DXINLINE D3DXVECTOR2 +D3DXVECTOR2::operator - ( const D3DXVECTOR2& v ) const +{ + return D3DXVECTOR2(x - v.x, y - v.y); +} + +D3DXINLINE D3DXVECTOR2 +D3DXVECTOR2::operator * ( float f ) const +{ + return D3DXVECTOR2(x * f, y * f); +} + +D3DXINLINE D3DXVECTOR2 +D3DXVECTOR2::operator / ( float f ) const +{ + float fInv = 1.0f / f; + return D3DXVECTOR2(x * fInv, y * fInv); +} + + +D3DXINLINE D3DXVECTOR2 +operator * ( float f, const D3DXVECTOR2& v ) +{ + return D3DXVECTOR2(f * v.x, f * v.y); +} + +D3DXINLINE BOOL +D3DXVECTOR2::operator == ( const D3DXVECTOR2& v ) const +{ + return x == v.x && y == v.y; +} + +D3DXINLINE BOOL +D3DXVECTOR2::operator != ( const D3DXVECTOR2& v ) const +{ + return x != v.x || y != v.y; +} + + + + +//-------------------------- +// 3D Vector +//-------------------------- +D3DXINLINE +D3DXVECTOR3::D3DXVECTOR3( const float *pf ) +{ +#ifdef D3DX_DEBUG + if(!pf) + return; +#endif + + x = pf[0]; + y = pf[1]; + z = pf[2]; +} + +D3DXINLINE +D3DXVECTOR3::D3DXVECTOR3( const D3DVECTOR& v ) +{ + x = v.x; + y = v.y; + z = v.z; +} + +D3DXINLINE +D3DXVECTOR3::D3DXVECTOR3( float fx, float fy, float fz ) +{ + x = fx; + y = fy; + z = fz; +} + + +// casting +D3DXINLINE +D3DXVECTOR3::operator float* () +{ + return (float *) &x; +} + +D3DXINLINE +D3DXVECTOR3::operator const float* () const +{ + return (const float *) &x; +} + + +D3DXINLINE +D3DXVECTOR3::operator D3DVECTOR* () +{ + return (D3DVECTOR *) &x; +} + +D3DXINLINE +D3DXVECTOR3::operator const D3DVECTOR* () const +{ + return (const D3DVECTOR *) &x; +} + + +D3DXINLINE +D3DXVECTOR3::operator D3DVECTOR& () +{ + return *((D3DVECTOR *) &x); +} + +D3DXINLINE +D3DXVECTOR3::operator const D3DVECTOR& () const +{ + return *((const D3DVECTOR *) &x); +} + + +// assignment operators +D3DXINLINE D3DXVECTOR3& +D3DXVECTOR3::operator += ( const D3DXVECTOR3& v ) +{ + x += v.x; + y += v.y; + z += v.z; + return *this; +} + +D3DXINLINE D3DXVECTOR3& +D3DXVECTOR3::operator -= ( const D3DXVECTOR3& v ) +{ + x -= v.x; + y -= v.y; + z -= v.z; + return *this; +} + +D3DXINLINE D3DXVECTOR3& +D3DXVECTOR3::operator *= ( float f ) +{ + x *= f; + y *= f; + z *= f; + return *this; +} + +D3DXINLINE D3DXVECTOR3& +D3DXVECTOR3::operator /= ( float f ) +{ + float fInv = 1.0f / f; + x *= fInv; + y *= fInv; + z *= fInv; + return *this; +} + + +// unary operators +D3DXINLINE D3DXVECTOR3 +D3DXVECTOR3::operator + () const +{ + return *this; +} + +D3DXINLINE D3DXVECTOR3 +D3DXVECTOR3::operator - () const +{ + return D3DXVECTOR3(-x, -y, -z); +} + + +// binary operators +D3DXINLINE D3DXVECTOR3 +D3DXVECTOR3::operator + ( const D3DXVECTOR3& v ) const +{ + return D3DXVECTOR3(x + v.x, y + v.y, z + v.z); +} + +D3DXINLINE D3DXVECTOR3 +D3DXVECTOR3::operator - ( const D3DXVECTOR3& v ) const +{ + return D3DXVECTOR3(x - v.x, y - v.y, z - v.z); +} + +D3DXINLINE D3DXVECTOR3 +D3DXVECTOR3::operator * ( float f ) const +{ + return D3DXVECTOR3(x * f, y * f, z * f); +} + +D3DXINLINE D3DXVECTOR3 +D3DXVECTOR3::operator / ( float f ) const +{ + float fInv = 1.0f / f; + return D3DXVECTOR3(x * fInv, y * fInv, z * fInv); +} + + +D3DXINLINE D3DXVECTOR3 +operator * ( float f, const struct D3DXVECTOR3& v ) +{ + return D3DXVECTOR3(f * v.x, f * v.y, f * v.z); +} + + +D3DXINLINE BOOL +D3DXVECTOR3::operator == ( const D3DXVECTOR3& v ) const +{ + return x == v.x && y == v.y && z == v.z; +} + +D3DXINLINE BOOL +D3DXVECTOR3::operator != ( const D3DXVECTOR3& v ) const +{ + return x != v.x || y != v.y || z != v.z; +} + + + +//-------------------------- +// 4D Vector +//-------------------------- +D3DXINLINE +D3DXVECTOR4::D3DXVECTOR4( const float *pf ) +{ +#ifdef D3DX_DEBUG + if(!pf) + return; +#endif + + x = pf[0]; + y = pf[1]; + z = pf[2]; + w = pf[3]; +} + +D3DXINLINE +D3DXVECTOR4::D3DXVECTOR4( float fx, float fy, float fz, float fw ) +{ + x = fx; + y = fy; + z = fz; + w = fw; +} + + +// casting +D3DXINLINE +D3DXVECTOR4::operator float* () +{ + return (float *) &x; +} + +D3DXINLINE +D3DXVECTOR4::operator const float* () const +{ + return (const float *) &x; +} + + +// assignment operators +D3DXINLINE D3DXVECTOR4& +D3DXVECTOR4::operator += ( const D3DXVECTOR4& v ) +{ + x += v.x; + y += v.y; + z += v.z; + w += v.w; + return *this; +} + +D3DXINLINE D3DXVECTOR4& +D3DXVECTOR4::operator -= ( const D3DXVECTOR4& v ) +{ + x -= v.x; + y -= v.y; + z -= v.z; + w -= v.w; + return *this; +} + +D3DXINLINE D3DXVECTOR4& +D3DXVECTOR4::operator *= ( float f ) +{ + x *= f; + y *= f; + z *= f; + w *= f; + return *this; +} + +D3DXINLINE D3DXVECTOR4& +D3DXVECTOR4::operator /= ( float f ) +{ + float fInv = 1.0f / f; + x *= fInv; + y *= fInv; + z *= fInv; + w *= fInv; + return *this; +} + + +// unary operators +D3DXINLINE D3DXVECTOR4 +D3DXVECTOR4::operator + () const +{ + return *this; +} + +D3DXINLINE D3DXVECTOR4 +D3DXVECTOR4::operator - () const +{ + return D3DXVECTOR4(-x, -y, -z, -w); +} + + +// binary operators +D3DXINLINE D3DXVECTOR4 +D3DXVECTOR4::operator + ( const D3DXVECTOR4& v ) const +{ + return D3DXVECTOR4(x + v.x, y + v.y, z + v.z, w + v.w); +} + +D3DXINLINE D3DXVECTOR4 +D3DXVECTOR4::operator - ( const D3DXVECTOR4& v ) const +{ + return D3DXVECTOR4(x - v.x, y - v.y, z - v.z, w - v.w); +} + +D3DXINLINE D3DXVECTOR4 +D3DXVECTOR4::operator * ( float f ) const +{ + return D3DXVECTOR4(x * f, y * f, z * f, w * f); +} + +D3DXINLINE D3DXVECTOR4 +D3DXVECTOR4::operator / ( float f ) const +{ + float fInv = 1.0f / f; + return D3DXVECTOR4(x * fInv, y * fInv, z * fInv, w * fInv); +} + + +D3DXINLINE D3DXVECTOR4 +operator * ( float f, const D3DXVECTOR4& v ) +{ + return D3DXVECTOR4(f * v.x, f * v.y, f * v.z, f * v.w); +} + + +D3DXINLINE BOOL +D3DXVECTOR4::operator == ( const D3DXVECTOR4& v ) const +{ + return x == v.x && y == v.y && z == v.z && w == v.w; +} + +D3DXINLINE BOOL +D3DXVECTOR4::operator != ( const D3DXVECTOR4& v ) const +{ + return x != v.x || y != v.y || z != v.z || w != v.w; +} + + +//-------------------------- +// Matrix +//-------------------------- +D3DXINLINE +D3DXMATRIX::D3DXMATRIX( const float* pf ) +{ +#ifdef D3DX_DEBUG + if(!pf) + return; +#endif + + memcpy(&m00, pf, sizeof(D3DXMATRIX)); +} + +D3DXINLINE +D3DXMATRIX::D3DXMATRIX( const D3DMATRIX& mat ) +{ + memcpy(&m00, &mat, sizeof(D3DXMATRIX)); +} + +D3DXINLINE +D3DXMATRIX::D3DXMATRIX( float f00, float f01, float f02, float f03, + float f10, float f11, float f12, float f13, + float f20, float f21, float f22, float f23, + float f30, float f31, float f32, float f33 ) +{ + m00 = f00; m01 = f01; m02 = f02; m03 = f03; + m10 = f10; m11 = f11; m12 = f12; m13 = f13; + m20 = f20; m21 = f21; m22 = f22; m23 = f23; + m30 = f30; m31 = f31; m32 = f32; m33 = f33; +} + + + +// access grants +D3DXINLINE float& +D3DXMATRIX::operator () ( UINT iRow, UINT iCol ) +{ + return m[iRow][iCol]; +} + +D3DXINLINE float +D3DXMATRIX::operator () ( UINT iRow, UINT iCol ) const +{ + return m[iRow][iCol]; +} + + +// casting operators +D3DXINLINE +D3DXMATRIX::operator float* () +{ + return (float *) &m00; +} + +D3DXINLINE +D3DXMATRIX::operator const float* () const +{ + return (const float *) &m00; +} + + +D3DXINLINE +D3DXMATRIX::operator D3DMATRIX* () +{ + return (D3DMATRIX *) &m00; +} + +D3DXINLINE +D3DXMATRIX::operator const D3DMATRIX* () const +{ + return (const D3DMATRIX *) &m00; +} + + +D3DXINLINE +D3DXMATRIX::operator D3DMATRIX& () +{ + return *((D3DMATRIX *) &m00); +} + +D3DXINLINE +D3DXMATRIX::operator const D3DMATRIX& () const +{ + return *((const D3DMATRIX *) &m00); +} + + +// assignment operators +D3DXINLINE D3DXMATRIX& +D3DXMATRIX::operator *= ( const D3DXMATRIX& mat ) +{ + D3DXMatrixMultiply(this, this, &mat); + return *this; +} + +D3DXINLINE D3DXMATRIX& +D3DXMATRIX::operator += ( const D3DXMATRIX& mat ) +{ + m00 += mat.m00; m01 += mat.m01; m02 += mat.m02; m03 += mat.m03; + m10 += mat.m10; m11 += mat.m11; m12 += mat.m12; m13 += mat.m13; + m20 += mat.m20; m21 += mat.m21; m22 += mat.m22; m23 += mat.m23; + m30 += mat.m30; m31 += mat.m31; m32 += mat.m32; m33 += mat.m33; + return *this; +} + +D3DXINLINE D3DXMATRIX& +D3DXMATRIX::operator -= ( const D3DXMATRIX& mat ) +{ + m00 -= mat.m00; m01 -= mat.m01; m02 -= mat.m02; m03 -= mat.m03; + m10 -= mat.m10; m11 -= mat.m11; m12 -= mat.m12; m13 -= mat.m13; + m20 -= mat.m20; m21 -= mat.m21; m22 -= mat.m22; m23 -= mat.m23; + m30 -= mat.m30; m31 -= mat.m31; m32 -= mat.m32; m33 -= mat.m33; + return *this; +} + +D3DXINLINE D3DXMATRIX& +D3DXMATRIX::operator *= ( float f ) +{ + m00 *= f; m01 *= f; m02 *= f; m03 *= f; + m10 *= f; m11 *= f; m12 *= f; m13 *= f; + m20 *= f; m21 *= f; m22 *= f; m23 *= f; + m30 *= f; m31 *= f; m32 *= f; m33 *= f; + return *this; +} + +D3DXINLINE D3DXMATRIX& +D3DXMATRIX::operator /= ( float f ) +{ + float fInv = 1.0f / f; + m00 *= fInv; m01 *= fInv; m02 *= fInv; m03 *= fInv; + m10 *= fInv; m11 *= fInv; m12 *= fInv; m13 *= fInv; + m20 *= fInv; m21 *= fInv; m22 *= fInv; m23 *= fInv; + m30 *= fInv; m31 *= fInv; m32 *= fInv; m33 *= fInv; + return *this; +} + + +// unary operators +D3DXINLINE D3DXMATRIX +D3DXMATRIX::operator + () const +{ + return *this; +} + +D3DXINLINE D3DXMATRIX +D3DXMATRIX::operator - () const +{ + return D3DXMATRIX(-m00, -m01, -m02, -m03, + -m10, -m11, -m12, -m13, + -m20, -m21, -m22, -m23, + -m30, -m31, -m32, -m33); +} + + +// binary operators +D3DXINLINE D3DXMATRIX +D3DXMATRIX::operator * ( const D3DXMATRIX& mat ) const +{ + D3DXMATRIX matT; + D3DXMatrixMultiply(&matT, this, &mat); + return matT; +} + +D3DXINLINE D3DXMATRIX +D3DXMATRIX::operator + ( const D3DXMATRIX& mat ) const +{ + return D3DXMATRIX(m00 + mat.m00, m01 + mat.m01, m02 + mat.m02, m03 + mat.m03, + m10 + mat.m10, m11 + mat.m11, m12 + mat.m12, m13 + mat.m13, + m20 + mat.m20, m21 + mat.m21, m22 + mat.m22, m23 + mat.m23, + m30 + mat.m30, m31 + mat.m31, m32 + mat.m32, m33 + mat.m33); +} + +D3DXINLINE D3DXMATRIX +D3DXMATRIX::operator - ( const D3DXMATRIX& mat ) const +{ + return D3DXMATRIX(m00 - mat.m00, m01 - mat.m01, m02 - mat.m02, m03 - mat.m03, + m10 - mat.m10, m11 - mat.m11, m12 - mat.m12, m13 - mat.m13, + m20 - mat.m20, m21 - mat.m21, m22 - mat.m22, m23 - mat.m23, + m30 - mat.m30, m31 - mat.m31, m32 - mat.m32, m33 - mat.m33); +} + +D3DXINLINE D3DXMATRIX +D3DXMATRIX::operator * ( float f ) const +{ + return D3DXMATRIX(m00 * f, m01 * f, m02 * f, m03 * f, + m10 * f, m11 * f, m12 * f, m13 * f, + m20 * f, m21 * f, m22 * f, m23 * f, + m30 * f, m31 * f, m32 * f, m33 * f); +} + +D3DXINLINE D3DXMATRIX +D3DXMATRIX::operator / ( float f ) const +{ + float fInv = 1.0f / f; + return D3DXMATRIX(m00 * fInv, m01 * fInv, m02 * fInv, m03 * fInv, + m10 * fInv, m11 * fInv, m12 * fInv, m13 * fInv, + m20 * fInv, m21 * fInv, m22 * fInv, m23 * fInv, + m30 * fInv, m31 * fInv, m32 * fInv, m33 * fInv); +} + + +D3DXINLINE D3DXMATRIX +operator * ( float f, const D3DXMATRIX& mat ) +{ + return D3DXMATRIX(f * mat.m00, f * mat.m01, f * mat.m02, f * mat.m03, + f * mat.m10, f * mat.m11, f * mat.m12, f * mat.m13, + f * mat.m20, f * mat.m21, f * mat.m22, f * mat.m23, + f * mat.m30, f * mat.m31, f * mat.m32, f * mat.m33); +} + + +D3DXINLINE BOOL +D3DXMATRIX::operator == ( const D3DXMATRIX& mat ) const +{ + return 0 == memcmp(this, &mat, sizeof(D3DXMATRIX)); +} + +D3DXINLINE BOOL +D3DXMATRIX::operator != ( const D3DXMATRIX& mat ) const +{ + return 0 != memcmp(this, &mat, sizeof(D3DXMATRIX)); +} + + + +//-------------------------- +// Quaternion +//-------------------------- + +D3DXINLINE +D3DXQUATERNION::D3DXQUATERNION( const float* pf ) +{ +#ifdef D3DX_DEBUG + if(!pf) + return; +#endif + + x = pf[0]; + y = pf[1]; + z = pf[2]; + w = pf[3]; +} + +D3DXINLINE +D3DXQUATERNION::D3DXQUATERNION( float fx, float fy, float fz, float fw ) +{ + x = fx; + y = fy; + z = fz; + w = fw; +} + + +// casting +D3DXINLINE +D3DXQUATERNION::operator float* () +{ + return (float *) &x; +} + +D3DXINLINE +D3DXQUATERNION::operator const float* () const +{ + return (const float *) &x; +} + + +// assignment operators +D3DXINLINE D3DXQUATERNION& +D3DXQUATERNION::operator += ( const D3DXQUATERNION& q ) +{ + x += q.x; + y += q.y; + z += q.z; + w += q.w; + return *this; +} + +D3DXINLINE D3DXQUATERNION& +D3DXQUATERNION::operator -= ( const D3DXQUATERNION& q ) +{ + x -= q.x; + y -= q.y; + z -= q.z; + w -= q.w; + return *this; +} + +D3DXINLINE D3DXQUATERNION& +D3DXQUATERNION::operator *= ( const D3DXQUATERNION& q ) +{ + D3DXQuaternionMultiply(this, this, &q); + return *this; +} + +D3DXINLINE D3DXQUATERNION& +D3DXQUATERNION::operator *= ( float f ) +{ + x *= f; + y *= f; + z *= f; + w *= f; + return *this; +} + +D3DXINLINE D3DXQUATERNION& +D3DXQUATERNION::operator /= ( float f ) +{ + float fInv = 1.0f / f; + x *= fInv; + y *= fInv; + z *= fInv; + w *= fInv; + return *this; +} + + +// unary operators +D3DXINLINE D3DXQUATERNION +D3DXQUATERNION::operator + () const +{ + return *this; +} + +D3DXINLINE D3DXQUATERNION +D3DXQUATERNION::operator - () const +{ + return D3DXQUATERNION(-x, -y, -z, -w); +} + + +// binary operators +D3DXINLINE D3DXQUATERNION +D3DXQUATERNION::operator + ( const D3DXQUATERNION& q ) const +{ + return D3DXQUATERNION(x + q.x, y + q.y, z + q.z, w + q.w); +} + +D3DXINLINE D3DXQUATERNION +D3DXQUATERNION::operator - ( const D3DXQUATERNION& q ) const +{ + return D3DXQUATERNION(x - q.x, y - q.y, z - q.z, w - q.w); +} + +D3DXINLINE D3DXQUATERNION +D3DXQUATERNION::operator * ( const D3DXQUATERNION& q ) const +{ + D3DXQUATERNION qT; + D3DXQuaternionMultiply(&qT, this, &q); + return qT; +} + +D3DXINLINE D3DXQUATERNION +D3DXQUATERNION::operator * ( float f ) const +{ + return D3DXQUATERNION(x * f, y * f, z * f, w * f); +} + +D3DXINLINE D3DXQUATERNION +D3DXQUATERNION::operator / ( float f ) const +{ + float fInv = 1.0f / f; + return D3DXQUATERNION(x * fInv, y * fInv, z * fInv, w * fInv); +} + + +D3DXINLINE D3DXQUATERNION +operator * (float f, const D3DXQUATERNION& q ) +{ + return D3DXQUATERNION(f * q.x, f * q.y, f * q.z, f * q.w); +} + + +D3DXINLINE BOOL +D3DXQUATERNION::operator == ( const D3DXQUATERNION& q ) const +{ + return x == q.x && y == q.y && z == q.z && w == q.w; +} + +D3DXINLINE BOOL +D3DXQUATERNION::operator != ( const D3DXQUATERNION& q ) const +{ + return x != q.x || y != q.y || z != q.z || w != q.w; +} + + + +//-------------------------- +// Plane +//-------------------------- + +D3DXINLINE +D3DXPLANE::D3DXPLANE( const float* pf ) +{ +#ifdef D3DX_DEBUG + if(!pf) + return; +#endif + + a = pf[0]; + b = pf[1]; + c = pf[2]; + d = pf[3]; +} + +D3DXINLINE +D3DXPLANE::D3DXPLANE( float fa, float fb, float fc, float fd ) +{ + a = fa; + b = fb; + c = fc; + d = fd; +} + + +// casting +D3DXINLINE +D3DXPLANE::operator float* () +{ + return (float *) &a; +} + +D3DXINLINE +D3DXPLANE::operator const float* () const +{ + return (const float *) &a; +} + + +// unary operators +D3DXINLINE D3DXPLANE +D3DXPLANE::operator + () const +{ + return *this; +} + +D3DXINLINE D3DXPLANE +D3DXPLANE::operator - () const +{ + return D3DXPLANE(-a, -b, -c, -d); +} + + +// binary operators +D3DXINLINE BOOL +D3DXPLANE::operator == ( const D3DXPLANE& p ) const +{ + return a == p.a && b == p.b && c == p.c && d == p.d; +} + +D3DXINLINE BOOL +D3DXPLANE::operator != ( const D3DXPLANE& p ) const +{ + return a != p.a || b != p.b || c != p.c || d != p.d; +} + + + + +//-------------------------- +// Color +//-------------------------- + +D3DXINLINE +D3DXCOLOR::D3DXCOLOR( DWORD dw ) +{ + const float f = 1.0f / 255.0f; + r = f * (float) (unsigned char) (dw >> 16); + g = f * (float) (unsigned char) (dw >> 8); + b = f * (float) (unsigned char) (dw >> 0); + a = f * (float) (unsigned char) (dw >> 24); +} + +D3DXINLINE +D3DXCOLOR::D3DXCOLOR( const float* pf ) +{ +#ifdef D3DX_DEBUG + if(!pf) + return; +#endif + + r = pf[0]; + g = pf[1]; + b = pf[2]; + a = pf[3]; +} + +D3DXINLINE +D3DXCOLOR::D3DXCOLOR( const D3DCOLORVALUE& c ) +{ + r = c.r; + g = c.g; + b = c.b; + a = c.a; +} + +D3DXINLINE +D3DXCOLOR::D3DXCOLOR( float fr, float fg, float fb, float fa ) +{ + r = fr; + g = fg; + b = fb; + a = fa; +} + + +// casting +D3DXINLINE +D3DXCOLOR::operator DWORD () const +{ + DWORD dwR = r >= 1.0f ? 0xff : r <= 0.0f ? 0x00 : (DWORD) (r * 255.0f + 0.5f); + DWORD dwG = g >= 1.0f ? 0xff : g <= 0.0f ? 0x00 : (DWORD) (g * 255.0f + 0.5f); + DWORD dwB = b >= 1.0f ? 0xff : b <= 0.0f ? 0x00 : (DWORD) (b * 255.0f + 0.5f); + DWORD dwA = a >= 1.0f ? 0xff : a <= 0.0f ? 0x00 : (DWORD) (a * 255.0f + 0.5f); + + return (dwA << 24) | (dwR << 16) | (dwG << 8) | dwB; +} + + +D3DXINLINE +D3DXCOLOR::operator float * () +{ + return (float *) &r; +} + +D3DXINLINE +D3DXCOLOR::operator const float * () const +{ + return (const float *) &r; +} + + +D3DXINLINE +D3DXCOLOR::operator D3DCOLORVALUE * () +{ + return (D3DCOLORVALUE *) &r; +} + +D3DXINLINE +D3DXCOLOR::operator const D3DCOLORVALUE * () const +{ + return (const D3DCOLORVALUE *) &r; +} + + +D3DXINLINE +D3DXCOLOR::operator D3DCOLORVALUE& () +{ + return *((D3DCOLORVALUE *) &r); +} + +D3DXINLINE +D3DXCOLOR::operator const D3DCOLORVALUE& () const +{ + return *((const D3DCOLORVALUE *) &r); +} + + +// assignment operators +D3DXINLINE D3DXCOLOR& +D3DXCOLOR::operator += ( const D3DXCOLOR& c ) +{ + r += c.r; + g += c.g; + b += c.b; + a += c.a; + return *this; +} + +D3DXINLINE D3DXCOLOR& +D3DXCOLOR::operator -= ( const D3DXCOLOR& c ) +{ + r -= c.r; + g -= c.g; + b -= c.b; + a -= c.a; + return *this; +} + +D3DXINLINE D3DXCOLOR& +D3DXCOLOR::operator *= ( float f ) +{ + r *= f; + g *= f; + b *= f; + a *= f; + return *this; +} + +D3DXINLINE D3DXCOLOR& +D3DXCOLOR::operator /= ( float f ) +{ + float fInv = 1.0f / f; + r *= fInv; + g *= fInv; + b *= fInv; + a *= fInv; + return *this; +} + + +// unary operators +D3DXINLINE D3DXCOLOR +D3DXCOLOR::operator + () const +{ + return *this; +} + +D3DXINLINE D3DXCOLOR +D3DXCOLOR::operator - () const +{ + return D3DXCOLOR(-r, -g, -b, -a); +} + + +// binary operators +D3DXINLINE D3DXCOLOR +D3DXCOLOR::operator + ( const D3DXCOLOR& c ) const +{ + return D3DXCOLOR(r + c.r, g + c.g, b + c.b, a + c.a); +} + +D3DXINLINE D3DXCOLOR +D3DXCOLOR::operator - ( const D3DXCOLOR& c ) const +{ + return D3DXCOLOR(r - c.r, g - c.g, b - c.b, a - c.a); +} + +D3DXINLINE D3DXCOLOR +D3DXCOLOR::operator * ( float f ) const +{ + return D3DXCOLOR(r * f, g * f, b * f, a * f); +} + +D3DXINLINE D3DXCOLOR +D3DXCOLOR::operator / ( float f ) const +{ + float fInv = 1.0f / f; + return D3DXCOLOR(r * fInv, g * fInv, b * fInv, a * fInv); +} + + +D3DXINLINE D3DXCOLOR +operator * (float f, const D3DXCOLOR& c ) +{ + return D3DXCOLOR(f * c.r, f * c.g, f * c.b, f * c.a); +} + + +D3DXINLINE BOOL +D3DXCOLOR::operator == ( const D3DXCOLOR& c ) const +{ + return r == c.r && g == c.g && b == c.b && a == c.a; +} + +D3DXINLINE BOOL +D3DXCOLOR::operator != ( const D3DXCOLOR& c ) const +{ + return r != c.r || g != c.g || b != c.b || a != c.a; +} + + +#endif //__cplusplus + + + +//=========================================================================== +// +// Inline functions +// +//=========================================================================== + + +//-------------------------- +// 2D Vector +//-------------------------- + +D3DXINLINE float D3DXVec2Length + ( const D3DXVECTOR2 *pV ) +{ +#ifdef D3DX_DEBUG + if(!pV) + return 0.0f; +#endif + +#ifdef __cplusplus + return sqrtf(pV->x * pV->x + pV->y * pV->y); +#else + return (float) sqrt(pV->x * pV->x + pV->y * pV->y); +#endif +} + +D3DXINLINE float D3DXVec2LengthSq + ( const D3DXVECTOR2 *pV ) +{ +#ifdef D3DX_DEBUG + if(!pV) + return 0.0f; +#endif + + return pV->x * pV->x + pV->y * pV->y; +} + +D3DXINLINE float D3DXVec2Dot + ( const D3DXVECTOR2 *pV1, const D3DXVECTOR2 *pV2 ) +{ +#ifdef D3DX_DEBUG + if(!pV1 || !pV2) + return 0.0f; +#endif + + return pV1->x * pV2->x + pV1->y * pV2->y; +} + +D3DXINLINE float D3DXVec2CCW + ( const D3DXVECTOR2 *pV1, const D3DXVECTOR2 *pV2 ) +{ +#ifdef D3DX_DEBUG + if(!pV1 || !pV2) + return 0.0f; +#endif + + return pV1->x * pV2->y - pV1->y * pV2->x; +} + +D3DXINLINE D3DXVECTOR2* D3DXVec2Add + ( D3DXVECTOR2 *pOut, const D3DXVECTOR2 *pV1, const D3DXVECTOR2 *pV2 ) +{ +#ifdef D3DX_DEBUG + if(!pOut || !pV1 || !pV2) + return NULL; +#endif + + pOut->x = pV1->x + pV2->x; + pOut->y = pV1->y + pV2->y; + return pOut; +} + +D3DXINLINE D3DXVECTOR2* D3DXVec2Subtract + ( D3DXVECTOR2 *pOut, const D3DXVECTOR2 *pV1, const D3DXVECTOR2 *pV2 ) +{ +#ifdef D3DX_DEBUG + if(!pOut || !pV1 || !pV2) + return NULL; +#endif + + pOut->x = pV1->x - pV2->x; + pOut->y = pV1->y - pV2->y; + return pOut; +} + +D3DXINLINE D3DXVECTOR2* D3DXVec2Minimize + ( D3DXVECTOR2 *pOut, const D3DXVECTOR2 *pV1, const D3DXVECTOR2 *pV2 ) +{ +#ifdef D3DX_DEBUG + if(!pOut || !pV1 || !pV2) + return NULL; +#endif + + pOut->x = pV1->x < pV2->x ? pV1->x : pV2->x; + pOut->y = pV1->y < pV2->y ? pV1->y : pV2->y; + return pOut; +} + +D3DXINLINE D3DXVECTOR2* D3DXVec2Maximize + ( D3DXVECTOR2 *pOut, const D3DXVECTOR2 *pV1, const D3DXVECTOR2 *pV2 ) +{ +#ifdef D3DX_DEBUG + if(!pOut || !pV1 || !pV2) + return NULL; +#endif + + pOut->x = pV1->x > pV2->x ? pV1->x : pV2->x; + pOut->y = pV1->y > pV2->y ? pV1->y : pV2->y; + return pOut; +} + +D3DXINLINE D3DXVECTOR2* D3DXVec2Scale + ( D3DXVECTOR2 *pOut, const D3DXVECTOR2 *pV, float s ) +{ +#ifdef D3DX_DEBUG + if(!pOut || !pV) + return NULL; +#endif + + pOut->x = pV->x * s; + pOut->y = pV->y * s; + return pOut; +} + +D3DXINLINE D3DXVECTOR2* D3DXVec2Lerp + ( D3DXVECTOR2 *pOut, const D3DXVECTOR2 *pV1, const D3DXVECTOR2 *pV2, + float s ) +{ +#ifdef D3DX_DEBUG + if(!pOut || !pV1 || !pV2) + return NULL; +#endif + + pOut->x = pV1->x + s * (pV2->x - pV1->x); + pOut->y = pV1->y + s * (pV2->y - pV1->y); + return pOut; +} + + +//-------------------------- +// 3D Vector +//-------------------------- + +D3DXINLINE float D3DXVec3Length + ( const D3DXVECTOR3 *pV ) +{ +#ifdef D3DX_DEBUG + if(!pV) + return 0.0f; +#endif + +#ifdef __cplusplus + return sqrtf(pV->x * pV->x + pV->y * pV->y + pV->z * pV->z); +#else + return (float) sqrt(pV->x * pV->x + pV->y * pV->y + pV->z * pV->z); +#endif +} + +D3DXINLINE float D3DXVec3LengthSq + ( const D3DXVECTOR3 *pV ) +{ +#ifdef D3DX_DEBUG + if(!pV) + return 0.0f; +#endif + + return pV->x * pV->x + pV->y * pV->y + pV->z * pV->z; +} + +D3DXINLINE float D3DXVec3Dot + ( const D3DXVECTOR3 *pV1, const D3DXVECTOR3 *pV2 ) +{ +#ifdef D3DX_DEBUG + if(!pV1 || !pV2) + return 0.0f; +#endif + + return pV1->x * pV2->x + pV1->y * pV2->y + pV1->z * pV2->z; +} + +D3DXINLINE D3DXVECTOR3* D3DXVec3Cross + ( D3DXVECTOR3 *pOut, const D3DXVECTOR3 *pV1, const D3DXVECTOR3 *pV2 ) +{ + D3DXVECTOR3 v; + +#ifdef D3DX_DEBUG + if(!pOut || !pV1 || !pV2) + return NULL; +#endif + + v.x = pV1->y * pV2->z - pV1->z * pV2->y; + v.y = pV1->z * pV2->x - pV1->x * pV2->z; + v.z = pV1->x * pV2->y - pV1->y * pV2->x; + + *pOut = v; + return pOut; +} + +D3DXINLINE D3DXVECTOR3* D3DXVec3Add + ( D3DXVECTOR3 *pOut, const D3DXVECTOR3 *pV1, const D3DXVECTOR3 *pV2 ) +{ +#ifdef D3DX_DEBUG + if(!pOut || !pV1 || !pV2) + return NULL; +#endif + + pOut->x = pV1->x + pV2->x; + pOut->y = pV1->y + pV2->y; + pOut->z = pV1->z + pV2->z; + return pOut; +} + +D3DXINLINE D3DXVECTOR3* D3DXVec3Subtract + ( D3DXVECTOR3 *pOut, const D3DXVECTOR3 *pV1, const D3DXVECTOR3 *pV2 ) +{ +#ifdef D3DX_DEBUG + if(!pOut || !pV1 || !pV2) + return NULL; +#endif + + pOut->x = pV1->x - pV2->x; + pOut->y = pV1->y - pV2->y; + pOut->z = pV1->z - pV2->z; + return pOut; +} + +D3DXINLINE D3DXVECTOR3* D3DXVec3Minimize + ( D3DXVECTOR3 *pOut, const D3DXVECTOR3 *pV1, const D3DXVECTOR3 *pV2 ) +{ +#ifdef D3DX_DEBUG + if(!pOut || !pV1 || !pV2) + return NULL; +#endif + + pOut->x = pV1->x < pV2->x ? pV1->x : pV2->x; + pOut->y = pV1->y < pV2->y ? pV1->y : pV2->y; + pOut->z = pV1->z < pV2->z ? pV1->z : pV2->z; + return pOut; +} + +D3DXINLINE D3DXVECTOR3* D3DXVec3Maximize + ( D3DXVECTOR3 *pOut, const D3DXVECTOR3 *pV1, const D3DXVECTOR3 *pV2 ) +{ +#ifdef D3DX_DEBUG + if(!pOut || !pV1 || !pV2) + return NULL; +#endif + + pOut->x = pV1->x > pV2->x ? pV1->x : pV2->x; + pOut->y = pV1->y > pV2->y ? pV1->y : pV2->y; + pOut->z = pV1->z > pV2->z ? pV1->z : pV2->z; + return pOut; +} + +D3DXINLINE D3DXVECTOR3* D3DXVec3Scale + ( D3DXVECTOR3 *pOut, const D3DXVECTOR3 *pV, float s) +{ +#ifdef D3DX_DEBUG + if(!pOut || !pV) + return NULL; +#endif + + pOut->x = pV->x * s; + pOut->y = pV->y * s; + pOut->z = pV->z * s; + return pOut; +} + +D3DXINLINE D3DXVECTOR3* D3DXVec3Lerp + ( D3DXVECTOR3 *pOut, const D3DXVECTOR3 *pV1, const D3DXVECTOR3 *pV2, + float s ) +{ +#ifdef D3DX_DEBUG + if(!pOut || !pV1 || !pV2) + return NULL; +#endif + + pOut->x = pV1->x + s * (pV2->x - pV1->x); + pOut->y = pV1->y + s * (pV2->y - pV1->y); + pOut->z = pV1->z + s * (pV2->z - pV1->z); + return pOut; +} + + +//-------------------------- +// 4D Vector +//-------------------------- + +D3DXINLINE float D3DXVec4Length + ( const D3DXVECTOR4 *pV ) +{ +#ifdef D3DX_DEBUG + if(!pV) + return 0.0f; +#endif + +#ifdef __cplusplus + return sqrtf(pV->x * pV->x + pV->y * pV->y + pV->z * pV->z + pV->w * pV->w); +#else + return (float) sqrt(pV->x * pV->x + pV->y * pV->y + pV->z * pV->z + pV->w * pV->w); +#endif +} + +D3DXINLINE float D3DXVec4LengthSq + ( const D3DXVECTOR4 *pV ) +{ +#ifdef D3DX_DEBUG + if(!pV) + return 0.0f; +#endif + + return pV->x * pV->x + pV->y * pV->y + pV->z * pV->z + pV->w * pV->w; +} + +D3DXINLINE float D3DXVec4Dot + ( const D3DXVECTOR4 *pV1, const D3DXVECTOR4 *pV2 ) +{ +#ifdef D3DX_DEBUG + if(!pV1 || !pV2) + return 0.0f; +#endif + + return pV1->x * pV2->x + pV1->y * pV2->y + pV1->z * pV2->z + pV1->w * pV2->w; +} + +D3DXINLINE D3DXVECTOR4* D3DXVec4Add + ( D3DXVECTOR4 *pOut, const D3DXVECTOR4 *pV1, const D3DXVECTOR4 *pV2) +{ +#ifdef D3DX_DEBUG + if(!pOut || !pV1 || !pV2) + return NULL; +#endif + + pOut->x = pV1->x + pV2->x; + pOut->y = pV1->y + pV2->y; + pOut->z = pV1->z + pV2->z; + pOut->w = pV1->w + pV2->w; + return pOut; +} + +D3DXINLINE D3DXVECTOR4* D3DXVec4Subtract + ( D3DXVECTOR4 *pOut, const D3DXVECTOR4 *pV1, const D3DXVECTOR4 *pV2) +{ +#ifdef D3DX_DEBUG + if(!pOut || !pV1 || !pV2) + return NULL; +#endif + + pOut->x = pV1->x - pV2->x; + pOut->y = pV1->y - pV2->y; + pOut->z = pV1->z - pV2->z; + pOut->w = pV1->w - pV2->w; + return pOut; +} + +D3DXINLINE D3DXVECTOR4* D3DXVec4Minimize + ( D3DXVECTOR4 *pOut, const D3DXVECTOR4 *pV1, const D3DXVECTOR4 *pV2) +{ +#ifdef D3DX_DEBUG + if(!pOut || !pV1 || !pV2) + return NULL; +#endif + + pOut->x = pV1->x < pV2->x ? pV1->x : pV2->x; + pOut->y = pV1->y < pV2->y ? pV1->y : pV2->y; + pOut->z = pV1->z < pV2->z ? pV1->z : pV2->z; + pOut->w = pV1->w < pV2->w ? pV1->w : pV2->w; + return pOut; +} + +D3DXINLINE D3DXVECTOR4* D3DXVec4Maximize + ( D3DXVECTOR4 *pOut, const D3DXVECTOR4 *pV1, const D3DXVECTOR4 *pV2) +{ +#ifdef D3DX_DEBUG + if(!pOut || !pV1 || !pV2) + return NULL; +#endif + + pOut->x = pV1->x > pV2->x ? pV1->x : pV2->x; + pOut->y = pV1->y > pV2->y ? pV1->y : pV2->y; + pOut->z = pV1->z > pV2->z ? pV1->z : pV2->z; + pOut->w = pV1->w > pV2->w ? pV1->w : pV2->w; + return pOut; +} + +D3DXINLINE D3DXVECTOR4* D3DXVec4Scale + ( D3DXVECTOR4 *pOut, const D3DXVECTOR4 *pV, float s) +{ +#ifdef D3DX_DEBUG + if(!pOut || !pV) + return NULL; +#endif + + pOut->x = pV->x * s; + pOut->y = pV->y * s; + pOut->z = pV->z * s; + pOut->w = pV->w * s; + return pOut; +} + +D3DXINLINE D3DXVECTOR4* D3DXVec4Lerp + ( D3DXVECTOR4 *pOut, const D3DXVECTOR4 *pV1, const D3DXVECTOR4 *pV2, + float s ) +{ +#ifdef D3DX_DEBUG + if(!pOut || !pV1 || !pV2) + return NULL; +#endif + + pOut->x = pV1->x + s * (pV2->x - pV1->x); + pOut->y = pV1->y + s * (pV2->y - pV1->y); + pOut->z = pV1->z + s * (pV2->z - pV1->z); + pOut->w = pV1->w + s * (pV2->w - pV1->w); + return pOut; +} + + +//-------------------------- +// 4D Matrix +//-------------------------- + +D3DXINLINE D3DXMATRIX* D3DXMatrixIdentity + ( D3DXMATRIX *pOut ) +{ +#ifdef D3DX_DEBUG + if(!pOut) + return NULL; +#endif + + pOut->m[0][1] = pOut->m[0][2] = pOut->m[0][3] = + pOut->m[1][0] = pOut->m[1][2] = pOut->m[1][3] = + pOut->m[2][0] = pOut->m[2][1] = pOut->m[2][3] = + pOut->m[3][0] = pOut->m[3][1] = pOut->m[3][2] = 0.0f; + + pOut->m[0][0] = pOut->m[1][1] = pOut->m[2][2] = pOut->m[3][3] = 1.0f; + return pOut; +} + + +D3DXINLINE BOOL D3DXMatrixIsIdentity + ( const D3DXMATRIX *pM ) +{ +#ifdef D3DX_DEBUG + if(!pM) + return FALSE; +#endif + + return pM->m[0][0] == 1.0f && pM->m[0][1] == 0.0f && pM->m[0][2] == 0.0f && pM->m[0][3] == 0.0f && + pM->m[1][0] == 0.0f && pM->m[1][1] == 1.0f && pM->m[1][2] == 0.0f && pM->m[1][3] == 0.0f && + pM->m[2][0] == 0.0f && pM->m[2][1] == 0.0f && pM->m[2][2] == 1.0f && pM->m[2][3] == 0.0f && + pM->m[3][0] == 0.0f && pM->m[3][1] == 0.0f && pM->m[3][2] == 0.0f && pM->m[3][3] == 1.0f; +} + + +//-------------------------- +// Quaternion +//-------------------------- + +D3DXINLINE float D3DXQuaternionLength + ( const D3DXQUATERNION *pQ ) +{ +#ifdef D3DX_DEBUG + if(!pQ) + return 0.0f; +#endif + +#ifdef __cplusplus + return sqrtf(pQ->x * pQ->x + pQ->y * pQ->y + pQ->z * pQ->z + pQ->w * pQ->w); +#else + return (float) sqrt(pQ->x * pQ->x + pQ->y * pQ->y + pQ->z * pQ->z + pQ->w * pQ->w); +#endif +} + +D3DXINLINE float D3DXQuaternionLengthSq + ( const D3DXQUATERNION *pQ ) +{ +#ifdef D3DX_DEBUG + if(!pQ) + return 0.0f; +#endif + + return pQ->x * pQ->x + pQ->y * pQ->y + pQ->z * pQ->z + pQ->w * pQ->w; +} + +D3DXINLINE float D3DXQuaternionDot + ( const D3DXQUATERNION *pQ1, const D3DXQUATERNION *pQ2 ) +{ +#ifdef D3DX_DEBUG + if(!pQ1 || !pQ2) + return 0.0f; +#endif + + return pQ1->x * pQ2->x + pQ1->y * pQ2->y + pQ1->z * pQ2->z + pQ1->w * pQ2->w; +} + + +D3DXINLINE D3DXQUATERNION* D3DXQuaternionIdentity + ( D3DXQUATERNION *pOut ) +{ +#ifdef D3DX_DEBUG + if(!pOut) + return NULL; +#endif + + pOut->x = pOut->y = pOut->z = 0.0f; + pOut->w = 1.0f; + return pOut; +} + +D3DXINLINE BOOL D3DXQuaternionIsIdentity + ( const D3DXQUATERNION *pQ ) +{ +#ifdef D3DX_DEBUG + if(!pQ) + return FALSE; +#endif + + return pQ->x == 0.0f && pQ->y == 0.0f && pQ->z == 0.0f && pQ->w == 1.0f; +} + + +D3DXINLINE D3DXQUATERNION* D3DXQuaternionConjugate + ( D3DXQUATERNION *pOut, const D3DXQUATERNION *pQ ) +{ +#ifdef D3DX_DEBUG + if(!pOut || !pQ) + return NULL; +#endif + + pOut->x = -pQ->x; + pOut->y = -pQ->y; + pOut->z = -pQ->z; + pOut->w = pQ->w; + return pOut; +} + + +//-------------------------- +// Plane +//-------------------------- + +D3DXINLINE float D3DXPlaneDot + ( const D3DXPLANE *pP, const D3DXVECTOR4 *pV) +{ +#ifdef D3DX_DEBUG + if(!pP || !pV) + return 0.0f; +#endif + + return pP->a * pV->x + pP->b * pV->y + pP->c * pV->z + pP->d * pV->w; +} + +D3DXINLINE float D3DXPlaneDotCoord + ( const D3DXPLANE *pP, const D3DXVECTOR3 *pV) +{ +#ifdef D3DX_DEBUG + if(!pP || !pV) + return 0.0f; +#endif + + return pP->a * pV->x + pP->b * pV->y + pP->c * pV->z + pP->d; +} + +D3DXINLINE float D3DXPlaneDotNormal + ( const D3DXPLANE *pP, const D3DXVECTOR3 *pV) +{ +#ifdef D3DX_DEBUG + if(!pP || !pV) + return 0.0f; +#endif + + return pP->a * pV->x + pP->b * pV->y + pP->c * pV->z; +} + + +//-------------------------- +// Color +//-------------------------- + +D3DXINLINE D3DXCOLOR* D3DXColorNegative + (D3DXCOLOR *pOut, const D3DXCOLOR *pC) +{ +#ifdef D3DX_DEBUG + if(!pOut || !pC) + return NULL; +#endif + + pOut->r = 1.0f - pC->r; + pOut->g = 1.0f - pC->g; + pOut->b = 1.0f - pC->b; + pOut->a = pC->a; + return pOut; +} + +D3DXINLINE D3DXCOLOR* D3DXColorAdd + (D3DXCOLOR *pOut, const D3DXCOLOR *pC1, const D3DXCOLOR *pC2) +{ +#ifdef D3DX_DEBUG + if(!pOut || !pC1 || !pC2) + return NULL; +#endif + + pOut->r = pC1->r + pC2->r; + pOut->g = pC1->g + pC2->g; + pOut->b = pC1->b + pC2->b; + pOut->a = pC1->a + pC2->a; + return pOut; +} + +D3DXINLINE D3DXCOLOR* D3DXColorSubtract + (D3DXCOLOR *pOut, const D3DXCOLOR *pC1, const D3DXCOLOR *pC2) +{ +#ifdef D3DX_DEBUG + if(!pOut || !pC1 || !pC2) + return NULL; +#endif + + pOut->r = pC1->r - pC2->r; + pOut->g = pC1->g - pC2->g; + pOut->b = pC1->b - pC2->b; + pOut->a = pC1->a - pC2->a; + return pOut; +} + +D3DXINLINE D3DXCOLOR* D3DXColorScale + (D3DXCOLOR *pOut, const D3DXCOLOR *pC, float s) +{ +#ifdef D3DX_DEBUG + if(!pOut || !pC) + return NULL; +#endif + + pOut->r = pC->r * s; + pOut->g = pC->g * s; + pOut->b = pC->b * s; + pOut->a = pC->a * s; + return pOut; +} + +D3DXINLINE D3DXCOLOR* D3DXColorModulate + (D3DXCOLOR *pOut, const D3DXCOLOR *pC1, const D3DXCOLOR *pC2) +{ +#ifdef D3DX_DEBUG + if(!pOut || !pC1 || !pC2) + return NULL; +#endif + + pOut->r = pC1->r * pC2->r; + pOut->g = pC1->g * pC2->g; + pOut->b = pC1->b * pC2->b; + pOut->a = pC1->a * pC2->a; + return pOut; +} + +D3DXINLINE D3DXCOLOR* D3DXColorLerp + (D3DXCOLOR *pOut, const D3DXCOLOR *pC1, const D3DXCOLOR *pC2, float s) +{ +#ifdef D3DX_DEBUG + if(!pOut || !pC1 || !pC2) + return NULL; +#endif + + pOut->r = pC1->r + s * (pC2->r - pC1->r); + pOut->g = pC1->g + s * (pC2->g - pC1->g); + pOut->b = pC1->b + s * (pC2->b - pC1->b); + pOut->a = pC1->a + s * (pC2->a - pC1->a); + return pOut; +} + + +#endif // __D3DXMATH_INL__ diff --git a/engine/libs/dxsdk7/include/d3dxshapes.h b/engine/libs/dxsdk7/include/d3dxshapes.h new file mode 100644 index 000000000..22dbfe12c --- /dev/null +++ b/engine/libs/dxsdk7/include/d3dxshapes.h @@ -0,0 +1,209 @@ +/////////////////////////////////////////////////////////////////////////// +// +// Copyright (C) 1999 Microsoft Corporation. All Rights Reserved. +// +// File: d3dxshapes.h +// Content: D3DX simple shapes +// +/////////////////////////////////////////////////////////////////////////// + +#ifndef __D3DXSHAPES_H__ +#define __D3DXSHAPES_H__ + +#include +#include +#include "d3dxerr.h" + + +typedef struct ID3DXSimpleShape *LPD3DXSIMPLESHAPE; + +// {CFCD4602-EB7B-11d2-A440-00A0C90629A8} +DEFINE_GUID( IID_ID3DXSimpleShape, +0xcfcd4602, 0xeb7b, 0x11d2, 0xa4, 0x40, 0x0, 0xa0, 0xc9, 0x6, 0x29, 0xa8 ); + + +/////////////////////////////////////////////////////////////////////////// +// Interfaces: +/////////////////////////////////////////////////////////////////////////// + +//------------------------------------------------------------------------- +// ID3DXSimpleShape interface: +//------------------------------------------------------------------------- + +DECLARE_INTERFACE_(ID3DXSimpleShape, IUnknown) +{ + // IUnknown methods + STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID* ppvObj) PURE; + STDMETHOD_(ULONG,AddRef)(THIS) PURE; + STDMETHOD_(ULONG,Release)(THIS) PURE; + + // ID3DXSimpleShape methods + STDMETHOD_(LPDIRECT3DVERTEXBUFFER7, GetVB)(THIS) PURE; + STDMETHOD_(DWORD, GetIndices)(THIS_ LPWORD *ppIndices) PURE; + STDMETHOD(Draw)(THIS) PURE; +}; + + + +/////////////////////////////////////////////////////////////////////////// +// Functions: +/////////////////////////////////////////////////////////////////////////// + +#ifdef __cplusplus +extern "C" { +#endif //__cplusplus + + +//------------------------------------------------------------------------- +// D3DXCreatePolygon: Creates an 'n' sided polygon using the device +// ---------------- specified. It returns a vertex buffer that can be used +// for drawing or manipulation by the program later on. +// +// Params: +// [in] LPDIRECT3DDEVICE7 pDevice: The device to create off. +// [in] float sideSize: Length of a side. +// [in] DWORD numTexCoords: The number of texture coordinates desired +// in the vertex-buffer. (Default is 1) +// D3DX_DEFAULT is a valid input. +// [out] IDirect3DVertexBuffer7** ppVB: The output shape interface. +//------------------------------------------------------------------------- +HRESULT WINAPI + D3DXCreatePolygon(LPDIRECT3DDEVICE7 pDevice, + float sideSize, + DWORD numSides, + DWORD numTexCoords, + LPD3DXSIMPLESHAPE* ppShape ); + +//------------------------------------------------------------------------- +// D3DXCreateBox: Creates a box (cuboid) of given dimensions using the +// ------------ device. It returns a vertex buffer that can +// be used for drawing or manipulation by the program later on. +// +// Params: +// [in] LPDIRECT3DDEVICE7 pDevice: The device to create off. +// [in] float width: Width of the box (along x-axis) +// [in] float height: Height of the box (along y-axis) +// [in] float depth: Depth of the box (along z-axis) +// [in] DWORD numTexCoords: The number of texture coordinates desired +// in the vertex-buffer. Default is 1. +// D3DX_DEFAULT is a valid input here. +// [out] LPD3DXSIMPLESHAPE* ppShape: The output vertex-buffer. +//------------------------------------------------------------------------- +HRESULT WINAPI + D3DXCreateBox(LPDIRECT3DDEVICE7 pDevice, + float width, + float height, + float depth, + DWORD numTexCoords, + LPD3DXSIMPLESHAPE* ppShape ); + +//------------------------------------------------------------------------- +// D3DXCreateCylinder: Creates a cylinder of given dimensions using the +// ----------------- device. It returns a vertex buffer that +// can be used for drawing or manipulation by the program +// later on. +// +// Params: +// [in] LPDIRECT3DDEVICE7 pDevice: The device to create off. +// [in] float baseRadius: Base-radius (default is 1.0f, shd be >= 0.0f) +// [in] float topRadius: Top-radius (default is 1.0f, shd be >= 0.0f) +// [in] float height: Height (default is 1.0f, shd be >= 0.0f) +// [in] DWORD numSlices: Number of slices about the main axis. +// (default is 8) D3DX_DEFAULT is a valid input. +// [in] DWORD numStacks: Number of stacks along the main axis. +// (default is 8) D3DX_DEFAULT is a valid input. +// [in] DWORD numTexCoords: The number of texture coordinates desired +// in the vertex-buffer. Default is 1. +// D3DX_DEFAULT is a valid input here. +// [out] LPD3DXSIMPLESHAPE* ppShape: The output shape interface. +//------------------------------------------------------------------------- +HRESULT WINAPI + D3DXCreateCylinder(LPDIRECT3DDEVICE7 pDevice, + float baseRadius, + float topRadius, + float height, + DWORD numSlices, + DWORD numStacks, + DWORD numTexCoords, + LPD3DXSIMPLESHAPE* ppShape ); + + +//------------------------------------------------------------------------- +// D3DXCreateTorus: Creates a torus of given dimensions using the +// -------------- device specified. It returns a vertex buffer that can +// be used for drawing or manipulation by the program later +// on. It draws a doughnut, centered at (0, 0, 0) whose axis +// is aligned with the z-axis. With the innerRadius used +// as the radius of the cross-section (minor-Radius) and +// the outerRadius used as the radius of the central 'hole'. +// +// Params: +// [in] LPDIRECT3DDEVICE7 pDevice: The device to create off. +// [in] float innerRadius: inner radius (default is 1.0f, shd be >= 0.0f) +// [in] float outerRadius: outer radius (default is 2.0f, shd be >= 0.0f) +// [in] DWORD numSides: Number of sides in the cross-section +// (default is 8). D3DX_DEFAULT is a valid input. +// [in] DWORD numRings: Number of rings making up the torus +// (default is 8) D3DX_DEFAULT is a valid input. +// [in] DWORD numTexCoords: The number of texture coordinates desired +// in the vertex-buffer. Default is 1. +// D3DX_DEFAULT is a valid input here. +// [out] LPD3DXSIMPLESHAPE* ppShape: The output shape interface. +//------------------------------------------------------------------------- +HRESULT WINAPI + D3DXCreateTorus(LPDIRECT3DDEVICE7 pDevice, + float innerRadius, + float outerRadius, + DWORD numSides, + DWORD numRings, + DWORD numTexCoords, + LPD3DXSIMPLESHAPE* ppShape ); + +//------------------------------------------------------------------------- +// D3DXCreateTeapot: Creates a teapot using the device specified. +// ---------------- It returns a vertex buffer that can be used for +// drawing or manipulation by the program later on. +// +// Params: +// [in] LPDIRECT3DDEVICE7 pDevice: The device to create off. +// [in] DWORD numTexCoords: The number of texture coordinates desired +// in the vertex-buffer. Default is 1. +// D3DX_DEFAULT is a valid input here. +// [out] LPD3DXSIMPLESHAPE* ppShape: The output shape interface. +//------------------------------------------------------------------------- +HRESULT WINAPI + D3DXCreateTeapot(LPDIRECT3DDEVICE7 pDevice, + DWORD numTexCoords, + LPD3DXSIMPLESHAPE* ppShape); + +//------------------------------------------------------------------------- +// D3DXCreateSphere: Creates a cylinder of given dimensions using the +// ---------------- device specified. +// It returns a vertex buffer that can be used for +// drawing or manipulation by the program later on. +// +// Params: +// [in] LPDIRECT3DDEVICE7 pDevice: The device to create off. +// [in] float radius: radius (default is 1.0f, shd be >= 0.0f) +// [in] float height: Height (default is 1.0f, shd be >= 0.0f) +// [in] DWORD numSlices: Number of slices about the main axis +// (default is 8) D3DX_DEFAULT is a valid input. +// [in] DWORD numStacks: Number of stacks along the main axis +// (default is 8) D3DX_DEFAULT is a valid input. +// [in] DWORD numTexCoords: The number of texture coordinates desired +// in the vertex-buffer. Default is 1. +// D3DX_DEFAULT is a valid input here. +// [out] LPD3DXSIMPLESHAPE* ppShape: The output shape interface. +//------------------------------------------------------------------------- +HRESULT WINAPI + D3DXCreateSphere(LPDIRECT3DDEVICE7 pDevice, + float radius, + DWORD numSlices, + DWORD numStacks, + DWORD numTexCoords, + LPD3DXSIMPLESHAPE* ppShape); + +#ifdef __cplusplus +} +#endif //__cplusplus +#endif //__D3DXSHAPES_H__ diff --git a/engine/libs/dxsdk7/include/d3dxsprite.h b/engine/libs/dxsdk7/include/d3dxsprite.h new file mode 100644 index 000000000..26cc0659f --- /dev/null +++ b/engine/libs/dxsdk7/include/d3dxsprite.h @@ -0,0 +1,321 @@ +/////////////////////////////////////////////////////////////////////////// +// +// Copyright (C) 1999 Microsoft Corporation. All Rights Reserved. +// +// File: d3dxsprite.h +// Content: D3DX sprite helper functions +// +// These functions allow you to use sprites with D3DX. A "sprite" is +// loosely defined as a 2D image that you want to transfer to the +// rendering target. The source image can be a texture created +// with the help of the D3DX texture loader; though advanced users may +// want to create their own. A helper function (PrepareDeviceForSprite) +// is provided to make it easy to set up render states on a device. +// (Again, advanced users can use their own created devices.) +// +// There are two general techniques for sprites; the simpler one just +// specifies a destination rectangle and a rotation anlge. A more +// powerful technique supports rendering to non-rectangular quads. +// +// Both techniques support clipping, alpha, and rotation. More +// details are below. +// +/////////////////////////////////////////////////////////////////////////// + +#ifndef __D3DXSPRITE_H__ +#define __D3DXSPRITE_H__ + +#include +#include +#include "d3dxerr.h" + +#ifdef __cplusplus +extern "C" { +#endif + + +//------------------------------------------------------------------------- +// D3DXPrepareDeviceForSprite: +// +// Call this function to set up all the render states necessary for +// BltSprite/WarpSprite to work correctly. (Advanced users may opt to +// not call this function first; in which case Blt/WarpSprite functions +// will use whatever render/texture states were set up on the device when +// they are called.) +// +// Warning: This function modifies render states and may impact performance +// negatively on some 3D hardware if it is called too often per frame. +// +// Warning: If the render state changes (other than through calls to +// BltSprite or WarpSprite), you will need to call this function again before +// calling BltSprite or WarpSprite. +// +// Details: This function modifies the the rendering first texture stage and +// it modifies some renderstates for the entire device. Here is the exact +// list: +// +// SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE); +// SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_SELECTARG1); +// SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE); +// SetTextureStageState(0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE); +// SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_MODULATE); +// SetTextureStageState(0, D3DTSS_MINFILTER, D3DTFN_LINEAR); +// SetTextureStageState(0, D3DTSS_MAGFILTER, D3DTFG_LINEAR); +// +// SetRenderState(D3DRENDERSTATE_SRCBLEND, D3DBLEND_SRCALPHA); +// SetRenderState(D3DRENDERSTATE_DESTBLEND, D3DBLEND_INVSRCALPHA); +// SetRenderState(D3DRENDERSTATE_ALPHABLENDENABLE, TRUE); +// +// Depending on the value of ZEnable parameter, this function will +// will either call +// SetRenderState(D3DRENDERSTATE_ZENABLE, FALSE); +// - or - +// SetRenderState(D3DRENDERSTATE_ZENABLE, TRUE); +// +// Parameters: +// pd3dDevice - a pointer to the d3d device that you wish to prepare +// for use with D3DX Sprite Services +// ZEnable - a flag indicating whether you want the sprites to +// check and update the Z buffer as part of rendering. +// If ZEnable is FALSE, OR you are using +// alpha-blending, then it is necessary to render your +// sprites from back-to-front. +// +//------------------------------------------------------------------------- + +#ifdef __cplusplus +HRESULT WINAPI + D3DXPrepareDeviceForSprite( LPDIRECT3DDEVICE7 pd3dDevice, + BOOL ZEnable = FALSE); +#else +HRESULT WINAPI + D3DXPrepareDeviceForSprite( LPDIRECT3DDEVICE7 pd3dDevice, + BOOL ZEnable); +#endif + + + +//------------------------------------------------------------------------- +// The D3DXDrawBasicSprite() function performs blitting of source images onto +// a 3D rendering device. This function only calls SetTexture on the first +// renderstage with the parameter (pd3dTexture) if that parameter is non-null. +// This function assumes that D3DXPrepareDeviceForSprite has been called on +// the device or that caller has in some other way correctly prepared the +// renderstates. +// +// This function supports scaling, rotations, alpha-blending, and choosing +// a source sub-rect. +// +// Rotation angle is specified in radians. Both rotations and scales +// are applied around the center of the sprite; where the center of the +// sprite is half the width/height of the sprite, plus the offset parameter. +// +// Use the offset parameter if you want the sprite's center to be something +// other than the image center. +// +// The destination point indicates where you would like the center of +// the sprite to draw to. +// +// Parameters: +// pd3dTexture - a pointer to the surface containing the texture +// pd3dDevice - a pointer to the d3d device to render to. It is +// assumed that render states are set up. (See +// D3DXPrepareDeviceForSprite) +// ppointDest - a pointer to the target point for the sprite. The +// components of the vector must be in screen +// space. +// alpha - alpha value to apply to sprite. 1.0 means totally +// opaque; and 0.0 means totally transparent. +// WARNING: If you are using alpha, then you should render +// from back to front in order to avoid rendering +// artifacts. +// angleRad - angle of rotation around the 'center' of the rect +// scale - a uniform scale that is applied to the source rect +// to specify the size of the image that is rendered +// pOffset - offset from the center of the source rect to use as the +// center of rotation +// pSourceRect - a rect that indicates what portion of the source +// source texture to use. If NULL is passed, then the +// entire source is used. If the source texture was +// created via D3DX, then the rect should be specified +// in the coordinates of the original image (so that you +// don't have to worry about stretching/scaling that D3DX +// may have done to make the image work with your current +// 3D Device.) Note that horizontal or vertical mirroring +// may be simply accomplished by swapping the left/right +// or top/bottom fields of this RECT. +//------------------------------------------------------------------------- + +#ifdef __cplusplus +HRESULT WINAPI + D3DXDrawSpriteSimple(LPDIRECTDRAWSURFACE7 pd3dTexture, + LPDIRECT3DDEVICE7 pd3dDevice, + const D3DXVECTOR3 *ppointDest, + float alpha = 1.0f, + float scale = 1.0f, + float angleRad = 0.0f, + const D3DXVECTOR2 *pOffset = NULL, + const RECT *pSourceRect = NULL); +#else +HRESULT WINAPI + D3DXDrawSpriteSimple(LPDIRECTDRAWSURFACE7 pd3dTexture, + LPDIRECT3DDEVICE7 pd3dDevice, + D3DXVECTOR3 *ppointDest, + float alpha, + float scale, + float angleRad, + D3DXVECTOR2 *pOffset, + RECT *pSourceRect); +#endif + +//------------------------------------------------------------------------- +// The D3DXDrawSprite() function transforms source images onto a 3D +// rendering device. It takes a general 4x4 matrix which is use to transform +// the points of a default rect: (left=-.5, top=-.5, right=+.5, bottom=+.5). +// (This default rect was chosen so that it was centered around the origin +// to ease setting up rotations. And it was chosen to have a width/height of one +// to ease setting up scales.) +// +// This function only calls SetTexture on the first +// renderstage with the parameter (pd3dTexture) if that parameter is non-null. +// This function assumes that D3DXPrepareDeviceForSprite has been called on +// the device or that caller has in some other way correctly prepared the +// renderstates. +// +// This function supports alpha-blending, and choosing +// a source sub-rect. (A value of NULL for source sub-rect means the entire +// texture is used.) +// +// Note that if the transformed points have a value for w (the homogenous +// coordinate) that is not 1, then this function will invert it and pass +// that value to D3D as the rhw field of a TLVERTEX. If the value for w is +// zero, then it use 1 as the rhw. +// +// Parameters: +// pd3dTexture - a pointer to the surface containing the texture +// pd3dDevice - a pointer to the d3d device to render to. It is +// assumed that render states are set up. (See +// D3DXPrepareDeviceForSprite) +// pMatrixTransform - 4x4 matrix that specifies the transformation +// that will be applied to the default -.5 to +.5 +// rectangle. +// alpha - alpha value to apply to sprite. 1.0 means totally +// opaque; and 0.0 means totally transparent. +// WARNING: If you are using alpha, then you should render +// from back to front in order to avoid rendering +// artifacts.Furthermore, you should avoid scenarios where +// semi-transparent objects intersect. +// pSourceRect - a rect that indicates what portion of the source +// source texture to use. If NULL is passed, then the +// entire source is used. If the source texture was +// created via D3DX, then the rect should be specified +// in the coordinates of the original image (so that you +// don't have to worry about stretching/scaling that D3DX +// may have done to make the image work with your current +// 3D Device.) Note that mirroring may be simply accomplished +// by swapping the left/right or top/bottom fields of +// this RECT. +// +//------------------------------------------------------------------------- + +#ifdef __cplusplus +HRESULT WINAPI + D3DXDrawSpriteTransform(LPDIRECTDRAWSURFACE7 pd3dTexture, + LPDIRECT3DDEVICE7 pd3dDevice, + const D3DXMATRIX *pMatrixTransform, + float alpha = 1.0f, + const RECT *pSourceRect = NULL); +#else +HRESULT WINAPI + D3DXDrawSpriteTransform(LPDIRECTDRAWSURFACE7 pd3dTexture, + LPDIRECT3DDEVICE7 pd3dDevice, + D3DXMATRIX *pMatrixTransform, + float alpha, + RECT *pSourceRect); +#endif + +//------------------------------------------------------------------------- +// The D3DXBuildSpriteTransform() function is a helper provided which +// creates a matrix corresponding to simple properties. This matrix is +// set up to pass directly to D3DXTransformSprite. +// +// Parameters: +// pMatrix - a pointer to the result matrix +// prectDest - a pointer to the target rectangle for the sprite +// angleRad - angle of rotation around the 'center' of the rect +// pOffset - offset from the center of the source rect to use as the +// center of rotation +// +//------------------------------------------------------------------------- + +#ifdef __cplusplus +void WINAPI + D3DXBuildSpriteTransform(D3DXMATRIX *pMatrix, + const RECT *prectDest, + float angleRad = 0.0f, + const D3DXVECTOR2 *pOffset = NULL); +#else +void WINAPI + D3DXBuildSpriteTransform(D3DXMATRIX *pMatrix, + RECT *prectDest, + float angleRad, + D3DXVECTOR2 *pOffset); +#endif + + +//------------------------------------------------------------------------- +// The D3DXDrawSprite3D() function renders a texture onto a 3D quad. The +// quad ABCD is broken into two triangles ABC and ACD which are rendered +// via DrawPrim. +// +// Parameters: +// pd3dTexture - a pointer to the surface containing the texture +// pd3dDevice - a pointer to the d3d device to render to. It is +// assumed that render states are set up. (See +// D3DXPrepareDeviceForSprite) +// quad - array of 4 points in the following order: +// upper-left, upper-right, lower-right, lower-left. +// If these vectors contain a W, then this function +// will take the reciprocal of that value to pass as +// as the rhw (i.e. reciprocal homogenous w). +// alpha - alpha value to apply to sprite. 1.0 means totally +// opaque; and 0.0 means totally transparent. +// WARNING: If you are using alpha, then you should render +// from back to front in order to avoid rendering +// artifacts.Furthermore, you should avoid scenarios where +// semi-transparent objects intersect. +// pSourceRect - a rect that indicates what portion of the source +// source texture to use. If NULL is passed, then the +// entire source is used. If the source texture was +// created via D3DX, then the rect should be specified +// in the coordinates of the original image (so that you +// don't have to worry about stretching/scaling that D3DX +// may have done to make the image work with your current +// 3D Device.) Note that mirroring may be simply accomplished +// by swapping the left/right or top/bottom fields of +// this RECT. +//------------------------------------------------------------------------- + +#ifdef __cplusplus +HRESULT WINAPI + D3DXDrawSprite3D(LPDIRECTDRAWSURFACE7 pd3dTexture, + LPDIRECT3DDEVICE7 pd3dDevice, + const D3DXVECTOR4 quad[4], + float alpha = 1.0f, + const RECT *pSourceRect = NULL); +#else +HRESULT WINAPI + D3DXDrawSprite3D(LPDIRECTDRAWSURFACE7 pd3dTexture, + LPDIRECT3DDEVICE7 pd3dDevice, + D3DXVECTOR4 quad[4], + float alpha, + RECT *pSourceRect); +#endif + + + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif // __D3DXSPRITE_H__ diff --git a/engine/libs/dxsdk7/include/ddraw.h b/engine/libs/dxsdk7/include/ddraw.h new file mode 100644 index 000000000..f031c3f14 --- /dev/null +++ b/engine/libs/dxsdk7/include/ddraw.h @@ -0,0 +1,5561 @@ +/*==========================================================================; + * + * Copyright (C) 1994-1997 Microsoft Corporation. All Rights Reserved. + * + * File: ddraw.h + * Content: DirectDraw include file + * + ***************************************************************************/ + +#ifndef __DDRAW_INCLUDED__ +#define __DDRAW_INCLUDED__ + +//Disable the nameless union warning +#ifdef _MSC_VER +#pragma warning(disable:4201) +#endif + +/* + * If you wish an application built against the newest version of DirectDraw + * to run against an older DirectDraw run time then define DIRECTDRAW_VERSION + * to be the earlies version of DirectDraw you wish to run against. For, + * example if you wish an application to run against a DX 3 runtime define + * DIRECTDRAW_VERSION to be 0x0300. + */ +#ifndef DIRECTDRAW_VERSION +#define DIRECTDRAW_VERSION 0x0700 +#endif /* DIRECTDRAW_VERSION */ + +#if defined( _WIN32 ) && !defined( _NO_COM ) +#define COM_NO_WINDOWS_H +#include +#else +#define IUnknown void +#if !defined( NT_BUILD_ENVIRONMENT ) && !defined(WINNT) + #define CO_E_NOTINITIALIZED 0x800401F0L +#endif +#endif + +#define _FACDD 0x876 +#define MAKE_DDHRESULT( code ) MAKE_HRESULT( 1, _FACDD, code ) + +#ifdef __cplusplus +extern "C" { +#endif + +// +// For compilers that don't support nameless unions, do a +// +// #define NONAMELESSUNION +// +// before #include +// +#ifndef DUMMYUNIONNAMEN +#if defined(__cplusplus) || !defined(NONAMELESSUNION) +#define DUMMYUNIONNAMEN(n) +#else +#define DUMMYUNIONNAMEN(n) u##n +#endif +#endif + +#ifndef MAKEFOURCC + #define MAKEFOURCC(ch0, ch1, ch2, ch3) \ + ((DWORD)(BYTE)(ch0) | ((DWORD)(BYTE)(ch1) << 8) | \ + ((DWORD)(BYTE)(ch2) << 16) | ((DWORD)(BYTE)(ch3) << 24 )) +#endif //defined(MAKEFOURCC) + +/* + * FOURCC codes for DX compressed-texture pixel formats + */ +#define FOURCC_DXT1 (MAKEFOURCC('D','X','T','1')) +#define FOURCC_DXT2 (MAKEFOURCC('D','X','T','2')) +#define FOURCC_DXT3 (MAKEFOURCC('D','X','T','3')) +#define FOURCC_DXT4 (MAKEFOURCC('D','X','T','4')) +#define FOURCC_DXT5 (MAKEFOURCC('D','X','T','5')) + +/* + * GUIDS used by DirectDraw objects + */ +#if defined( _WIN32 ) && !defined( _NO_COM ) + +DEFINE_GUID( CLSID_DirectDraw, 0xD7B70EE0,0x4340,0x11CF,0xB0,0x63,0x00,0x20,0xAF,0xC2,0xCD,0x35 ); +DEFINE_GUID( CLSID_DirectDraw7, 0x3c305196,0x50db,0x11d3,0x9c,0xfe,0x00,0xc0,0x4f,0xd9,0x30,0xc5 ); +DEFINE_GUID( CLSID_DirectDrawClipper, 0x593817A0,0x7DB3,0x11CF,0xA2,0xDE,0x00,0xAA,0x00,0xb9,0x33,0x56 ); +DEFINE_GUID( IID_IDirectDraw, 0x6C14DB80,0xA733,0x11CE,0xA5,0x21,0x00,0x20,0xAF,0x0B,0xE5,0x60 ); +DEFINE_GUID( IID_IDirectDraw2, 0xB3A6F3E0,0x2B43,0x11CF,0xA2,0xDE,0x00,0xAA,0x00,0xB9,0x33,0x56 ); +DEFINE_GUID( IID_IDirectDraw4, 0x9c59509a,0x39bd,0x11d1,0x8c,0x4a,0x00,0xc0,0x4f,0xd9,0x30,0xc5 ); +DEFINE_GUID( IID_IDirectDraw7, 0x15e65ec0,0x3b9c,0x11d2,0xb9,0x2f,0x00,0x60,0x97,0x97,0xea,0x5b ); +DEFINE_GUID( IID_IDirectDrawSurface, 0x6C14DB81,0xA733,0x11CE,0xA5,0x21,0x00,0x20,0xAF,0x0B,0xE5,0x60 ); +DEFINE_GUID( IID_IDirectDrawSurface2, 0x57805885,0x6eec,0x11cf,0x94,0x41,0xa8,0x23,0x03,0xc1,0x0e,0x27 ); +DEFINE_GUID( IID_IDirectDrawSurface3, 0xDA044E00,0x69B2,0x11D0,0xA1,0xD5,0x00,0xAA,0x00,0xB8,0xDF,0xBB ); +DEFINE_GUID( IID_IDirectDrawSurface4, 0x0B2B8630,0xAD35,0x11D0,0x8E,0xA6,0x00,0x60,0x97,0x97,0xEA,0x5B ); +DEFINE_GUID( IID_IDirectDrawSurface7, 0x06675a80,0x3b9b,0x11d2,0xb9,0x2f,0x00,0x60,0x97,0x97,0xea,0x5b ); + +DEFINE_GUID( IID_IDirectDrawPalette, 0x6C14DB84,0xA733,0x11CE,0xA5,0x21,0x00,0x20,0xAF,0x0B,0xE5,0x60 ); +DEFINE_GUID( IID_IDirectDrawClipper, 0x6C14DB85,0xA733,0x11CE,0xA5,0x21,0x00,0x20,0xAF,0x0B,0xE5,0x60 ); +DEFINE_GUID( IID_IDirectDrawColorControl, 0x4B9F0EE0,0x0D7E,0x11D0,0x9B,0x06,0x00,0xA0,0xC9,0x03,0xA3,0xB8 ); +DEFINE_GUID( IID_IDirectDrawGammaControl, 0x69C11C3E,0xB46B,0x11D1,0xAD,0x7A,0x00,0xC0,0x4F,0xC2,0x9B,0x4E ); + +#endif + +/*============================================================================ + * + * DirectDraw Structures + * + * Various structures used to invoke DirectDraw. + * + *==========================================================================*/ + +struct IDirectDraw; +struct IDirectDrawSurface; +struct IDirectDrawPalette; +struct IDirectDrawClipper; + +typedef struct IDirectDraw FAR *LPDIRECTDRAW; +typedef struct IDirectDraw2 FAR *LPDIRECTDRAW2; +typedef struct IDirectDraw4 FAR *LPDIRECTDRAW4; +typedef struct IDirectDraw7 FAR *LPDIRECTDRAW7; +typedef struct IDirectDrawSurface FAR *LPDIRECTDRAWSURFACE; +typedef struct IDirectDrawSurface2 FAR *LPDIRECTDRAWSURFACE2; +typedef struct IDirectDrawSurface3 FAR *LPDIRECTDRAWSURFACE3; +typedef struct IDirectDrawSurface4 FAR *LPDIRECTDRAWSURFACE4; +typedef struct IDirectDrawSurface7 FAR *LPDIRECTDRAWSURFACE7; + +typedef struct IDirectDrawPalette FAR *LPDIRECTDRAWPALETTE; +typedef struct IDirectDrawClipper FAR *LPDIRECTDRAWCLIPPER; +typedef struct IDirectDrawColorControl FAR *LPDIRECTDRAWCOLORCONTROL; +typedef struct IDirectDrawGammaControl FAR *LPDIRECTDRAWGAMMACONTROL; + +typedef struct _DDFXROP FAR *LPDDFXROP; +typedef struct _DDSURFACEDESC FAR *LPDDSURFACEDESC; +typedef struct _DDSURFACEDESC2 FAR *LPDDSURFACEDESC2; +typedef struct _DDCOLORCONTROL FAR *LPDDCOLORCONTROL; + +/* + * API's + */ +#if (defined (WIN32) || defined( _WIN32 ) ) && !defined( _NO_COM ) +//#if defined( _WIN32 ) && !defined( _NO_ENUM ) + typedef BOOL (FAR PASCAL * LPDDENUMCALLBACKA)(GUID FAR *, LPSTR, LPSTR, LPVOID); + typedef BOOL (FAR PASCAL * LPDDENUMCALLBACKW)(GUID FAR *, LPWSTR, LPWSTR, LPVOID); + extern HRESULT WINAPI DirectDrawEnumerateW( LPDDENUMCALLBACKW lpCallback, LPVOID lpContext ); + extern HRESULT WINAPI DirectDrawEnumerateA( LPDDENUMCALLBACKA lpCallback, LPVOID lpContext ); + /* + * Protect against old SDKs + */ + #if !defined(HMONITOR_DECLARED) && (WINVER < 0x0500) + #define HMONITOR_DECLARED + DECLARE_HANDLE(HMONITOR); + #endif + typedef BOOL (FAR PASCAL * LPDDENUMCALLBACKEXA)(GUID FAR *, LPSTR, LPSTR, LPVOID, HMONITOR); + typedef BOOL (FAR PASCAL * LPDDENUMCALLBACKEXW)(GUID FAR *, LPWSTR, LPWSTR, LPVOID, HMONITOR); + extern HRESULT WINAPI DirectDrawEnumerateExW( LPDDENUMCALLBACKEXW lpCallback, LPVOID lpContext, DWORD dwFlags); + extern HRESULT WINAPI DirectDrawEnumerateExA( LPDDENUMCALLBACKEXA lpCallback, LPVOID lpContext, DWORD dwFlags); + typedef HRESULT (WINAPI * LPDIRECTDRAWENUMERATEEXA)( LPDDENUMCALLBACKEXA lpCallback, LPVOID lpContext, DWORD dwFlags); + typedef HRESULT (WINAPI * LPDIRECTDRAWENUMERATEEXW)( LPDDENUMCALLBACKEXW lpCallback, LPVOID lpContext, DWORD dwFlags); + + #ifdef UNICODE + typedef LPDDENUMCALLBACKW LPDDENUMCALLBACK; + #define DirectDrawEnumerate DirectDrawEnumerateW + typedef LPDDENUMCALLBACKEXW LPDDENUMCALLBACKEX; + typedef LPDIRECTDRAWENUMERATEEXW LPDIRECTDRAWENUMERATEEX; + #define DirectDrawEnumerateEx DirectDrawEnumerateExW + #else + typedef LPDDENUMCALLBACKA LPDDENUMCALLBACK; + #define DirectDrawEnumerate DirectDrawEnumerateA + typedef LPDDENUMCALLBACKEXA LPDDENUMCALLBACKEX; + typedef LPDIRECTDRAWENUMERATEEXA LPDIRECTDRAWENUMERATEEX; + #define DirectDrawEnumerateEx DirectDrawEnumerateExA + #endif + extern HRESULT WINAPI DirectDrawCreate( GUID FAR *lpGUID, LPDIRECTDRAW FAR *lplpDD, IUnknown FAR *pUnkOuter ); + extern HRESULT WINAPI DirectDrawCreateEx( GUID FAR * lpGuid, LPVOID *lplpDD, REFIID iid,IUnknown FAR *pUnkOuter ); + extern HRESULT WINAPI DirectDrawCreateClipper( DWORD dwFlags, LPDIRECTDRAWCLIPPER FAR *lplpDDClipper, IUnknown FAR *pUnkOuter ); +#endif +/* + * Flags for DirectDrawEnumerateEx + * DirectDrawEnumerateEx supercedes DirectDrawEnumerate. You must use GetProcAddress to + * obtain a function pointer (of type LPDIRECTDRAWENUMERATEEX) to DirectDrawEnumerateEx. + * By default, only the primary display device is enumerated. + * DirectDrawEnumerate is equivalent to DirectDrawEnumerate(,,DDENUM_NONDISPLAYDEVICES) + */ + +/* + * This flag causes enumeration of any GDI display devices which are part of + * the Windows Desktop + */ +#define DDENUM_ATTACHEDSECONDARYDEVICES 0x00000001L + +/* + * This flag causes enumeration of any GDI display devices which are not + * part of the Windows Desktop + */ +#define DDENUM_DETACHEDSECONDARYDEVICES 0x00000002L + +/* + * This flag causes enumeration of non-display devices + */ +#define DDENUM_NONDISPLAYDEVICES 0x00000004L + + +#define REGSTR_KEY_DDHW_DESCRIPTION "Description" +#define REGSTR_KEY_DDHW_DRIVERNAME "DriverName" +#define REGSTR_PATH_DDHW "Hardware\\DirectDrawDrivers" + +#define DDCREATE_HARDWAREONLY 0x00000001l +#define DDCREATE_EMULATIONONLY 0x00000002l + +#ifdef _MSC_VER //look, just stop spitting out a pointless warning. it's annoying. +#if defined(WINNT) || !defined(WIN32) +typedef long HRESULT; +#endif +#endif + +//#ifndef WINNT +typedef HRESULT (FAR PASCAL * LPDDENUMMODESCALLBACK)(LPDDSURFACEDESC, LPVOID); +typedef HRESULT (FAR PASCAL * LPDDENUMMODESCALLBACK2)(LPDDSURFACEDESC2, LPVOID); +typedef HRESULT (FAR PASCAL * LPDDENUMSURFACESCALLBACK)(LPDIRECTDRAWSURFACE, LPDDSURFACEDESC, LPVOID); +typedef HRESULT (FAR PASCAL * LPDDENUMSURFACESCALLBACK2)(LPDIRECTDRAWSURFACE4, LPDDSURFACEDESC2, LPVOID); +typedef HRESULT (FAR PASCAL * LPDDENUMSURFACESCALLBACK7)(LPDIRECTDRAWSURFACE7, LPDDSURFACEDESC2, LPVOID); +//#endif + +/* + * Generic pixel format with 8-bit RGB and alpha components + */ +typedef struct _DDARGB +{ + BYTE blue; + BYTE green; + BYTE red; + BYTE alpha; +} DDARGB; + +typedef DDARGB FAR *LPDDARGB; + +/* + * This version of the structure remains for backwards source compatibility. + * The DDARGB structure is the one that should be used for all DirectDraw APIs. + */ +typedef struct _DDRGBA +{ + BYTE red; + BYTE green; + BYTE blue; + BYTE alpha; +} DDRGBA; + +typedef DDRGBA FAR *LPDDRGBA; + + +/* + * DDCOLORKEY + */ +typedef struct _DDCOLORKEY +{ + DWORD dwColorSpaceLowValue; // low boundary of color space that is to + // be treated as Color Key, inclusive + DWORD dwColorSpaceHighValue; // high boundary of color space that is + // to be treated as Color Key, inclusive +} DDCOLORKEY; + +typedef DDCOLORKEY FAR* LPDDCOLORKEY; + +/* + * DDBLTFX + * Used to pass override information to the DIRECTDRAWSURFACE callback Blt. + */ +typedef struct _DDBLTFX +{ + DWORD dwSize; // size of structure + DWORD dwDDFX; // FX operations + DWORD dwROP; // Win32 raster operations + DWORD dwDDROP; // Raster operations new for DirectDraw + DWORD dwRotationAngle; // Rotation angle for blt + DWORD dwZBufferOpCode; // ZBuffer compares + DWORD dwZBufferLow; // Low limit of Z buffer + DWORD dwZBufferHigh; // High limit of Z buffer + DWORD dwZBufferBaseDest; // Destination base value + DWORD dwZDestConstBitDepth; // Bit depth used to specify Z constant for destination + union + { + DWORD dwZDestConst; // Constant to use as Z buffer for dest + LPDIRECTDRAWSURFACE lpDDSZBufferDest; // Surface to use as Z buffer for dest + } DUMMYUNIONNAMEN(1); + DWORD dwZSrcConstBitDepth; // Bit depth used to specify Z constant for source + union + { + DWORD dwZSrcConst; // Constant to use as Z buffer for src + LPDIRECTDRAWSURFACE lpDDSZBufferSrc; // Surface to use as Z buffer for src + } DUMMYUNIONNAMEN(2); + DWORD dwAlphaEdgeBlendBitDepth; // Bit depth used to specify constant for alpha edge blend + DWORD dwAlphaEdgeBlend; // Alpha for edge blending + DWORD dwReserved; + DWORD dwAlphaDestConstBitDepth; // Bit depth used to specify alpha constant for destination + union + { + DWORD dwAlphaDestConst; // Constant to use as Alpha Channel + LPDIRECTDRAWSURFACE lpDDSAlphaDest; // Surface to use as Alpha Channel + } DUMMYUNIONNAMEN(3); + DWORD dwAlphaSrcConstBitDepth; // Bit depth used to specify alpha constant for source + union + { + DWORD dwAlphaSrcConst; // Constant to use as Alpha Channel + LPDIRECTDRAWSURFACE lpDDSAlphaSrc; // Surface to use as Alpha Channel + } DUMMYUNIONNAMEN(4); + union + { + DWORD dwFillColor; // color in RGB or Palettized + DWORD dwFillDepth; // depth value for z-buffer + DWORD dwFillPixel; // pixel value for RGBA or RGBZ + LPDIRECTDRAWSURFACE lpDDSPattern; // Surface to use as pattern + } DUMMYUNIONNAMEN(5); + DDCOLORKEY ddckDestColorkey; // DestColorkey override + DDCOLORKEY ddckSrcColorkey; // SrcColorkey override +} DDBLTFX; + +typedef DDBLTFX FAR* LPDDBLTFX; + + + +/* + * DDSCAPS + */ +typedef struct _DDSCAPS +{ + DWORD dwCaps; // capabilities of surface wanted +} DDSCAPS; + +typedef DDSCAPS FAR* LPDDSCAPS; + + +/* + * DDOSCAPS + */ +typedef struct _DDOSCAPS +{ + DWORD dwCaps; // capabilities of surface wanted +} DDOSCAPS; + +typedef DDOSCAPS FAR* LPDDOSCAPS; + +/* + * This structure is used internally by DirectDraw. + */ +typedef struct _DDSCAPSEX +{ + DWORD dwCaps2; + DWORD dwCaps3; + DWORD dwCaps4; +} DDSCAPSEX, FAR * LPDDSCAPSEX; + +/* + * DDSCAPS2 + */ +typedef struct _DDSCAPS2 +{ + DWORD dwCaps; // capabilities of surface wanted + DWORD dwCaps2; + DWORD dwCaps3; + DWORD dwCaps4; +} DDSCAPS2; + +typedef DDSCAPS2 FAR* LPDDSCAPS2; + +/* + * DDCAPS + */ +#define DD_ROP_SPACE (256/32) // space required to store ROP array +/* + * NOTE: Our choosen structure number scheme is to append a single digit to + * the end of the structure giving the version that structure is associated + * with. + */ + +/* + * This structure represents the DDCAPS structure released in DirectDraw 1.0. It is used internally + * by DirectDraw to interpret caps passed into ddraw by drivers written prior to the release of DirectDraw 2.0. + * New applications should use the DDCAPS structure defined below. + */ +typedef struct _DDCAPS_DX1 +{ + DWORD dwSize; // size of the DDDRIVERCAPS structure + DWORD dwCaps; // driver specific capabilities + DWORD dwCaps2; // more driver specific capabilites + DWORD dwCKeyCaps; // color key capabilities of the surface + DWORD dwFXCaps; // driver specific stretching and effects capabilites + DWORD dwFXAlphaCaps; // alpha driver specific capabilities + DWORD dwPalCaps; // palette capabilities + DWORD dwSVCaps; // stereo vision capabilities + DWORD dwAlphaBltConstBitDepths; // DDBD_2,4,8 + DWORD dwAlphaBltPixelBitDepths; // DDBD_1,2,4,8 + DWORD dwAlphaBltSurfaceBitDepths; // DDBD_1,2,4,8 + DWORD dwAlphaOverlayConstBitDepths; // DDBD_2,4,8 + DWORD dwAlphaOverlayPixelBitDepths; // DDBD_1,2,4,8 + DWORD dwAlphaOverlaySurfaceBitDepths; // DDBD_1,2,4,8 + DWORD dwZBufferBitDepths; // DDBD_8,16,24,32 + DWORD dwVidMemTotal; // total amount of video memory + DWORD dwVidMemFree; // amount of free video memory + DWORD dwMaxVisibleOverlays; // maximum number of visible overlays + DWORD dwCurrVisibleOverlays; // current number of visible overlays + DWORD dwNumFourCCCodes; // number of four cc codes + DWORD dwAlignBoundarySrc; // source rectangle alignment + DWORD dwAlignSizeSrc; // source rectangle byte size + DWORD dwAlignBoundaryDest; // dest rectangle alignment + DWORD dwAlignSizeDest; // dest rectangle byte size + DWORD dwAlignStrideAlign; // stride alignment + DWORD dwRops[DD_ROP_SPACE]; // ROPS supported + DDSCAPS ddsCaps; // DDSCAPS structure has all the general capabilities + DWORD dwMinOverlayStretch; // minimum overlay stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 + DWORD dwMaxOverlayStretch; // maximum overlay stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 + DWORD dwMinLiveVideoStretch; // OBSOLETE! This field remains for compatability reasons only + DWORD dwMaxLiveVideoStretch; // OBSOLETE! This field remains for compatability reasons only + DWORD dwMinHwCodecStretch; // OBSOLETE! This field remains for compatability reasons only + DWORD dwMaxHwCodecStretch; // OBSOLETE! This field remains for compatability reasons only + DWORD dwReserved1; // reserved + DWORD dwReserved2; // reserved + DWORD dwReserved3; // reserved +} DDCAPS_DX1; + +typedef DDCAPS_DX1 FAR* LPDDCAPS_DX1; + +/* + * This structure is the DDCAPS structure as it was in version 2 and 3 of Direct X. + * It is present for back compatability. + */ +typedef struct _DDCAPS_DX3 +{ + DWORD dwSize; // size of the DDDRIVERCAPS structure + DWORD dwCaps; // driver specific capabilities + DWORD dwCaps2; // more driver specific capabilites + DWORD dwCKeyCaps; // color key capabilities of the surface + DWORD dwFXCaps; // driver specific stretching and effects capabilites + DWORD dwFXAlphaCaps; // alpha driver specific capabilities + DWORD dwPalCaps; // palette capabilities + DWORD dwSVCaps; // stereo vision capabilities + DWORD dwAlphaBltConstBitDepths; // DDBD_2,4,8 + DWORD dwAlphaBltPixelBitDepths; // DDBD_1,2,4,8 + DWORD dwAlphaBltSurfaceBitDepths; // DDBD_1,2,4,8 + DWORD dwAlphaOverlayConstBitDepths; // DDBD_2,4,8 + DWORD dwAlphaOverlayPixelBitDepths; // DDBD_1,2,4,8 + DWORD dwAlphaOverlaySurfaceBitDepths; // DDBD_1,2,4,8 + DWORD dwZBufferBitDepths; // DDBD_8,16,24,32 + DWORD dwVidMemTotal; // total amount of video memory + DWORD dwVidMemFree; // amount of free video memory + DWORD dwMaxVisibleOverlays; // maximum number of visible overlays + DWORD dwCurrVisibleOverlays; // current number of visible overlays + DWORD dwNumFourCCCodes; // number of four cc codes + DWORD dwAlignBoundarySrc; // source rectangle alignment + DWORD dwAlignSizeSrc; // source rectangle byte size + DWORD dwAlignBoundaryDest; // dest rectangle alignment + DWORD dwAlignSizeDest; // dest rectangle byte size + DWORD dwAlignStrideAlign; // stride alignment + DWORD dwRops[DD_ROP_SPACE]; // ROPS supported + DDSCAPS ddsCaps; // DDSCAPS structure has all the general capabilities + DWORD dwMinOverlayStretch; // minimum overlay stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 + DWORD dwMaxOverlayStretch; // maximum overlay stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 + DWORD dwMinLiveVideoStretch; // minimum live video stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 + DWORD dwMaxLiveVideoStretch; // maximum live video stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 + DWORD dwMinHwCodecStretch; // minimum hardware codec stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 + DWORD dwMaxHwCodecStretch; // maximum hardware codec stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 + DWORD dwReserved1; // reserved + DWORD dwReserved2; // reserved + DWORD dwReserved3; // reserved + DWORD dwSVBCaps; // driver specific capabilities for System->Vmem blts + DWORD dwSVBCKeyCaps; // driver color key capabilities for System->Vmem blts + DWORD dwSVBFXCaps; // driver FX capabilities for System->Vmem blts + DWORD dwSVBRops[DD_ROP_SPACE];// ROPS supported for System->Vmem blts + DWORD dwVSBCaps; // driver specific capabilities for Vmem->System blts + DWORD dwVSBCKeyCaps; // driver color key capabilities for Vmem->System blts + DWORD dwVSBFXCaps; // driver FX capabilities for Vmem->System blts + DWORD dwVSBRops[DD_ROP_SPACE];// ROPS supported for Vmem->System blts + DWORD dwSSBCaps; // driver specific capabilities for System->System blts + DWORD dwSSBCKeyCaps; // driver color key capabilities for System->System blts + DWORD dwSSBFXCaps; // driver FX capabilities for System->System blts + DWORD dwSSBRops[DD_ROP_SPACE];// ROPS supported for System->System blts + DWORD dwReserved4; // reserved + DWORD dwReserved5; // reserved + DWORD dwReserved6; // reserved +} DDCAPS_DX3; +typedef DDCAPS_DX3 FAR* LPDDCAPS_DX3; + +/* + * This structure is the DDCAPS structure as it was in version 5 of Direct X. + * It is present for back compatability. + */ +typedef struct _DDCAPS_DX5 +{ +/* 0*/ DWORD dwSize; // size of the DDDRIVERCAPS structure +/* 4*/ DWORD dwCaps; // driver specific capabilities +/* 8*/ DWORD dwCaps2; // more driver specific capabilites +/* c*/ DWORD dwCKeyCaps; // color key capabilities of the surface +/* 10*/ DWORD dwFXCaps; // driver specific stretching and effects capabilites +/* 14*/ DWORD dwFXAlphaCaps; // alpha driver specific capabilities +/* 18*/ DWORD dwPalCaps; // palette capabilities +/* 1c*/ DWORD dwSVCaps; // stereo vision capabilities +/* 20*/ DWORD dwAlphaBltConstBitDepths; // DDBD_2,4,8 +/* 24*/ DWORD dwAlphaBltPixelBitDepths; // DDBD_1,2,4,8 +/* 28*/ DWORD dwAlphaBltSurfaceBitDepths; // DDBD_1,2,4,8 +/* 2c*/ DWORD dwAlphaOverlayConstBitDepths; // DDBD_2,4,8 +/* 30*/ DWORD dwAlphaOverlayPixelBitDepths; // DDBD_1,2,4,8 +/* 34*/ DWORD dwAlphaOverlaySurfaceBitDepths; // DDBD_1,2,4,8 +/* 38*/ DWORD dwZBufferBitDepths; // DDBD_8,16,24,32 +/* 3c*/ DWORD dwVidMemTotal; // total amount of video memory +/* 40*/ DWORD dwVidMemFree; // amount of free video memory +/* 44*/ DWORD dwMaxVisibleOverlays; // maximum number of visible overlays +/* 48*/ DWORD dwCurrVisibleOverlays; // current number of visible overlays +/* 4c*/ DWORD dwNumFourCCCodes; // number of four cc codes +/* 50*/ DWORD dwAlignBoundarySrc; // source rectangle alignment +/* 54*/ DWORD dwAlignSizeSrc; // source rectangle byte size +/* 58*/ DWORD dwAlignBoundaryDest; // dest rectangle alignment +/* 5c*/ DWORD dwAlignSizeDest; // dest rectangle byte size +/* 60*/ DWORD dwAlignStrideAlign; // stride alignment +/* 64*/ DWORD dwRops[DD_ROP_SPACE]; // ROPS supported +/* 84*/ DDSCAPS ddsCaps; // DDSCAPS structure has all the general capabilities +/* 88*/ DWORD dwMinOverlayStretch; // minimum overlay stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 +/* 8c*/ DWORD dwMaxOverlayStretch; // maximum overlay stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 +/* 90*/ DWORD dwMinLiveVideoStretch; // minimum live video stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 +/* 94*/ DWORD dwMaxLiveVideoStretch; // maximum live video stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 +/* 98*/ DWORD dwMinHwCodecStretch; // minimum hardware codec stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 +/* 9c*/ DWORD dwMaxHwCodecStretch; // maximum hardware codec stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 +/* a0*/ DWORD dwReserved1; // reserved +/* a4*/ DWORD dwReserved2; // reserved +/* a8*/ DWORD dwReserved3; // reserved +/* ac*/ DWORD dwSVBCaps; // driver specific capabilities for System->Vmem blts +/* b0*/ DWORD dwSVBCKeyCaps; // driver color key capabilities for System->Vmem blts +/* b4*/ DWORD dwSVBFXCaps; // driver FX capabilities for System->Vmem blts +/* b8*/ DWORD dwSVBRops[DD_ROP_SPACE];// ROPS supported for System->Vmem blts +/* d8*/ DWORD dwVSBCaps; // driver specific capabilities for Vmem->System blts +/* dc*/ DWORD dwVSBCKeyCaps; // driver color key capabilities for Vmem->System blts +/* e0*/ DWORD dwVSBFXCaps; // driver FX capabilities for Vmem->System blts +/* e4*/ DWORD dwVSBRops[DD_ROP_SPACE];// ROPS supported for Vmem->System blts +/*104*/ DWORD dwSSBCaps; // driver specific capabilities for System->System blts +/*108*/ DWORD dwSSBCKeyCaps; // driver color key capabilities for System->System blts +/*10c*/ DWORD dwSSBFXCaps; // driver FX capabilities for System->System blts +/*110*/ DWORD dwSSBRops[DD_ROP_SPACE];// ROPS supported for System->System blts +// Members added for DX5: +/*130*/ DWORD dwMaxVideoPorts; // maximum number of usable video ports +/*134*/ DWORD dwCurrVideoPorts; // current number of video ports used +/*138*/ DWORD dwSVBCaps2; // more driver specific capabilities for System->Vmem blts +/*13c*/ DWORD dwNLVBCaps; // driver specific capabilities for non-local->local vidmem blts +/*140*/ DWORD dwNLVBCaps2; // more driver specific capabilities non-local->local vidmem blts +/*144*/ DWORD dwNLVBCKeyCaps; // driver color key capabilities for non-local->local vidmem blts +/*148*/ DWORD dwNLVBFXCaps; // driver FX capabilities for non-local->local blts +/*14c*/ DWORD dwNLVBRops[DD_ROP_SPACE]; // ROPS supported for non-local->local blts +} DDCAPS_DX5; +typedef DDCAPS_DX5 FAR* LPDDCAPS_DX5; + +typedef struct _DDCAPS_DX6 +{ +/* 0*/ DWORD dwSize; // size of the DDDRIVERCAPS structure +/* 4*/ DWORD dwCaps; // driver specific capabilities +/* 8*/ DWORD dwCaps2; // more driver specific capabilites +/* c*/ DWORD dwCKeyCaps; // color key capabilities of the surface +/* 10*/ DWORD dwFXCaps; // driver specific stretching and effects capabilites +/* 14*/ DWORD dwFXAlphaCaps; // alpha caps +/* 18*/ DWORD dwPalCaps; // palette capabilities +/* 1c*/ DWORD dwSVCaps; // stereo vision capabilities +/* 20*/ DWORD dwAlphaBltConstBitDepths; // DDBD_2,4,8 +/* 24*/ DWORD dwAlphaBltPixelBitDepths; // DDBD_1,2,4,8 +/* 28*/ DWORD dwAlphaBltSurfaceBitDepths; // DDBD_1,2,4,8 +/* 2c*/ DWORD dwAlphaOverlayConstBitDepths; // DDBD_2,4,8 +/* 30*/ DWORD dwAlphaOverlayPixelBitDepths; // DDBD_1,2,4,8 +/* 34*/ DWORD dwAlphaOverlaySurfaceBitDepths; // DDBD_1,2,4,8 +/* 38*/ DWORD dwZBufferBitDepths; // DDBD_8,16,24,32 +/* 3c*/ DWORD dwVidMemTotal; // total amount of video memory +/* 40*/ DWORD dwVidMemFree; // amount of free video memory +/* 44*/ DWORD dwMaxVisibleOverlays; // maximum number of visible overlays +/* 48*/ DWORD dwCurrVisibleOverlays; // current number of visible overlays +/* 4c*/ DWORD dwNumFourCCCodes; // number of four cc codes +/* 50*/ DWORD dwAlignBoundarySrc; // source rectangle alignment +/* 54*/ DWORD dwAlignSizeSrc; // source rectangle byte size +/* 58*/ DWORD dwAlignBoundaryDest; // dest rectangle alignment +/* 5c*/ DWORD dwAlignSizeDest; // dest rectangle byte size +/* 60*/ DWORD dwAlignStrideAlign; // stride alignment +/* 64*/ DWORD dwRops[DD_ROP_SPACE]; // ROPS supported +/* 84*/ DDSCAPS ddsOldCaps; // Was DDSCAPS ddsCaps. ddsCaps is of type DDSCAPS2 for DX6 +/* 88*/ DWORD dwMinOverlayStretch; // minimum overlay stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 +/* 8c*/ DWORD dwMaxOverlayStretch; // maximum overlay stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 +/* 90*/ DWORD dwMinLiveVideoStretch; // minimum live video stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 +/* 94*/ DWORD dwMaxLiveVideoStretch; // maximum live video stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 +/* 98*/ DWORD dwMinHwCodecStretch; // minimum hardware codec stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 +/* 9c*/ DWORD dwMaxHwCodecStretch; // maximum hardware codec stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 +/* a0*/ DWORD dwReserved1; // reserved +/* a4*/ DWORD dwReserved2; // reserved +/* a8*/ DWORD dwReserved3; // reserved +/* ac*/ DWORD dwSVBCaps; // driver specific capabilities for System->Vmem blts +/* b0*/ DWORD dwSVBCKeyCaps; // driver color key capabilities for System->Vmem blts +/* b4*/ DWORD dwSVBFXCaps; // driver FX capabilities for System->Vmem blts +/* b8*/ DWORD dwSVBRops[DD_ROP_SPACE];// ROPS supported for System->Vmem blts +/* d8*/ DWORD dwVSBCaps; // driver specific capabilities for Vmem->System blts +/* dc*/ DWORD dwVSBCKeyCaps; // driver color key capabilities for Vmem->System blts +/* e0*/ DWORD dwVSBFXCaps; // driver FX capabilities for Vmem->System blts +/* e4*/ DWORD dwVSBRops[DD_ROP_SPACE];// ROPS supported for Vmem->System blts +/*104*/ DWORD dwSSBCaps; // driver specific capabilities for System->System blts +/*108*/ DWORD dwSSBCKeyCaps; // driver color key capabilities for System->System blts +/*10c*/ DWORD dwSSBFXCaps; // driver FX capabilities for System->System blts +/*110*/ DWORD dwSSBRops[DD_ROP_SPACE];// ROPS supported for System->System blts +/*130*/ DWORD dwMaxVideoPorts; // maximum number of usable video ports +/*134*/ DWORD dwCurrVideoPorts; // current number of video ports used +/*138*/ DWORD dwSVBCaps2; // more driver specific capabilities for System->Vmem blts +/*13c*/ DWORD dwNLVBCaps; // driver specific capabilities for non-local->local vidmem blts +/*140*/ DWORD dwNLVBCaps2; // more driver specific capabilities non-local->local vidmem blts +/*144*/ DWORD dwNLVBCKeyCaps; // driver color key capabilities for non-local->local vidmem blts +/*148*/ DWORD dwNLVBFXCaps; // driver FX capabilities for non-local->local blts +/*14c*/ DWORD dwNLVBRops[DD_ROP_SPACE]; // ROPS supported for non-local->local blts +// Members added for DX6 release +/*16c*/ DDSCAPS2 ddsCaps; // Surface Caps +} DDCAPS_DX6; +typedef DDCAPS_DX6 FAR* LPDDCAPS_DX6; + +typedef struct _DDCAPS_DX7 +{ +/* 0*/ DWORD dwSize; // size of the DDDRIVERCAPS structure +/* 4*/ DWORD dwCaps; // driver specific capabilities +/* 8*/ DWORD dwCaps2; // more driver specific capabilites +/* c*/ DWORD dwCKeyCaps; // color key capabilities of the surface +/* 10*/ DWORD dwFXCaps; // driver specific stretching and effects capabilites +/* 14*/ DWORD dwFXAlphaCaps; // alpha driver specific capabilities +/* 18*/ DWORD dwPalCaps; // palette capabilities +/* 1c*/ DWORD dwSVCaps; // stereo vision capabilities +/* 20*/ DWORD dwAlphaBltConstBitDepths; // DDBD_2,4,8 +/* 24*/ DWORD dwAlphaBltPixelBitDepths; // DDBD_1,2,4,8 +/* 28*/ DWORD dwAlphaBltSurfaceBitDepths; // DDBD_1,2,4,8 +/* 2c*/ DWORD dwAlphaOverlayConstBitDepths; // DDBD_2,4,8 +/* 30*/ DWORD dwAlphaOverlayPixelBitDepths; // DDBD_1,2,4,8 +/* 34*/ DWORD dwAlphaOverlaySurfaceBitDepths; // DDBD_1,2,4,8 +/* 38*/ DWORD dwZBufferBitDepths; // DDBD_8,16,24,32 +/* 3c*/ DWORD dwVidMemTotal; // total amount of video memory +/* 40*/ DWORD dwVidMemFree; // amount of free video memory +/* 44*/ DWORD dwMaxVisibleOverlays; // maximum number of visible overlays +/* 48*/ DWORD dwCurrVisibleOverlays; // current number of visible overlays +/* 4c*/ DWORD dwNumFourCCCodes; // number of four cc codes +/* 50*/ DWORD dwAlignBoundarySrc; // source rectangle alignment +/* 54*/ DWORD dwAlignSizeSrc; // source rectangle byte size +/* 58*/ DWORD dwAlignBoundaryDest; // dest rectangle alignment +/* 5c*/ DWORD dwAlignSizeDest; // dest rectangle byte size +/* 60*/ DWORD dwAlignStrideAlign; // stride alignment +/* 64*/ DWORD dwRops[DD_ROP_SPACE]; // ROPS supported +/* 84*/ DDSCAPS ddsOldCaps; // Was DDSCAPS ddsCaps. ddsCaps is of type DDSCAPS2 for DX6 +/* 88*/ DWORD dwMinOverlayStretch; // minimum overlay stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 +/* 8c*/ DWORD dwMaxOverlayStretch; // maximum overlay stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 +/* 90*/ DWORD dwMinLiveVideoStretch; // minimum live video stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 +/* 94*/ DWORD dwMaxLiveVideoStretch; // maximum live video stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 +/* 98*/ DWORD dwMinHwCodecStretch; // minimum hardware codec stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 +/* 9c*/ DWORD dwMaxHwCodecStretch; // maximum hardware codec stretch factor multiplied by 1000, eg 1000 == 1.0, 1300 == 1.3 +/* a0*/ DWORD dwReserved1; // reserved +/* a4*/ DWORD dwReserved2; // reserved +/* a8*/ DWORD dwReserved3; // reserved +/* ac*/ DWORD dwSVBCaps; // driver specific capabilities for System->Vmem blts +/* b0*/ DWORD dwSVBCKeyCaps; // driver color key capabilities for System->Vmem blts +/* b4*/ DWORD dwSVBFXCaps; // driver FX capabilities for System->Vmem blts +/* b8*/ DWORD dwSVBRops[DD_ROP_SPACE];// ROPS supported for System->Vmem blts +/* d8*/ DWORD dwVSBCaps; // driver specific capabilities for Vmem->System blts +/* dc*/ DWORD dwVSBCKeyCaps; // driver color key capabilities for Vmem->System blts +/* e0*/ DWORD dwVSBFXCaps; // driver FX capabilities for Vmem->System blts +/* e4*/ DWORD dwVSBRops[DD_ROP_SPACE];// ROPS supported for Vmem->System blts +/*104*/ DWORD dwSSBCaps; // driver specific capabilities for System->System blts +/*108*/ DWORD dwSSBCKeyCaps; // driver color key capabilities for System->System blts +/*10c*/ DWORD dwSSBFXCaps; // driver FX capabilities for System->System blts +/*110*/ DWORD dwSSBRops[DD_ROP_SPACE];// ROPS supported for System->System blts +/*130*/ DWORD dwMaxVideoPorts; // maximum number of usable video ports +/*134*/ DWORD dwCurrVideoPorts; // current number of video ports used +/*138*/ DWORD dwSVBCaps2; // more driver specific capabilities for System->Vmem blts +/*13c*/ DWORD dwNLVBCaps; // driver specific capabilities for non-local->local vidmem blts +/*140*/ DWORD dwNLVBCaps2; // more driver specific capabilities non-local->local vidmem blts +/*144*/ DWORD dwNLVBCKeyCaps; // driver color key capabilities for non-local->local vidmem blts +/*148*/ DWORD dwNLVBFXCaps; // driver FX capabilities for non-local->local blts +/*14c*/ DWORD dwNLVBRops[DD_ROP_SPACE]; // ROPS supported for non-local->local blts +// Members added for DX6 release +/*16c*/ DDSCAPS2 ddsCaps; // Surface Caps +} DDCAPS_DX7; +typedef DDCAPS_DX7 FAR* LPDDCAPS_DX7; + + +#if DIRECTDRAW_VERSION <= 0x300 + typedef DDCAPS_DX3 DDCAPS; +#elif DIRECTDRAW_VERSION <= 0x500 + typedef DDCAPS_DX5 DDCAPS; +#elif DIRECTDRAW_VERSION <= 0x600 + typedef DDCAPS_DX6 DDCAPS; +#else + typedef DDCAPS_DX7 DDCAPS; +#endif + +typedef DDCAPS FAR* LPDDCAPS; + + + +/* + * DDPIXELFORMAT + */ +typedef struct _DDPIXELFORMAT +{ + DWORD dwSize; // size of structure + DWORD dwFlags; // pixel format flags + DWORD dwFourCC; // (FOURCC code) + union + { + DWORD dwRGBBitCount; // how many bits per pixel + DWORD dwYUVBitCount; // how many bits per pixel + DWORD dwZBufferBitDepth; // how many total bits/pixel in z buffer (including any stencil bits) + DWORD dwAlphaBitDepth; // how many bits for alpha channels + DWORD dwLuminanceBitCount; // how many bits per pixel + DWORD dwBumpBitCount; // how many bits per "buxel", total + } DUMMYUNIONNAMEN(1); + union + { + DWORD dwRBitMask; // mask for red bit + DWORD dwYBitMask; // mask for Y bits + DWORD dwStencilBitDepth; // how many stencil bits (note: dwZBufferBitDepth-dwStencilBitDepth is total Z-only bits) + DWORD dwLuminanceBitMask; // mask for luminance bits + DWORD dwBumpDuBitMask; // mask for bump map U delta bits + } DUMMYUNIONNAMEN(2); + union + { + DWORD dwGBitMask; // mask for green bits + DWORD dwUBitMask; // mask for U bits + DWORD dwZBitMask; // mask for Z bits + DWORD dwBumpDvBitMask; // mask for bump map V delta bits + } DUMMYUNIONNAMEN(3); + union + { + DWORD dwBBitMask; // mask for blue bits + DWORD dwVBitMask; // mask for V bits + DWORD dwStencilBitMask; // mask for stencil bits + DWORD dwBumpLuminanceBitMask; // mask for luminance in bump map + } DUMMYUNIONNAMEN(4); + union + { + DWORD dwRGBAlphaBitMask; // mask for alpha channel + DWORD dwYUVAlphaBitMask; // mask for alpha channel + DWORD dwLuminanceAlphaBitMask;// mask for alpha channel + DWORD dwRGBZBitMask; // mask for Z channel + DWORD dwYUVZBitMask; // mask for Z channel + } DUMMYUNIONNAMEN(5); +} DDPIXELFORMAT; + +typedef DDPIXELFORMAT FAR* LPDDPIXELFORMAT; + +/* + * DDOVERLAYFX + */ +typedef struct _DDOVERLAYFX +{ + DWORD dwSize; // size of structure + DWORD dwAlphaEdgeBlendBitDepth; // Bit depth used to specify constant for alpha edge blend + DWORD dwAlphaEdgeBlend; // Constant to use as alpha for edge blend + DWORD dwReserved; + DWORD dwAlphaDestConstBitDepth; // Bit depth used to specify alpha constant for destination + union + { + DWORD dwAlphaDestConst; // Constant to use as alpha channel for dest + LPDIRECTDRAWSURFACE lpDDSAlphaDest; // Surface to use as alpha channel for dest + } DUMMYUNIONNAMEN(1); + DWORD dwAlphaSrcConstBitDepth; // Bit depth used to specify alpha constant for source + union + { + DWORD dwAlphaSrcConst; // Constant to use as alpha channel for src + LPDIRECTDRAWSURFACE lpDDSAlphaSrc; // Surface to use as alpha channel for src + } DUMMYUNIONNAMEN(2); + DDCOLORKEY dckDestColorkey; // DestColorkey override + DDCOLORKEY dckSrcColorkey; // DestColorkey override + DWORD dwDDFX; // Overlay FX + DWORD dwFlags; // flags +} DDOVERLAYFX; + +typedef DDOVERLAYFX FAR *LPDDOVERLAYFX; + + +/* + * DDBLTBATCH: BltBatch entry structure + */ +typedef struct _DDBLTBATCH +{ + LPRECT lprDest; + LPDIRECTDRAWSURFACE lpDDSSrc; + LPRECT lprSrc; + DWORD dwFlags; + LPDDBLTFX lpDDBltFx; +} DDBLTBATCH; + +typedef DDBLTBATCH FAR * LPDDBLTBATCH; + + +/* + * DDGAMMARAMP + */ +typedef struct _DDGAMMARAMP +{ + WORD red[256]; + WORD green[256]; + WORD blue[256]; +} DDGAMMARAMP; +typedef DDGAMMARAMP FAR * LPDDGAMMARAMP; + +/* + * This is the structure within which DirectDraw returns data about the current graphics driver and chipset + */ + +#define MAX_DDDEVICEID_STRING 512 + +typedef struct tagDDDEVICEIDENTIFIER +{ + /* + * These elements are for presentation to the user only. They should not be used to identify particular + * drivers, since this is unreliable and many different strings may be associated with the same + * device, and the same driver from different vendors. + */ + char szDriver[MAX_DDDEVICEID_STRING]; + char szDescription[MAX_DDDEVICEID_STRING]; + + /* + * This element is the version of the DirectDraw/3D driver. It is legal to do <, > comparisons + * on the whole 64 bits. Caution should be exercised if you use this element to identify problematic + * drivers. It is recommended that guidDeviceIdentifier is used for this purpose. + * + * This version has the form: + * wProduct = HIWORD(liDriverVersion.HighPart) + * wVersion = LOWORD(liDriverVersion.HighPart) + * wSubVersion = HIWORD(liDriverVersion.LowPart) + * wBuild = LOWORD(liDriverVersion.LowPart) + */ +#ifdef _WIN32 + LARGE_INTEGER liDriverVersion; /* Defined for applications and other 32 bit components */ +#else + DWORD dwDriverVersionLowPart; /* Defined for 16 bit driver components */ + DWORD dwDriverVersionHighPart; +#endif + + + /* + * These elements can be used to identify particular chipsets. Use with extreme caution. + * dwVendorId Identifies the manufacturer. May be zero if unknown. + * dwDeviceId Identifies the type of chipset. May be zero if unknown. + * dwSubSysId Identifies the subsystem, typically this means the particular board. May be zero if unknown. + * dwRevision Identifies the revision level of the chipset. May be zero if unknown. + */ + DWORD dwVendorId; + DWORD dwDeviceId; + DWORD dwSubSysId; + DWORD dwRevision; + + /* + * This element can be used to check changes in driver/chipset. This GUID is a unique identifier for the + * driver/chipset pair. Use this element if you wish to track changes to the driver/chipset in order to + * reprofile the graphics subsystem. + * This element can also be used to identify particular problematic drivers. + */ + GUID guidDeviceIdentifier; +} DDDEVICEIDENTIFIER, * LPDDDEVICEIDENTIFIER; + +typedef struct tagDDDEVICEIDENTIFIER2 +{ + /* + * These elements are for presentation to the user only. They should not be used to identify particular + * drivers, since this is unreliable and many different strings may be associated with the same + * device, and the same driver from different vendors. + */ + char szDriver[MAX_DDDEVICEID_STRING]; + char szDescription[MAX_DDDEVICEID_STRING]; + + /* + * This element is the version of the DirectDraw/3D driver. It is legal to do <, > comparisons + * on the whole 64 bits. Caution should be exercised if you use this element to identify problematic + * drivers. It is recommended that guidDeviceIdentifier is used for this purpose. + * + * This version has the form: + * wProduct = HIWORD(liDriverVersion.HighPart) + * wVersion = LOWORD(liDriverVersion.HighPart) + * wSubVersion = HIWORD(liDriverVersion.LowPart) + * wBuild = LOWORD(liDriverVersion.LowPart) + */ +#ifdef _WIN32 + LARGE_INTEGER liDriverVersion; /* Defined for applications and other 32 bit components */ +#else + DWORD dwDriverVersionLowPart; /* Defined for 16 bit driver components */ + DWORD dwDriverVersionHighPart; +#endif + + + /* + * These elements can be used to identify particular chipsets. Use with extreme caution. + * dwVendorId Identifies the manufacturer. May be zero if unknown. + * dwDeviceId Identifies the type of chipset. May be zero if unknown. + * dwSubSysId Identifies the subsystem, typically this means the particular board. May be zero if unknown. + * dwRevision Identifies the revision level of the chipset. May be zero if unknown. + */ + DWORD dwVendorId; + DWORD dwDeviceId; + DWORD dwSubSysId; + DWORD dwRevision; + + /* + * This element can be used to check changes in driver/chipset. This GUID is a unique identifier for the + * driver/chipset pair. Use this element if you wish to track changes to the driver/chipset in order to + * reprofile the graphics subsystem. + * This element can also be used to identify particular problematic drivers. + */ + GUID guidDeviceIdentifier; + + /* + * This element is used to determine the Windows Hardware Quality Lab (WHQL) + * certification level for this driver/device pair. + */ + DWORD dwWHQLLevel; + +} DDDEVICEIDENTIFIER2, * LPDDDEVICEIDENTIFIER2; + +/* + * Flags for the IDirectDraw4::GetDeviceIdentifier method + */ + +/* + * This flag causes GetDeviceIdentifier to return information about the host (typically 2D) adapter in a system equipped + * with a stacked secondary 3D adapter. Such an adapter appears to the application as if it were part of the + * host adapter, but is typically physcially located on a separate card. The stacked secondary's information is + * returned when GetDeviceIdentifier's dwFlags field is zero, since this most accurately reflects the qualities + * of the DirectDraw object involved. + */ +#define DDGDI_GETHOSTIDENTIFIER 0x00000001L + +/* + * Macros for interpretting DDEVICEIDENTIFIER2.dwWHQLLevel + */ +#define GET_WHQL_YEAR( dwWHQLLevel ) \ + ( (dwWHQLLevel) / 0x10000 ) +#define GET_WHQL_MONTH( dwWHQLLevel ) \ + ( ( (dwWHQLLevel) / 0x100 ) & 0x00ff ) +#define GET_WHQL_DAY( dwWHQLLevel ) \ + ( (dwWHQLLevel) & 0xff ) + + +/* + * callbacks + */ +typedef DWORD (FAR PASCAL *LPCLIPPERCALLBACK)(LPDIRECTDRAWCLIPPER lpDDClipper, HWND hWnd, DWORD code, LPVOID lpContext ); +#ifdef STREAMING +typedef DWORD (FAR PASCAL *LPSURFACESTREAMINGCALLBACK)(DWORD); +#endif + + +/* + * INTERACES FOLLOW: + * IDirectDraw + * IDirectDrawClipper + * IDirectDrawPalette + * IDirectDrawSurface + */ + +/* + * IDirectDraw + */ +#if defined( _WIN32 ) && !defined( _NO_COM ) +#undef INTERFACE +#define INTERFACE IDirectDraw +DECLARE_INTERFACE_( IDirectDraw, IUnknown ) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + /*** IDirectDraw methods ***/ + STDMETHOD(Compact)(THIS) PURE; + STDMETHOD(CreateClipper)(THIS_ DWORD, LPDIRECTDRAWCLIPPER FAR*, IUnknown FAR * ) PURE; + STDMETHOD(CreatePalette)(THIS_ DWORD, LPPALETTEENTRY, LPDIRECTDRAWPALETTE FAR*, IUnknown FAR * ) PURE; + STDMETHOD(CreateSurface)(THIS_ LPDDSURFACEDESC, LPDIRECTDRAWSURFACE FAR *, IUnknown FAR *) PURE; + STDMETHOD(DuplicateSurface)( THIS_ LPDIRECTDRAWSURFACE, LPDIRECTDRAWSURFACE FAR * ) PURE; + STDMETHOD(EnumDisplayModes)( THIS_ DWORD, LPDDSURFACEDESC, LPVOID, LPDDENUMMODESCALLBACK ) PURE; + STDMETHOD(EnumSurfaces)(THIS_ DWORD, LPDDSURFACEDESC, LPVOID,LPDDENUMSURFACESCALLBACK ) PURE; + STDMETHOD(FlipToGDISurface)(THIS) PURE; + STDMETHOD(GetCaps)( THIS_ LPDDCAPS, LPDDCAPS) PURE; + STDMETHOD(GetDisplayMode)( THIS_ LPDDSURFACEDESC) PURE; + STDMETHOD(GetFourCCCodes)(THIS_ LPDWORD, LPDWORD ) PURE; + STDMETHOD(GetGDISurface)(THIS_ LPDIRECTDRAWSURFACE FAR *) PURE; + STDMETHOD(GetMonitorFrequency)(THIS_ LPDWORD) PURE; + STDMETHOD(GetScanLine)(THIS_ LPDWORD) PURE; + STDMETHOD(GetVerticalBlankStatus)(THIS_ LPBOOL ) PURE; + STDMETHOD(Initialize)(THIS_ GUID FAR *) PURE; + STDMETHOD(RestoreDisplayMode)(THIS) PURE; + STDMETHOD(SetCooperativeLevel)(THIS_ HWND, DWORD) PURE; + STDMETHOD(SetDisplayMode)(THIS_ DWORD, DWORD,DWORD) PURE; + STDMETHOD(WaitForVerticalBlank)(THIS_ DWORD, HANDLE ) PURE; +}; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirectDraw_QueryInterface(p, a, b) (p)->lpVtbl->QueryInterface(p, a, b) +#define IDirectDraw_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirectDraw_Release(p) (p)->lpVtbl->Release(p) +#define IDirectDraw_Compact(p) (p)->lpVtbl->Compact(p) +#define IDirectDraw_CreateClipper(p, a, b, c) (p)->lpVtbl->CreateClipper(p, a, b, c) +#define IDirectDraw_CreatePalette(p, a, b, c, d) (p)->lpVtbl->CreatePalette(p, a, b, c, d) +#define IDirectDraw_CreateSurface(p, a, b, c) (p)->lpVtbl->CreateSurface(p, a, b, c) +#define IDirectDraw_DuplicateSurface(p, a, b) (p)->lpVtbl->DuplicateSurface(p, a, b) +#define IDirectDraw_EnumDisplayModes(p, a, b, c, d) (p)->lpVtbl->EnumDisplayModes(p, a, b, c, d) +#define IDirectDraw_EnumSurfaces(p, a, b, c, d) (p)->lpVtbl->EnumSurfaces(p, a, b, c, d) +#define IDirectDraw_FlipToGDISurface(p) (p)->lpVtbl->FlipToGDISurface(p) +#define IDirectDraw_GetCaps(p, a, b) (p)->lpVtbl->GetCaps(p, a, b) +#define IDirectDraw_GetDisplayMode(p, a) (p)->lpVtbl->GetDisplayMode(p, a) +#define IDirectDraw_GetFourCCCodes(p, a, b) (p)->lpVtbl->GetFourCCCodes(p, a, b) +#define IDirectDraw_GetGDISurface(p, a) (p)->lpVtbl->GetGDISurface(p, a) +#define IDirectDraw_GetMonitorFrequency(p, a) (p)->lpVtbl->GetMonitorFrequency(p, a) +#define IDirectDraw_GetScanLine(p, a) (p)->lpVtbl->GetScanLine(p, a) +#define IDirectDraw_GetVerticalBlankStatus(p, a) (p)->lpVtbl->GetVerticalBlankStatus(p, a) +#define IDirectDraw_Initialize(p, a) (p)->lpVtbl->Initialize(p, a) +#define IDirectDraw_RestoreDisplayMode(p) (p)->lpVtbl->RestoreDisplayMode(p) +#define IDirectDraw_SetCooperativeLevel(p, a, b) (p)->lpVtbl->SetCooperativeLevel(p, a, b) +#define IDirectDraw_SetDisplayMode(p, a, b, c) (p)->lpVtbl->SetDisplayMode(p, a, b, c) +#define IDirectDraw_WaitForVerticalBlank(p, a, b) (p)->lpVtbl->WaitForVerticalBlank(p, a, b) +#else +#define IDirectDraw_QueryInterface(p, a, b) (p)->QueryInterface(a, b) +#define IDirectDraw_AddRef(p) (p)->AddRef() +#define IDirectDraw_Release(p) (p)->Release() +#define IDirectDraw_Compact(p) (p)->Compact() +#define IDirectDraw_CreateClipper(p, a, b, c) (p)->CreateClipper(a, b, c) +#define IDirectDraw_CreatePalette(p, a, b, c, d) (p)->CreatePalette(a, b, c, d) +#define IDirectDraw_CreateSurface(p, a, b, c) (p)->CreateSurface(a, b, c) +#define IDirectDraw_DuplicateSurface(p, a, b) (p)->DuplicateSurface(a, b) +#define IDirectDraw_EnumDisplayModes(p, a, b, c, d) (p)->EnumDisplayModes(a, b, c, d) +#define IDirectDraw_EnumSurfaces(p, a, b, c, d) (p)->EnumSurfaces(a, b, c, d) +#define IDirectDraw_FlipToGDISurface(p) (p)->FlipToGDISurface() +#define IDirectDraw_GetCaps(p, a, b) (p)->GetCaps(a, b) +#define IDirectDraw_GetDisplayMode(p, a) (p)->GetDisplayMode(a) +#define IDirectDraw_GetFourCCCodes(p, a, b) (p)->GetFourCCCodes(a, b) +#define IDirectDraw_GetGDISurface(p, a) (p)->GetGDISurface(a) +#define IDirectDraw_GetMonitorFrequency(p, a) (p)->GetMonitorFrequency(a) +#define IDirectDraw_GetScanLine(p, a) (p)->GetScanLine(a) +#define IDirectDraw_GetVerticalBlankStatus(p, a) (p)->GetVerticalBlankStatus(a) +#define IDirectDraw_Initialize(p, a) (p)->Initialize(a) +#define IDirectDraw_RestoreDisplayMode(p) (p)->RestoreDisplayMode() +#define IDirectDraw_SetCooperativeLevel(p, a, b) (p)->SetCooperativeLevel(a, b) +#define IDirectDraw_SetDisplayMode(p, a, b, c) (p)->SetDisplayMode(a, b, c) +#define IDirectDraw_WaitForVerticalBlank(p, a, b) (p)->WaitForVerticalBlank(a, b) +#endif + +#endif + +#if defined( _WIN32 ) && !defined( _NO_COM ) +#undef INTERFACE +#define INTERFACE IDirectDraw2 +DECLARE_INTERFACE_( IDirectDraw2, IUnknown ) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + /*** IDirectDraw methods ***/ + STDMETHOD(Compact)(THIS) PURE; + STDMETHOD(CreateClipper)(THIS_ DWORD, LPDIRECTDRAWCLIPPER FAR*, IUnknown FAR * ) PURE; + STDMETHOD(CreatePalette)(THIS_ DWORD, LPPALETTEENTRY, LPDIRECTDRAWPALETTE FAR*, IUnknown FAR * ) PURE; + STDMETHOD(CreateSurface)(THIS_ LPDDSURFACEDESC, LPDIRECTDRAWSURFACE FAR *, IUnknown FAR *) PURE; + STDMETHOD(DuplicateSurface)( THIS_ LPDIRECTDRAWSURFACE, LPDIRECTDRAWSURFACE FAR * ) PURE; + STDMETHOD(EnumDisplayModes)( THIS_ DWORD, LPDDSURFACEDESC, LPVOID, LPDDENUMMODESCALLBACK ) PURE; + STDMETHOD(EnumSurfaces)(THIS_ DWORD, LPDDSURFACEDESC, LPVOID,LPDDENUMSURFACESCALLBACK ) PURE; + STDMETHOD(FlipToGDISurface)(THIS) PURE; + STDMETHOD(GetCaps)( THIS_ LPDDCAPS, LPDDCAPS) PURE; + STDMETHOD(GetDisplayMode)( THIS_ LPDDSURFACEDESC) PURE; + STDMETHOD(GetFourCCCodes)(THIS_ LPDWORD, LPDWORD ) PURE; + STDMETHOD(GetGDISurface)(THIS_ LPDIRECTDRAWSURFACE FAR *) PURE; + STDMETHOD(GetMonitorFrequency)(THIS_ LPDWORD) PURE; + STDMETHOD(GetScanLine)(THIS_ LPDWORD) PURE; + STDMETHOD(GetVerticalBlankStatus)(THIS_ LPBOOL ) PURE; + STDMETHOD(Initialize)(THIS_ GUID FAR *) PURE; + STDMETHOD(RestoreDisplayMode)(THIS) PURE; + STDMETHOD(SetCooperativeLevel)(THIS_ HWND, DWORD) PURE; + STDMETHOD(SetDisplayMode)(THIS_ DWORD, DWORD,DWORD, DWORD, DWORD) PURE; + STDMETHOD(WaitForVerticalBlank)(THIS_ DWORD, HANDLE ) PURE; + /*** Added in the v2 interface ***/ + STDMETHOD(GetAvailableVidMem)(THIS_ LPDDSCAPS, LPDWORD, LPDWORD) PURE; +}; +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirectDraw2_QueryInterface(p, a, b) (p)->lpVtbl->QueryInterface(p, a, b) +#define IDirectDraw2_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirectDraw2_Release(p) (p)->lpVtbl->Release(p) +#define IDirectDraw2_Compact(p) (p)->lpVtbl->Compact(p) +#define IDirectDraw2_CreateClipper(p, a, b, c) (p)->lpVtbl->CreateClipper(p, a, b, c) +#define IDirectDraw2_CreatePalette(p, a, b, c, d) (p)->lpVtbl->CreatePalette(p, a, b, c, d) +#define IDirectDraw2_CreateSurface(p, a, b, c) (p)->lpVtbl->CreateSurface(p, a, b, c) +#define IDirectDraw2_DuplicateSurface(p, a, b) (p)->lpVtbl->DuplicateSurface(p, a, b) +#define IDirectDraw2_EnumDisplayModes(p, a, b, c, d) (p)->lpVtbl->EnumDisplayModes(p, a, b, c, d) +#define IDirectDraw2_EnumSurfaces(p, a, b, c, d) (p)->lpVtbl->EnumSurfaces(p, a, b, c, d) +#define IDirectDraw2_FlipToGDISurface(p) (p)->lpVtbl->FlipToGDISurface(p) +#define IDirectDraw2_GetCaps(p, a, b) (p)->lpVtbl->GetCaps(p, a, b) +#define IDirectDraw2_GetDisplayMode(p, a) (p)->lpVtbl->GetDisplayMode(p, a) +#define IDirectDraw2_GetFourCCCodes(p, a, b) (p)->lpVtbl->GetFourCCCodes(p, a, b) +#define IDirectDraw2_GetGDISurface(p, a) (p)->lpVtbl->GetGDISurface(p, a) +#define IDirectDraw2_GetMonitorFrequency(p, a) (p)->lpVtbl->GetMonitorFrequency(p, a) +#define IDirectDraw2_GetScanLine(p, a) (p)->lpVtbl->GetScanLine(p, a) +#define IDirectDraw2_GetVerticalBlankStatus(p, a) (p)->lpVtbl->GetVerticalBlankStatus(p, a) +#define IDirectDraw2_Initialize(p, a) (p)->lpVtbl->Initialize(p, a) +#define IDirectDraw2_RestoreDisplayMode(p) (p)->lpVtbl->RestoreDisplayMode(p) +#define IDirectDraw2_SetCooperativeLevel(p, a, b) (p)->lpVtbl->SetCooperativeLevel(p, a, b) +#define IDirectDraw2_SetDisplayMode(p, a, b, c, d, e) (p)->lpVtbl->SetDisplayMode(p, a, b, c, d, e) +#define IDirectDraw2_WaitForVerticalBlank(p, a, b) (p)->lpVtbl->WaitForVerticalBlank(p, a, b) +#define IDirectDraw2_GetAvailableVidMem(p, a, b, c) (p)->lpVtbl->GetAvailableVidMem(p, a, b, c) +#else +#define IDirectDraw2_QueryInterface(p, a, b) (p)->QueryInterface(a, b) +#define IDirectDraw2_AddRef(p) (p)->AddRef() +#define IDirectDraw2_Release(p) (p)->Release() +#define IDirectDraw2_Compact(p) (p)->Compact() +#define IDirectDraw2_CreateClipper(p, a, b, c) (p)->CreateClipper(a, b, c) +#define IDirectDraw2_CreatePalette(p, a, b, c, d) (p)->CreatePalette(a, b, c, d) +#define IDirectDraw2_CreateSurface(p, a, b, c) (p)->CreateSurface(a, b, c) +#define IDirectDraw2_DuplicateSurface(p, a, b) (p)->DuplicateSurface(a, b) +#define IDirectDraw2_EnumDisplayModes(p, a, b, c, d) (p)->EnumDisplayModes(a, b, c, d) +#define IDirectDraw2_EnumSurfaces(p, a, b, c, d) (p)->EnumSurfaces(a, b, c, d) +#define IDirectDraw2_FlipToGDISurface(p) (p)->FlipToGDISurface() +#define IDirectDraw2_GetCaps(p, a, b) (p)->GetCaps(a, b) +#define IDirectDraw2_GetDisplayMode(p, a) (p)->GetDisplayMode(a) +#define IDirectDraw2_GetFourCCCodes(p, a, b) (p)->GetFourCCCodes(a, b) +#define IDirectDraw2_GetGDISurface(p, a) (p)->GetGDISurface(a) +#define IDirectDraw2_GetMonitorFrequency(p, a) (p)->GetMonitorFrequency(a) +#define IDirectDraw2_GetScanLine(p, a) (p)->GetScanLine(a) +#define IDirectDraw2_GetVerticalBlankStatus(p, a) (p)->GetVerticalBlankStatus(a) +#define IDirectDraw2_Initialize(p, a) (p)->Initialize(a) +#define IDirectDraw2_RestoreDisplayMode(p) (p)->RestoreDisplayMode() +#define IDirectDraw2_SetCooperativeLevel(p, a, b) (p)->SetCooperativeLevel(a, b) +#define IDirectDraw2_SetDisplayMode(p, a, b, c, d, e) (p)->SetDisplayMode(a, b, c, d, e) +#define IDirectDraw2_WaitForVerticalBlank(p, a, b) (p)->WaitForVerticalBlank(a, b) +#define IDirectDraw2_GetAvailableVidMem(p, a, b, c) (p)->GetAvailableVidMem(a, b, c) +#endif + +#endif + +#if defined( _WIN32 ) && !defined( _NO_COM ) +#undef INTERFACE +#define INTERFACE IDirectDraw4 +DECLARE_INTERFACE_( IDirectDraw4, IUnknown ) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + /*** IDirectDraw methods ***/ + STDMETHOD(Compact)(THIS) PURE; + STDMETHOD(CreateClipper)(THIS_ DWORD, LPDIRECTDRAWCLIPPER FAR*, IUnknown FAR * ) PURE; + STDMETHOD(CreatePalette)(THIS_ DWORD, LPPALETTEENTRY, LPDIRECTDRAWPALETTE FAR*, IUnknown FAR * ) PURE; + STDMETHOD(CreateSurface)(THIS_ LPDDSURFACEDESC2, LPDIRECTDRAWSURFACE4 FAR *, IUnknown FAR *) PURE; + STDMETHOD(DuplicateSurface)( THIS_ LPDIRECTDRAWSURFACE4, LPDIRECTDRAWSURFACE4 FAR * ) PURE; + STDMETHOD(EnumDisplayModes)( THIS_ DWORD, LPDDSURFACEDESC2, LPVOID, LPDDENUMMODESCALLBACK2 ) PURE; + STDMETHOD(EnumSurfaces)(THIS_ DWORD, LPDDSURFACEDESC2, LPVOID,LPDDENUMSURFACESCALLBACK2 ) PURE; + STDMETHOD(FlipToGDISurface)(THIS) PURE; + STDMETHOD(GetCaps)( THIS_ LPDDCAPS, LPDDCAPS) PURE; + STDMETHOD(GetDisplayMode)( THIS_ LPDDSURFACEDESC2) PURE; + STDMETHOD(GetFourCCCodes)(THIS_ LPDWORD, LPDWORD ) PURE; + STDMETHOD(GetGDISurface)(THIS_ LPDIRECTDRAWSURFACE4 FAR *) PURE; + STDMETHOD(GetMonitorFrequency)(THIS_ LPDWORD) PURE; + STDMETHOD(GetScanLine)(THIS_ LPDWORD) PURE; + STDMETHOD(GetVerticalBlankStatus)(THIS_ LPBOOL ) PURE; + STDMETHOD(Initialize)(THIS_ GUID FAR *) PURE; + STDMETHOD(RestoreDisplayMode)(THIS) PURE; + STDMETHOD(SetCooperativeLevel)(THIS_ HWND, DWORD) PURE; + STDMETHOD(SetDisplayMode)(THIS_ DWORD, DWORD,DWORD, DWORD, DWORD) PURE; + STDMETHOD(WaitForVerticalBlank)(THIS_ DWORD, HANDLE ) PURE; + /*** Added in the v2 interface ***/ + STDMETHOD(GetAvailableVidMem)(THIS_ LPDDSCAPS2, LPDWORD, LPDWORD) PURE; + /*** Added in the V4 Interface ***/ + STDMETHOD(GetSurfaceFromDC) (THIS_ HDC, LPDIRECTDRAWSURFACE4 *) PURE; + STDMETHOD(RestoreAllSurfaces)(THIS) PURE; + STDMETHOD(TestCooperativeLevel)(THIS) PURE; + STDMETHOD(GetDeviceIdentifier)(THIS_ LPDDDEVICEIDENTIFIER, DWORD ) PURE; +}; +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirectDraw4_QueryInterface(p, a, b) (p)->lpVtbl->QueryInterface(p, a, b) +#define IDirectDraw4_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirectDraw4_Release(p) (p)->lpVtbl->Release(p) +#define IDirectDraw4_Compact(p) (p)->lpVtbl->Compact(p) +#define IDirectDraw4_CreateClipper(p, a, b, c) (p)->lpVtbl->CreateClipper(p, a, b, c) +#define IDirectDraw4_CreatePalette(p, a, b, c, d) (p)->lpVtbl->CreatePalette(p, a, b, c, d) +#define IDirectDraw4_CreateSurface(p, a, b, c) (p)->lpVtbl->CreateSurface(p, a, b, c) +#define IDirectDraw4_DuplicateSurface(p, a, b) (p)->lpVtbl->DuplicateSurface(p, a, b) +#define IDirectDraw4_EnumDisplayModes(p, a, b, c, d) (p)->lpVtbl->EnumDisplayModes(p, a, b, c, d) +#define IDirectDraw4_EnumSurfaces(p, a, b, c, d) (p)->lpVtbl->EnumSurfaces(p, a, b, c, d) +#define IDirectDraw4_FlipToGDISurface(p) (p)->lpVtbl->FlipToGDISurface(p) +#define IDirectDraw4_GetCaps(p, a, b) (p)->lpVtbl->GetCaps(p, a, b) +#define IDirectDraw4_GetDisplayMode(p, a) (p)->lpVtbl->GetDisplayMode(p, a) +#define IDirectDraw4_GetFourCCCodes(p, a, b) (p)->lpVtbl->GetFourCCCodes(p, a, b) +#define IDirectDraw4_GetGDISurface(p, a) (p)->lpVtbl->GetGDISurface(p, a) +#define IDirectDraw4_GetMonitorFrequency(p, a) (p)->lpVtbl->GetMonitorFrequency(p, a) +#define IDirectDraw4_GetScanLine(p, a) (p)->lpVtbl->GetScanLine(p, a) +#define IDirectDraw4_GetVerticalBlankStatus(p, a) (p)->lpVtbl->GetVerticalBlankStatus(p, a) +#define IDirectDraw4_Initialize(p, a) (p)->lpVtbl->Initialize(p, a) +#define IDirectDraw4_RestoreDisplayMode(p) (p)->lpVtbl->RestoreDisplayMode(p) +#define IDirectDraw4_SetCooperativeLevel(p, a, b) (p)->lpVtbl->SetCooperativeLevel(p, a, b) +#define IDirectDraw4_SetDisplayMode(p, a, b, c, d, e) (p)->lpVtbl->SetDisplayMode(p, a, b, c, d, e) +#define IDirectDraw4_WaitForVerticalBlank(p, a, b) (p)->lpVtbl->WaitForVerticalBlank(p, a, b) +#define IDirectDraw4_GetAvailableVidMem(p, a, b, c) (p)->lpVtbl->GetAvailableVidMem(p, a, b, c) +#define IDirectDraw4_GetSurfaceFromDC(p, a, b) (p)->lpVtbl->GetSurfaceFromDC(p, a, b) +#define IDirectDraw4_RestoreAllSurfaces(p) (p)->lpVtbl->RestoreAllSurfaces(p) +#define IDirectDraw4_TestCooperativeLevel(p) (p)->lpVtbl->TestCooperativeLevel(p) +#define IDirectDraw4_GetDeviceIdentifier(p,a,b) (p)->lpVtbl->GetDeviceIdentifier(p,a,b) +#else +#define IDirectDraw4_QueryInterface(p, a, b) (p)->QueryInterface(a, b) +#define IDirectDraw4_AddRef(p) (p)->AddRef() +#define IDirectDraw4_Release(p) (p)->Release() +#define IDirectDraw4_Compact(p) (p)->Compact() +#define IDirectDraw4_CreateClipper(p, a, b, c) (p)->CreateClipper(a, b, c) +#define IDirectDraw4_CreatePalette(p, a, b, c, d) (p)->CreatePalette(a, b, c, d) +#define IDirectDraw4_CreateSurface(p, a, b, c) (p)->CreateSurface(a, b, c) +#define IDirectDraw4_DuplicateSurface(p, a, b) (p)->DuplicateSurface(a, b) +#define IDirectDraw4_EnumDisplayModes(p, a, b, c, d) (p)->EnumDisplayModes(a, b, c, d) +#define IDirectDraw4_EnumSurfaces(p, a, b, c, d) (p)->EnumSurfaces(a, b, c, d) +#define IDirectDraw4_FlipToGDISurface(p) (p)->FlipToGDISurface() +#define IDirectDraw4_GetCaps(p, a, b) (p)->GetCaps(a, b) +#define IDirectDraw4_GetDisplayMode(p, a) (p)->GetDisplayMode(a) +#define IDirectDraw4_GetFourCCCodes(p, a, b) (p)->GetFourCCCodes(a, b) +#define IDirectDraw4_GetGDISurface(p, a) (p)->GetGDISurface(a) +#define IDirectDraw4_GetMonitorFrequency(p, a) (p)->GetMonitorFrequency(a) +#define IDirectDraw4_GetScanLine(p, a) (p)->GetScanLine(a) +#define IDirectDraw4_GetVerticalBlankStatus(p, a) (p)->GetVerticalBlankStatus(a) +#define IDirectDraw4_Initialize(p, a) (p)->Initialize(a) +#define IDirectDraw4_RestoreDisplayMode(p) (p)->RestoreDisplayMode() +#define IDirectDraw4_SetCooperativeLevel(p, a, b) (p)->SetCooperativeLevel(a, b) +#define IDirectDraw4_SetDisplayMode(p, a, b, c, d, e) (p)->SetDisplayMode(a, b, c, d, e) +#define IDirectDraw4_WaitForVerticalBlank(p, a, b) (p)->WaitForVerticalBlank(a, b) +#define IDirectDraw4_GetAvailableVidMem(p, a, b, c) (p)->GetAvailableVidMem(a, b, c) +#define IDirectDraw4_GetSurfaceFromDC(p, a, b) (p)->GetSurfaceFromDC(a, b) +#define IDirectDraw4_RestoreAllSurfaces(p) (p)->RestoreAllSurfaces() +#define IDirectDraw4_TestCooperativeLevel(p) (p)->TestCooperativeLevel() +#define IDirectDraw4_GetDeviceIdentifier(p,a,b) (p)->GetDeviceIdentifier(a,b) +#endif + +#endif + +#if defined( _WIN32 ) && !defined( _NO_COM ) +#undef INTERFACE +#define INTERFACE IDirectDraw7 +DECLARE_INTERFACE_( IDirectDraw7, IUnknown ) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + /*** IDirectDraw methods ***/ + STDMETHOD(Compact)(THIS) PURE; + STDMETHOD(CreateClipper)(THIS_ DWORD, LPDIRECTDRAWCLIPPER FAR*, IUnknown FAR * ) PURE; + STDMETHOD(CreatePalette)(THIS_ DWORD, LPPALETTEENTRY, LPDIRECTDRAWPALETTE FAR*, IUnknown FAR * ) PURE; + STDMETHOD(CreateSurface)(THIS_ LPDDSURFACEDESC2, LPDIRECTDRAWSURFACE7 FAR *, IUnknown FAR *) PURE; + STDMETHOD(DuplicateSurface)( THIS_ LPDIRECTDRAWSURFACE7, LPDIRECTDRAWSURFACE7 FAR * ) PURE; + STDMETHOD(EnumDisplayModes)( THIS_ DWORD, LPDDSURFACEDESC2, LPVOID, LPDDENUMMODESCALLBACK2 ) PURE; + STDMETHOD(EnumSurfaces)(THIS_ DWORD, LPDDSURFACEDESC2, LPVOID,LPDDENUMSURFACESCALLBACK7 ) PURE; + STDMETHOD(FlipToGDISurface)(THIS) PURE; + STDMETHOD(GetCaps)( THIS_ LPDDCAPS, LPDDCAPS) PURE; + STDMETHOD(GetDisplayMode)( THIS_ LPDDSURFACEDESC2) PURE; + STDMETHOD(GetFourCCCodes)(THIS_ LPDWORD, LPDWORD ) PURE; + STDMETHOD(GetGDISurface)(THIS_ LPDIRECTDRAWSURFACE7 FAR *) PURE; + STDMETHOD(GetMonitorFrequency)(THIS_ LPDWORD) PURE; + STDMETHOD(GetScanLine)(THIS_ LPDWORD) PURE; + STDMETHOD(GetVerticalBlankStatus)(THIS_ LPBOOL ) PURE; + STDMETHOD(Initialize)(THIS_ GUID FAR *) PURE; + STDMETHOD(RestoreDisplayMode)(THIS) PURE; + STDMETHOD(SetCooperativeLevel)(THIS_ HWND, DWORD) PURE; + STDMETHOD(SetDisplayMode)(THIS_ DWORD, DWORD,DWORD, DWORD, DWORD) PURE; + STDMETHOD(WaitForVerticalBlank)(THIS_ DWORD, HANDLE ) PURE; + /*** Added in the v2 interface ***/ + STDMETHOD(GetAvailableVidMem)(THIS_ LPDDSCAPS2, LPDWORD, LPDWORD) PURE; + /*** Added in the V4 Interface ***/ + STDMETHOD(GetSurfaceFromDC) (THIS_ HDC, LPDIRECTDRAWSURFACE7 *) PURE; + STDMETHOD(RestoreAllSurfaces)(THIS) PURE; + STDMETHOD(TestCooperativeLevel)(THIS) PURE; + STDMETHOD(GetDeviceIdentifier)(THIS_ LPDDDEVICEIDENTIFIER2, DWORD ) PURE; + STDMETHOD(StartModeTest)(THIS_ LPSIZE, DWORD, DWORD ) PURE; + STDMETHOD(EvaluateMode)(THIS_ DWORD, DWORD * ) PURE; +}; +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirectDraw7_QueryInterface(p, a, b) (p)->lpVtbl->QueryInterface(p, a, b) +#define IDirectDraw7_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirectDraw7_Release(p) (p)->lpVtbl->Release(p) +#define IDirectDraw7_Compact(p) (p)->lpVtbl->Compact(p) +#define IDirectDraw7_CreateClipper(p, a, b, c) (p)->lpVtbl->CreateClipper(p, a, b, c) +#define IDirectDraw7_CreatePalette(p, a, b, c, d) (p)->lpVtbl->CreatePalette(p, a, b, c, d) +#define IDirectDraw7_CreateSurface(p, a, b, c) (p)->lpVtbl->CreateSurface(p, a, b, c) +#define IDirectDraw7_DuplicateSurface(p, a, b) (p)->lpVtbl->DuplicateSurface(p, a, b) +#define IDirectDraw7_EnumDisplayModes(p, a, b, c, d) (p)->lpVtbl->EnumDisplayModes(p, a, b, c, d) +#define IDirectDraw7_EnumSurfaces(p, a, b, c, d) (p)->lpVtbl->EnumSurfaces(p, a, b, c, d) +#define IDirectDraw7_FlipToGDISurface(p) (p)->lpVtbl->FlipToGDISurface(p) +#define IDirectDraw7_GetCaps(p, a, b) (p)->lpVtbl->GetCaps(p, a, b) +#define IDirectDraw7_GetDisplayMode(p, a) (p)->lpVtbl->GetDisplayMode(p, a) +#define IDirectDraw7_GetFourCCCodes(p, a, b) (p)->lpVtbl->GetFourCCCodes(p, a, b) +#define IDirectDraw7_GetGDISurface(p, a) (p)->lpVtbl->GetGDISurface(p, a) +#define IDirectDraw7_GetMonitorFrequency(p, a) (p)->lpVtbl->GetMonitorFrequency(p, a) +#define IDirectDraw7_GetScanLine(p, a) (p)->lpVtbl->GetScanLine(p, a) +#define IDirectDraw7_GetVerticalBlankStatus(p, a) (p)->lpVtbl->GetVerticalBlankStatus(p, a) +#define IDirectDraw7_Initialize(p, a) (p)->lpVtbl->Initialize(p, a) +#define IDirectDraw7_RestoreDisplayMode(p) (p)->lpVtbl->RestoreDisplayMode(p) +#define IDirectDraw7_SetCooperativeLevel(p, a, b) (p)->lpVtbl->SetCooperativeLevel(p, a, b) +#define IDirectDraw7_SetDisplayMode(p, a, b, c, d, e) (p)->lpVtbl->SetDisplayMode(p, a, b, c, d, e) +#define IDirectDraw7_WaitForVerticalBlank(p, a, b) (p)->lpVtbl->WaitForVerticalBlank(p, a, b) +#define IDirectDraw7_GetAvailableVidMem(p, a, b, c) (p)->lpVtbl->GetAvailableVidMem(p, a, b, c) +#define IDirectDraw7_GetSurfaceFromDC(p, a, b) (p)->lpVtbl->GetSurfaceFromDC(p, a, b) +#define IDirectDraw7_RestoreAllSurfaces(p) (p)->lpVtbl->RestoreAllSurfaces(p) +#define IDirectDraw7_TestCooperativeLevel(p) (p)->lpVtbl->TestCooperativeLevel(p) +#define IDirectDraw7_GetDeviceIdentifier(p,a,b) (p)->lpVtbl->GetDeviceIdentifier(p,a,b) +#define IDirectDraw7_StartModeTest(p,a,b,c) (p)->lpVtbl->StartModeTest(p,a,b,c) +#define IDirectDraw7_EvaluateMode(p,a,b) (p)->lpVtbl->EvaluateMode(p,a,b) +#else +#define IDirectDraw7_QueryInterface(p, a, b) (p)->QueryInterface(a, b) +#define IDirectDraw7_AddRef(p) (p)->AddRef() +#define IDirectDraw7_Release(p) (p)->Release() +#define IDirectDraw7_Compact(p) (p)->Compact() +#define IDirectDraw7_CreateClipper(p, a, b, c) (p)->CreateClipper(a, b, c) +#define IDirectDraw7_CreatePalette(p, a, b, c, d) (p)->CreatePalette(a, b, c, d) +#define IDirectDraw7_CreateSurface(p, a, b, c) (p)->CreateSurface(a, b, c) +#define IDirectDraw7_DuplicateSurface(p, a, b) (p)->DuplicateSurface(a, b) +#define IDirectDraw7_EnumDisplayModes(p, a, b, c, d) (p)->EnumDisplayModes(a, b, c, d) +#define IDirectDraw7_EnumSurfaces(p, a, b, c, d) (p)->EnumSurfaces(a, b, c, d) +#define IDirectDraw7_FlipToGDISurface(p) (p)->FlipToGDISurface() +#define IDirectDraw7_GetCaps(p, a, b) (p)->GetCaps(a, b) +#define IDirectDraw7_GetDisplayMode(p, a) (p)->GetDisplayMode(a) +#define IDirectDraw7_GetFourCCCodes(p, a, b) (p)->GetFourCCCodes(a, b) +#define IDirectDraw7_GetGDISurface(p, a) (p)->GetGDISurface(a) +#define IDirectDraw7_GetMonitorFrequency(p, a) (p)->GetMonitorFrequency(a) +#define IDirectDraw7_GetScanLine(p, a) (p)->GetScanLine(a) +#define IDirectDraw7_GetVerticalBlankStatus(p, a) (p)->GetVerticalBlankStatus(a) +#define IDirectDraw7_Initialize(p, a) (p)->Initialize(a) +#define IDirectDraw7_RestoreDisplayMode(p) (p)->RestoreDisplayMode() +#define IDirectDraw7_SetCooperativeLevel(p, a, b) (p)->SetCooperativeLevel(a, b) +#define IDirectDraw7_SetDisplayMode(p, a, b, c, d, e) (p)->SetDisplayMode(a, b, c, d, e) +#define IDirectDraw7_WaitForVerticalBlank(p, a, b) (p)->WaitForVerticalBlank(a, b) +#define IDirectDraw7_GetAvailableVidMem(p, a, b, c) (p)->GetAvailableVidMem(a, b, c) +#define IDirectDraw7_GetSurfaceFromDC(p, a, b) (p)->GetSurfaceFromDC(a, b) +#define IDirectDraw7_RestoreAllSurfaces(p) (p)->RestoreAllSurfaces() +#define IDirectDraw7_TestCooperativeLevel(p) (p)->TestCooperativeLevel() +#define IDirectDraw7_GetDeviceIdentifier(p,a,b) (p)->GetDeviceIdentifier(a,b) +#define IDirectDraw7_StartModeTest(p,a,b,c) (p)->lpVtbl->StartModeTest(a,b,c) +#define IDirectDraw7_EvaluateMode(p,a,b) (p)->lpVtbl->EvaluateMode(a,b) +#endif + +#endif + + +/* + * IDirectDrawPalette + */ +#if defined( _WIN32 ) && !defined( _NO_COM ) +#undef INTERFACE +#define INTERFACE IDirectDrawPalette +DECLARE_INTERFACE_( IDirectDrawPalette, IUnknown ) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + /*** IDirectDrawPalette methods ***/ + STDMETHOD(GetCaps)(THIS_ LPDWORD) PURE; + STDMETHOD(GetEntries)(THIS_ DWORD,DWORD,DWORD,LPPALETTEENTRY) PURE; + STDMETHOD(Initialize)(THIS_ LPDIRECTDRAW, DWORD, LPPALETTEENTRY) PURE; + STDMETHOD(SetEntries)(THIS_ DWORD,DWORD,DWORD,LPPALETTEENTRY) PURE; +}; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirectDrawPalette_QueryInterface(p, a, b) (p)->lpVtbl->QueryInterface(p, a, b) +#define IDirectDrawPalette_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirectDrawPalette_Release(p) (p)->lpVtbl->Release(p) +#define IDirectDrawPalette_GetCaps(p, a) (p)->lpVtbl->GetCaps(p, a) +#define IDirectDrawPalette_GetEntries(p, a, b, c, d) (p)->lpVtbl->GetEntries(p, a, b, c, d) +#define IDirectDrawPalette_Initialize(p, a, b, c) (p)->lpVtbl->Initialize(p, a, b, c) +#define IDirectDrawPalette_SetEntries(p, a, b, c, d) (p)->lpVtbl->SetEntries(p, a, b, c, d) +#else +#define IDirectDrawPalette_QueryInterface(p, a, b) (p)->QueryInterface(a, b) +#define IDirectDrawPalette_AddRef(p) (p)->AddRef() +#define IDirectDrawPalette_Release(p) (p)->Release() +#define IDirectDrawPalette_GetCaps(p, a) (p)->GetCaps(a) +#define IDirectDrawPalette_GetEntries(p, a, b, c, d) (p)->GetEntries(a, b, c, d) +#define IDirectDrawPalette_Initialize(p, a, b, c) (p)->Initialize(a, b, c) +#define IDirectDrawPalette_SetEntries(p, a, b, c, d) (p)->SetEntries(a, b, c, d) +#endif + +#endif + + + +/* + * IDirectDrawClipper + */ +#if defined( _WIN32 ) && !defined( _NO_COM ) +#undef INTERFACE +#define INTERFACE IDirectDrawClipper +DECLARE_INTERFACE_( IDirectDrawClipper, IUnknown ) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + /*** IDirectDrawClipper methods ***/ + STDMETHOD(GetClipList)(THIS_ LPRECT, LPRGNDATA, LPDWORD) PURE; + STDMETHOD(GetHWnd)(THIS_ HWND FAR *) PURE; + STDMETHOD(Initialize)(THIS_ LPDIRECTDRAW, DWORD) PURE; + STDMETHOD(IsClipListChanged)(THIS_ BOOL FAR *) PURE; + STDMETHOD(SetClipList)(THIS_ LPRGNDATA,DWORD) PURE; + STDMETHOD(SetHWnd)(THIS_ DWORD, HWND ) PURE; +}; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirectDrawClipper_QueryInterface(p, a, b) (p)->lpVtbl->QueryInterface(p, a, b) +#define IDirectDrawClipper_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirectDrawClipper_Release(p) (p)->lpVtbl->Release(p) +#define IDirectDrawClipper_GetClipList(p, a, b, c) (p)->lpVtbl->GetClipList(p, a, b, c) +#define IDirectDrawClipper_GetHWnd(p, a) (p)->lpVtbl->GetHWnd(p, a) +#define IDirectDrawClipper_Initialize(p, a, b) (p)->lpVtbl->Initialize(p, a, b) +#define IDirectDrawClipper_IsClipListChanged(p, a) (p)->lpVtbl->IsClipListChanged(p, a) +#define IDirectDrawClipper_SetClipList(p, a, b) (p)->lpVtbl->SetClipList(p, a, b) +#define IDirectDrawClipper_SetHWnd(p, a, b) (p)->lpVtbl->SetHWnd(p, a, b) +#else +#define IDirectDrawClipper_QueryInterface(p, a, b) (p)->QueryInterface(a, b) +#define IDirectDrawClipper_AddRef(p) (p)->AddRef() +#define IDirectDrawClipper_Release(p) (p)->Release() +#define IDirectDrawClipper_GetClipList(p, a, b, c) (p)->GetClipList(a, b, c) +#define IDirectDrawClipper_GetHWnd(p, a) (p)->GetHWnd(a) +#define IDirectDrawClipper_Initialize(p, a, b) (p)->Initialize(a, b) +#define IDirectDrawClipper_IsClipListChanged(p, a) (p)->IsClipListChanged(a) +#define IDirectDrawClipper_SetClipList(p, a, b) (p)->SetClipList(a, b) +#define IDirectDrawClipper_SetHWnd(p, a, b) (p)->SetHWnd(a, b) +#endif + +#endif + +/* + * IDirectDrawSurface and related interfaces + */ +#if defined( _WIN32 ) && !defined( _NO_COM ) +#undef INTERFACE +#define INTERFACE IDirectDrawSurface +DECLARE_INTERFACE_( IDirectDrawSurface, IUnknown ) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + /*** IDirectDrawSurface methods ***/ + STDMETHOD(AddAttachedSurface)(THIS_ LPDIRECTDRAWSURFACE) PURE; + STDMETHOD(AddOverlayDirtyRect)(THIS_ LPRECT) PURE; + STDMETHOD(Blt)(THIS_ LPRECT,LPDIRECTDRAWSURFACE, LPRECT,DWORD, LPDDBLTFX) PURE; + STDMETHOD(BltBatch)(THIS_ LPDDBLTBATCH, DWORD, DWORD ) PURE; + STDMETHOD(BltFast)(THIS_ DWORD,DWORD,LPDIRECTDRAWSURFACE, LPRECT,DWORD) PURE; + STDMETHOD(DeleteAttachedSurface)(THIS_ DWORD,LPDIRECTDRAWSURFACE) PURE; + STDMETHOD(EnumAttachedSurfaces)(THIS_ LPVOID,LPDDENUMSURFACESCALLBACK) PURE; + STDMETHOD(EnumOverlayZOrders)(THIS_ DWORD,LPVOID,LPDDENUMSURFACESCALLBACK) PURE; + STDMETHOD(Flip)(THIS_ LPDIRECTDRAWSURFACE, DWORD) PURE; + STDMETHOD(GetAttachedSurface)(THIS_ LPDDSCAPS, LPDIRECTDRAWSURFACE FAR *) PURE; + STDMETHOD(GetBltStatus)(THIS_ DWORD) PURE; + STDMETHOD(GetCaps)(THIS_ LPDDSCAPS) PURE; + STDMETHOD(GetClipper)(THIS_ LPDIRECTDRAWCLIPPER FAR*) PURE; + STDMETHOD(GetColorKey)(THIS_ DWORD, LPDDCOLORKEY) PURE; + STDMETHOD(GetDC)(THIS_ HDC FAR *) PURE; + STDMETHOD(GetFlipStatus)(THIS_ DWORD) PURE; + STDMETHOD(GetOverlayPosition)(THIS_ LPLONG, LPLONG ) PURE; + STDMETHOD(GetPalette)(THIS_ LPDIRECTDRAWPALETTE FAR*) PURE; + STDMETHOD(GetPixelFormat)(THIS_ LPDDPIXELFORMAT) PURE; + STDMETHOD(GetSurfaceDesc)(THIS_ LPDDSURFACEDESC) PURE; + STDMETHOD(Initialize)(THIS_ LPDIRECTDRAW, LPDDSURFACEDESC) PURE; + STDMETHOD(IsLost)(THIS) PURE; + STDMETHOD(Lock)(THIS_ LPRECT,LPDDSURFACEDESC,DWORD,HANDLE) PURE; + STDMETHOD(ReleaseDC)(THIS_ HDC) PURE; + STDMETHOD(Restore)(THIS) PURE; + STDMETHOD(SetClipper)(THIS_ LPDIRECTDRAWCLIPPER) PURE; + STDMETHOD(SetColorKey)(THIS_ DWORD, LPDDCOLORKEY) PURE; + STDMETHOD(SetOverlayPosition)(THIS_ LONG, LONG ) PURE; + STDMETHOD(SetPalette)(THIS_ LPDIRECTDRAWPALETTE) PURE; + STDMETHOD(Unlock)(THIS_ LPVOID) PURE; + STDMETHOD(UpdateOverlay)(THIS_ LPRECT, LPDIRECTDRAWSURFACE,LPRECT,DWORD, LPDDOVERLAYFX) PURE; + STDMETHOD(UpdateOverlayDisplay)(THIS_ DWORD) PURE; + STDMETHOD(UpdateOverlayZOrder)(THIS_ DWORD, LPDIRECTDRAWSURFACE) PURE; +}; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirectDrawSurface_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirectDrawSurface_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirectDrawSurface_Release(p) (p)->lpVtbl->Release(p) +#define IDirectDrawSurface_AddAttachedSurface(p,a) (p)->lpVtbl->AddAttachedSurface(p,a) +#define IDirectDrawSurface_AddOverlayDirtyRect(p,a) (p)->lpVtbl->AddOverlayDirtyRect(p,a) +#define IDirectDrawSurface_Blt(p,a,b,c,d,e) (p)->lpVtbl->Blt(p,a,b,c,d,e) +#define IDirectDrawSurface_BltBatch(p,a,b,c) (p)->lpVtbl->BltBatch(p,a,b,c) +#define IDirectDrawSurface_BltFast(p,a,b,c,d,e) (p)->lpVtbl->BltFast(p,a,b,c,d,e) +#define IDirectDrawSurface_DeleteAttachedSurface(p,a,b) (p)->lpVtbl->DeleteAttachedSurface(p,a,b) +#define IDirectDrawSurface_EnumAttachedSurfaces(p,a,b) (p)->lpVtbl->EnumAttachedSurfaces(p,a,b) +#define IDirectDrawSurface_EnumOverlayZOrders(p,a,b,c) (p)->lpVtbl->EnumOverlayZOrders(p,a,b,c) +#define IDirectDrawSurface_Flip(p,a,b) (p)->lpVtbl->Flip(p,a,b) +#define IDirectDrawSurface_GetAttachedSurface(p,a,b) (p)->lpVtbl->GetAttachedSurface(p,a,b) +#define IDirectDrawSurface_GetBltStatus(p,a) (p)->lpVtbl->GetBltStatus(p,a) +#define IDirectDrawSurface_GetCaps(p,b) (p)->lpVtbl->GetCaps(p,b) +#define IDirectDrawSurface_GetClipper(p,a) (p)->lpVtbl->GetClipper(p,a) +#define IDirectDrawSurface_GetColorKey(p,a,b) (p)->lpVtbl->GetColorKey(p,a,b) +#define IDirectDrawSurface_GetDC(p,a) (p)->lpVtbl->GetDC(p,a) +#define IDirectDrawSurface_GetFlipStatus(p,a) (p)->lpVtbl->GetFlipStatus(p,a) +#define IDirectDrawSurface_GetOverlayPosition(p,a,b) (p)->lpVtbl->GetOverlayPosition(p,a,b) +#define IDirectDrawSurface_GetPalette(p,a) (p)->lpVtbl->GetPalette(p,a) +#define IDirectDrawSurface_GetPixelFormat(p,a) (p)->lpVtbl->GetPixelFormat(p,a) +#define IDirectDrawSurface_GetSurfaceDesc(p,a) (p)->lpVtbl->GetSurfaceDesc(p,a) +#define IDirectDrawSurface_Initialize(p,a,b) (p)->lpVtbl->Initialize(p,a,b) +#define IDirectDrawSurface_IsLost(p) (p)->lpVtbl->IsLost(p) +#define IDirectDrawSurface_Lock(p,a,b,c,d) (p)->lpVtbl->Lock(p,a,b,c,d) +#define IDirectDrawSurface_ReleaseDC(p,a) (p)->lpVtbl->ReleaseDC(p,a) +#define IDirectDrawSurface_Restore(p) (p)->lpVtbl->Restore(p) +#define IDirectDrawSurface_SetClipper(p,a) (p)->lpVtbl->SetClipper(p,a) +#define IDirectDrawSurface_SetColorKey(p,a,b) (p)->lpVtbl->SetColorKey(p,a,b) +#define IDirectDrawSurface_SetOverlayPosition(p,a,b) (p)->lpVtbl->SetOverlayPosition(p,a,b) +#define IDirectDrawSurface_SetPalette(p,a) (p)->lpVtbl->SetPalette(p,a) +#define IDirectDrawSurface_Unlock(p,b) (p)->lpVtbl->Unlock(p,b) +#define IDirectDrawSurface_UpdateOverlay(p,a,b,c,d,e) (p)->lpVtbl->UpdateOverlay(p,a,b,c,d,e) +#define IDirectDrawSurface_UpdateOverlayDisplay(p,a) (p)->lpVtbl->UpdateOverlayDisplay(p,a) +#define IDirectDrawSurface_UpdateOverlayZOrder(p,a,b) (p)->lpVtbl->UpdateOverlayZOrder(p,a,b) +#else +#define IDirectDrawSurface_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirectDrawSurface_AddRef(p) (p)->AddRef() +#define IDirectDrawSurface_Release(p) (p)->Release() +#define IDirectDrawSurface_AddAttachedSurface(p,a) (p)->AddAttachedSurface(a) +#define IDirectDrawSurface_AddOverlayDirtyRect(p,a) (p)->AddOverlayDirtyRect(a) +#define IDirectDrawSurface_Blt(p,a,b,c,d,e) (p)->Blt(a,b,c,d,e) +#define IDirectDrawSurface_BltBatch(p,a,b,c) (p)->BltBatch(a,b,c) +#define IDirectDrawSurface_BltFast(p,a,b,c,d,e) (p)->BltFast(a,b,c,d,e) +#define IDirectDrawSurface_DeleteAttachedSurface(p,a,b) (p)->DeleteAttachedSurface(a,b) +#define IDirectDrawSurface_EnumAttachedSurfaces(p,a,b) (p)->EnumAttachedSurfaces(a,b) +#define IDirectDrawSurface_EnumOverlayZOrders(p,a,b,c) (p)->EnumOverlayZOrders(a,b,c) +#define IDirectDrawSurface_Flip(p,a,b) (p)->Flip(a,b) +#define IDirectDrawSurface_GetAttachedSurface(p,a,b) (p)->GetAttachedSurface(a,b) +#define IDirectDrawSurface_GetBltStatus(p,a) (p)->GetBltStatus(a) +#define IDirectDrawSurface_GetCaps(p,b) (p)->GetCaps(b) +#define IDirectDrawSurface_GetClipper(p,a) (p)->GetClipper(a) +#define IDirectDrawSurface_GetColorKey(p,a,b) (p)->GetColorKey(a,b) +#define IDirectDrawSurface_GetDC(p,a) (p)->GetDC(a) +#define IDirectDrawSurface_GetFlipStatus(p,a) (p)->GetFlipStatus(a) +#define IDirectDrawSurface_GetOverlayPosition(p,a,b) (p)->GetOverlayPosition(a,b) +#define IDirectDrawSurface_GetPalette(p,a) (p)->GetPalette(a) +#define IDirectDrawSurface_GetPixelFormat(p,a) (p)->GetPixelFormat(a) +#define IDirectDrawSurface_GetSurfaceDesc(p,a) (p)->GetSurfaceDesc(a) +#define IDirectDrawSurface_Initialize(p,a,b) (p)->Initialize(a,b) +#define IDirectDrawSurface_IsLost(p) (p)->IsLost() +#define IDirectDrawSurface_Lock(p,a,b,c,d) (p)->Lock(a,b,c,d) +#define IDirectDrawSurface_ReleaseDC(p,a) (p)->ReleaseDC(a) +#define IDirectDrawSurface_Restore(p) (p)->Restore() +#define IDirectDrawSurface_SetClipper(p,a) (p)->SetClipper(a) +#define IDirectDrawSurface_SetColorKey(p,a,b) (p)->SetColorKey(a,b) +#define IDirectDrawSurface_SetOverlayPosition(p,a,b) (p)->SetOverlayPosition(a,b) +#define IDirectDrawSurface_SetPalette(p,a) (p)->SetPalette(a) +#define IDirectDrawSurface_Unlock(p,b) (p)->Unlock(b) +#define IDirectDrawSurface_UpdateOverlay(p,a,b,c,d,e) (p)->UpdateOverlay(a,b,c,d,e) +#define IDirectDrawSurface_UpdateOverlayDisplay(p,a) (p)->UpdateOverlayDisplay(a) +#define IDirectDrawSurface_UpdateOverlayZOrder(p,a,b) (p)->UpdateOverlayZOrder(a,b) +#endif + +/* + * IDirectDrawSurface2 and related interfaces + */ +#undef INTERFACE +#define INTERFACE IDirectDrawSurface2 +DECLARE_INTERFACE_( IDirectDrawSurface2, IUnknown ) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + /*** IDirectDrawSurface methods ***/ + STDMETHOD(AddAttachedSurface)(THIS_ LPDIRECTDRAWSURFACE2) PURE; + STDMETHOD(AddOverlayDirtyRect)(THIS_ LPRECT) PURE; + STDMETHOD(Blt)(THIS_ LPRECT,LPDIRECTDRAWSURFACE2, LPRECT,DWORD, LPDDBLTFX) PURE; + STDMETHOD(BltBatch)(THIS_ LPDDBLTBATCH, DWORD, DWORD ) PURE; + STDMETHOD(BltFast)(THIS_ DWORD,DWORD,LPDIRECTDRAWSURFACE2, LPRECT,DWORD) PURE; + STDMETHOD(DeleteAttachedSurface)(THIS_ DWORD,LPDIRECTDRAWSURFACE2) PURE; + STDMETHOD(EnumAttachedSurfaces)(THIS_ LPVOID,LPDDENUMSURFACESCALLBACK) PURE; + STDMETHOD(EnumOverlayZOrders)(THIS_ DWORD,LPVOID,LPDDENUMSURFACESCALLBACK) PURE; + STDMETHOD(Flip)(THIS_ LPDIRECTDRAWSURFACE2, DWORD) PURE; + STDMETHOD(GetAttachedSurface)(THIS_ LPDDSCAPS, LPDIRECTDRAWSURFACE2 FAR *) PURE; + STDMETHOD(GetBltStatus)(THIS_ DWORD) PURE; + STDMETHOD(GetCaps)(THIS_ LPDDSCAPS) PURE; + STDMETHOD(GetClipper)(THIS_ LPDIRECTDRAWCLIPPER FAR*) PURE; + STDMETHOD(GetColorKey)(THIS_ DWORD, LPDDCOLORKEY) PURE; + STDMETHOD(GetDC)(THIS_ HDC FAR *) PURE; + STDMETHOD(GetFlipStatus)(THIS_ DWORD) PURE; + STDMETHOD(GetOverlayPosition)(THIS_ LPLONG, LPLONG ) PURE; + STDMETHOD(GetPalette)(THIS_ LPDIRECTDRAWPALETTE FAR*) PURE; + STDMETHOD(GetPixelFormat)(THIS_ LPDDPIXELFORMAT) PURE; + STDMETHOD(GetSurfaceDesc)(THIS_ LPDDSURFACEDESC) PURE; + STDMETHOD(Initialize)(THIS_ LPDIRECTDRAW, LPDDSURFACEDESC) PURE; + STDMETHOD(IsLost)(THIS) PURE; + STDMETHOD(Lock)(THIS_ LPRECT,LPDDSURFACEDESC,DWORD,HANDLE) PURE; + STDMETHOD(ReleaseDC)(THIS_ HDC) PURE; + STDMETHOD(Restore)(THIS) PURE; + STDMETHOD(SetClipper)(THIS_ LPDIRECTDRAWCLIPPER) PURE; + STDMETHOD(SetColorKey)(THIS_ DWORD, LPDDCOLORKEY) PURE; + STDMETHOD(SetOverlayPosition)(THIS_ LONG, LONG ) PURE; + STDMETHOD(SetPalette)(THIS_ LPDIRECTDRAWPALETTE) PURE; + STDMETHOD(Unlock)(THIS_ LPVOID) PURE; + STDMETHOD(UpdateOverlay)(THIS_ LPRECT, LPDIRECTDRAWSURFACE2,LPRECT,DWORD, LPDDOVERLAYFX) PURE; + STDMETHOD(UpdateOverlayDisplay)(THIS_ DWORD) PURE; + STDMETHOD(UpdateOverlayZOrder)(THIS_ DWORD, LPDIRECTDRAWSURFACE2) PURE; + /*** Added in the v2 interface ***/ + STDMETHOD(GetDDInterface)(THIS_ LPVOID FAR *) PURE; + STDMETHOD(PageLock)(THIS_ DWORD) PURE; + STDMETHOD(PageUnlock)(THIS_ DWORD) PURE; +}; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirectDrawSurface2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirectDrawSurface2_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirectDrawSurface2_Release(p) (p)->lpVtbl->Release(p) +#define IDirectDrawSurface2_AddAttachedSurface(p,a) (p)->lpVtbl->AddAttachedSurface(p,a) +#define IDirectDrawSurface2_AddOverlayDirtyRect(p,a) (p)->lpVtbl->AddOverlayDirtyRect(p,a) +#define IDirectDrawSurface2_Blt(p,a,b,c,d,e) (p)->lpVtbl->Blt(p,a,b,c,d,e) +#define IDirectDrawSurface2_BltBatch(p,a,b,c) (p)->lpVtbl->BltBatch(p,a,b,c) +#define IDirectDrawSurface2_BltFast(p,a,b,c,d,e) (p)->lpVtbl->BltFast(p,a,b,c,d,e) +#define IDirectDrawSurface2_DeleteAttachedSurface(p,a,b) (p)->lpVtbl->DeleteAttachedSurface(p,a,b) +#define IDirectDrawSurface2_EnumAttachedSurfaces(p,a,b) (p)->lpVtbl->EnumAttachedSurfaces(p,a,b) +#define IDirectDrawSurface2_EnumOverlayZOrders(p,a,b,c) (p)->lpVtbl->EnumOverlayZOrders(p,a,b,c) +#define IDirectDrawSurface2_Flip(p,a,b) (p)->lpVtbl->Flip(p,a,b) +#define IDirectDrawSurface2_GetAttachedSurface(p,a,b) (p)->lpVtbl->GetAttachedSurface(p,a,b) +#define IDirectDrawSurface2_GetBltStatus(p,a) (p)->lpVtbl->GetBltStatus(p,a) +#define IDirectDrawSurface2_GetCaps(p,b) (p)->lpVtbl->GetCaps(p,b) +#define IDirectDrawSurface2_GetClipper(p,a) (p)->lpVtbl->GetClipper(p,a) +#define IDirectDrawSurface2_GetColorKey(p,a,b) (p)->lpVtbl->GetColorKey(p,a,b) +#define IDirectDrawSurface2_GetDC(p,a) (p)->lpVtbl->GetDC(p,a) +#define IDirectDrawSurface2_GetFlipStatus(p,a) (p)->lpVtbl->GetFlipStatus(p,a) +#define IDirectDrawSurface2_GetOverlayPosition(p,a,b) (p)->lpVtbl->GetOverlayPosition(p,a,b) +#define IDirectDrawSurface2_GetPalette(p,a) (p)->lpVtbl->GetPalette(p,a) +#define IDirectDrawSurface2_GetPixelFormat(p,a) (p)->lpVtbl->GetPixelFormat(p,a) +#define IDirectDrawSurface2_GetSurfaceDesc(p,a) (p)->lpVtbl->GetSurfaceDesc(p,a) +#define IDirectDrawSurface2_Initialize(p,a,b) (p)->lpVtbl->Initialize(p,a,b) +#define IDirectDrawSurface2_IsLost(p) (p)->lpVtbl->IsLost(p) +#define IDirectDrawSurface2_Lock(p,a,b,c,d) (p)->lpVtbl->Lock(p,a,b,c,d) +#define IDirectDrawSurface2_ReleaseDC(p,a) (p)->lpVtbl->ReleaseDC(p,a) +#define IDirectDrawSurface2_Restore(p) (p)->lpVtbl->Restore(p) +#define IDirectDrawSurface2_SetClipper(p,a) (p)->lpVtbl->SetClipper(p,a) +#define IDirectDrawSurface2_SetColorKey(p,a,b) (p)->lpVtbl->SetColorKey(p,a,b) +#define IDirectDrawSurface2_SetOverlayPosition(p,a,b) (p)->lpVtbl->SetOverlayPosition(p,a,b) +#define IDirectDrawSurface2_SetPalette(p,a) (p)->lpVtbl->SetPalette(p,a) +#define IDirectDrawSurface2_Unlock(p,b) (p)->lpVtbl->Unlock(p,b) +#define IDirectDrawSurface2_UpdateOverlay(p,a,b,c,d,e) (p)->lpVtbl->UpdateOverlay(p,a,b,c,d,e) +#define IDirectDrawSurface2_UpdateOverlayDisplay(p,a) (p)->lpVtbl->UpdateOverlayDisplay(p,a) +#define IDirectDrawSurface2_UpdateOverlayZOrder(p,a,b) (p)->lpVtbl->UpdateOverlayZOrder(p,a,b) +#define IDirectDrawSurface2_GetDDInterface(p,a) (p)->lpVtbl->GetDDInterface(p,a) +#define IDirectDrawSurface2_PageLock(p,a) (p)->lpVtbl->PageLock(p,a) +#define IDirectDrawSurface2_PageUnlock(p,a) (p)->lpVtbl->PageUnlock(p,a) +#else +#define IDirectDrawSurface2_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirectDrawSurface2_AddRef(p) (p)->AddRef() +#define IDirectDrawSurface2_Release(p) (p)->Release() +#define IDirectDrawSurface2_AddAttachedSurface(p,a) (p)->AddAttachedSurface(a) +#define IDirectDrawSurface2_AddOverlayDirtyRect(p,a) (p)->AddOverlayDirtyRect(a) +#define IDirectDrawSurface2_Blt(p,a,b,c,d,e) (p)->Blt(a,b,c,d,e) +#define IDirectDrawSurface2_BltBatch(p,a,b,c) (p)->BltBatch(a,b,c) +#define IDirectDrawSurface2_BltFast(p,a,b,c,d,e) (p)->BltFast(a,b,c,d,e) +#define IDirectDrawSurface2_DeleteAttachedSurface(p,a,b) (p)->DeleteAttachedSurface(a,b) +#define IDirectDrawSurface2_EnumAttachedSurfaces(p,a,b) (p)->EnumAttachedSurfaces(a,b) +#define IDirectDrawSurface2_EnumOverlayZOrders(p,a,b,c) (p)->EnumOverlayZOrders(a,b,c) +#define IDirectDrawSurface2_Flip(p,a,b) (p)->Flip(a,b) +#define IDirectDrawSurface2_GetAttachedSurface(p,a,b) (p)->GetAttachedSurface(a,b) +#define IDirectDrawSurface2_GetBltStatus(p,a) (p)->GetBltStatus(a) +#define IDirectDrawSurface2_GetCaps(p,b) (p)->GetCaps(b) +#define IDirectDrawSurface2_GetClipper(p,a) (p)->GetClipper(a) +#define IDirectDrawSurface2_GetColorKey(p,a,b) (p)->GetColorKey(a,b) +#define IDirectDrawSurface2_GetDC(p,a) (p)->GetDC(a) +#define IDirectDrawSurface2_GetFlipStatus(p,a) (p)->GetFlipStatus(a) +#define IDirectDrawSurface2_GetOverlayPosition(p,a,b) (p)->GetOverlayPosition(a,b) +#define IDirectDrawSurface2_GetPalette(p,a) (p)->GetPalette(a) +#define IDirectDrawSurface2_GetPixelFormat(p,a) (p)->GetPixelFormat(a) +#define IDirectDrawSurface2_GetSurfaceDesc(p,a) (p)->GetSurfaceDesc(a) +#define IDirectDrawSurface2_Initialize(p,a,b) (p)->Initialize(a,b) +#define IDirectDrawSurface2_IsLost(p) (p)->IsLost() +#define IDirectDrawSurface2_Lock(p,a,b,c,d) (p)->Lock(a,b,c,d) +#define IDirectDrawSurface2_ReleaseDC(p,a) (p)->ReleaseDC(a) +#define IDirectDrawSurface2_Restore(p) (p)->Restore() +#define IDirectDrawSurface2_SetClipper(p,a) (p)->SetClipper(a) +#define IDirectDrawSurface2_SetColorKey(p,a,b) (p)->SetColorKey(a,b) +#define IDirectDrawSurface2_SetOverlayPosition(p,a,b) (p)->SetOverlayPosition(a,b) +#define IDirectDrawSurface2_SetPalette(p,a) (p)->SetPalette(a) +#define IDirectDrawSurface2_Unlock(p,b) (p)->Unlock(b) +#define IDirectDrawSurface2_UpdateOverlay(p,a,b,c,d,e) (p)->UpdateOverlay(a,b,c,d,e) +#define IDirectDrawSurface2_UpdateOverlayDisplay(p,a) (p)->UpdateOverlayDisplay(a) +#define IDirectDrawSurface2_UpdateOverlayZOrder(p,a,b) (p)->UpdateOverlayZOrder(a,b) +#define IDirectDrawSurface2_GetDDInterface(p,a) (p)->GetDDInterface(a) +#define IDirectDrawSurface2_PageLock(p,a) (p)->PageLock(a) +#define IDirectDrawSurface2_PageUnlock(p,a) (p)->PageUnlock(a) +#endif + +/* + * IDirectDrawSurface3 and related interfaces + */ +#undef INTERFACE +#define INTERFACE IDirectDrawSurface3 +DECLARE_INTERFACE_( IDirectDrawSurface3, IUnknown ) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + /*** IDirectDrawSurface methods ***/ + STDMETHOD(AddAttachedSurface)(THIS_ LPDIRECTDRAWSURFACE3) PURE; + STDMETHOD(AddOverlayDirtyRect)(THIS_ LPRECT) PURE; + STDMETHOD(Blt)(THIS_ LPRECT,LPDIRECTDRAWSURFACE3, LPRECT,DWORD, LPDDBLTFX) PURE; + STDMETHOD(BltBatch)(THIS_ LPDDBLTBATCH, DWORD, DWORD ) PURE; + STDMETHOD(BltFast)(THIS_ DWORD,DWORD,LPDIRECTDRAWSURFACE3, LPRECT,DWORD) PURE; + STDMETHOD(DeleteAttachedSurface)(THIS_ DWORD,LPDIRECTDRAWSURFACE3) PURE; + STDMETHOD(EnumAttachedSurfaces)(THIS_ LPVOID,LPDDENUMSURFACESCALLBACK) PURE; + STDMETHOD(EnumOverlayZOrders)(THIS_ DWORD,LPVOID,LPDDENUMSURFACESCALLBACK) PURE; + STDMETHOD(Flip)(THIS_ LPDIRECTDRAWSURFACE3, DWORD) PURE; + STDMETHOD(GetAttachedSurface)(THIS_ LPDDSCAPS, LPDIRECTDRAWSURFACE3 FAR *) PURE; + STDMETHOD(GetBltStatus)(THIS_ DWORD) PURE; + STDMETHOD(GetCaps)(THIS_ LPDDSCAPS) PURE; + STDMETHOD(GetClipper)(THIS_ LPDIRECTDRAWCLIPPER FAR*) PURE; + STDMETHOD(GetColorKey)(THIS_ DWORD, LPDDCOLORKEY) PURE; + STDMETHOD(GetDC)(THIS_ HDC FAR *) PURE; + STDMETHOD(GetFlipStatus)(THIS_ DWORD) PURE; + STDMETHOD(GetOverlayPosition)(THIS_ LPLONG, LPLONG ) PURE; + STDMETHOD(GetPalette)(THIS_ LPDIRECTDRAWPALETTE FAR*) PURE; + STDMETHOD(GetPixelFormat)(THIS_ LPDDPIXELFORMAT) PURE; + STDMETHOD(GetSurfaceDesc)(THIS_ LPDDSURFACEDESC) PURE; + STDMETHOD(Initialize)(THIS_ LPDIRECTDRAW, LPDDSURFACEDESC) PURE; + STDMETHOD(IsLost)(THIS) PURE; + STDMETHOD(Lock)(THIS_ LPRECT,LPDDSURFACEDESC,DWORD,HANDLE) PURE; + STDMETHOD(ReleaseDC)(THIS_ HDC) PURE; + STDMETHOD(Restore)(THIS) PURE; + STDMETHOD(SetClipper)(THIS_ LPDIRECTDRAWCLIPPER) PURE; + STDMETHOD(SetColorKey)(THIS_ DWORD, LPDDCOLORKEY) PURE; + STDMETHOD(SetOverlayPosition)(THIS_ LONG, LONG ) PURE; + STDMETHOD(SetPalette)(THIS_ LPDIRECTDRAWPALETTE) PURE; + STDMETHOD(Unlock)(THIS_ LPVOID) PURE; + STDMETHOD(UpdateOverlay)(THIS_ LPRECT, LPDIRECTDRAWSURFACE3,LPRECT,DWORD, LPDDOVERLAYFX) PURE; + STDMETHOD(UpdateOverlayDisplay)(THIS_ DWORD) PURE; + STDMETHOD(UpdateOverlayZOrder)(THIS_ DWORD, LPDIRECTDRAWSURFACE3) PURE; + /*** Added in the v2 interface ***/ + STDMETHOD(GetDDInterface)(THIS_ LPVOID FAR *) PURE; + STDMETHOD(PageLock)(THIS_ DWORD) PURE; + STDMETHOD(PageUnlock)(THIS_ DWORD) PURE; + /*** Added in the V3 interface ***/ + STDMETHOD(SetSurfaceDesc)(THIS_ LPDDSURFACEDESC, DWORD) PURE; +}; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirectDrawSurface3_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirectDrawSurface3_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirectDrawSurface3_Release(p) (p)->lpVtbl->Release(p) +#define IDirectDrawSurface3_AddAttachedSurface(p,a) (p)->lpVtbl->AddAttachedSurface(p,a) +#define IDirectDrawSurface3_AddOverlayDirtyRect(p,a) (p)->lpVtbl->AddOverlayDirtyRect(p,a) +#define IDirectDrawSurface3_Blt(p,a,b,c,d,e) (p)->lpVtbl->Blt(p,a,b,c,d,e) +#define IDirectDrawSurface3_BltBatch(p,a,b,c) (p)->lpVtbl->BltBatch(p,a,b,c) +#define IDirectDrawSurface3_BltFast(p,a,b,c,d,e) (p)->lpVtbl->BltFast(p,a,b,c,d,e) +#define IDirectDrawSurface3_DeleteAttachedSurface(p,a,b) (p)->lpVtbl->DeleteAttachedSurface(p,a,b) +#define IDirectDrawSurface3_EnumAttachedSurfaces(p,a,b) (p)->lpVtbl->EnumAttachedSurfaces(p,a,b) +#define IDirectDrawSurface3_EnumOverlayZOrders(p,a,b,c) (p)->lpVtbl->EnumOverlayZOrders(p,a,b,c) +#define IDirectDrawSurface3_Flip(p,a,b) (p)->lpVtbl->Flip(p,a,b) +#define IDirectDrawSurface3_GetAttachedSurface(p,a,b) (p)->lpVtbl->GetAttachedSurface(p,a,b) +#define IDirectDrawSurface3_GetBltStatus(p,a) (p)->lpVtbl->GetBltStatus(p,a) +#define IDirectDrawSurface3_GetCaps(p,b) (p)->lpVtbl->GetCaps(p,b) +#define IDirectDrawSurface3_GetClipper(p,a) (p)->lpVtbl->GetClipper(p,a) +#define IDirectDrawSurface3_GetColorKey(p,a,b) (p)->lpVtbl->GetColorKey(p,a,b) +#define IDirectDrawSurface3_GetDC(p,a) (p)->lpVtbl->GetDC(p,a) +#define IDirectDrawSurface3_GetFlipStatus(p,a) (p)->lpVtbl->GetFlipStatus(p,a) +#define IDirectDrawSurface3_GetOverlayPosition(p,a,b) (p)->lpVtbl->GetOverlayPosition(p,a,b) +#define IDirectDrawSurface3_GetPalette(p,a) (p)->lpVtbl->GetPalette(p,a) +#define IDirectDrawSurface3_GetPixelFormat(p,a) (p)->lpVtbl->GetPixelFormat(p,a) +#define IDirectDrawSurface3_GetSurfaceDesc(p,a) (p)->lpVtbl->GetSurfaceDesc(p,a) +#define IDirectDrawSurface3_Initialize(p,a,b) (p)->lpVtbl->Initialize(p,a,b) +#define IDirectDrawSurface3_IsLost(p) (p)->lpVtbl->IsLost(p) +#define IDirectDrawSurface3_Lock(p,a,b,c,d) (p)->lpVtbl->Lock(p,a,b,c,d) +#define IDirectDrawSurface3_ReleaseDC(p,a) (p)->lpVtbl->ReleaseDC(p,a) +#define IDirectDrawSurface3_Restore(p) (p)->lpVtbl->Restore(p) +#define IDirectDrawSurface3_SetClipper(p,a) (p)->lpVtbl->SetClipper(p,a) +#define IDirectDrawSurface3_SetColorKey(p,a,b) (p)->lpVtbl->SetColorKey(p,a,b) +#define IDirectDrawSurface3_SetOverlayPosition(p,a,b) (p)->lpVtbl->SetOverlayPosition(p,a,b) +#define IDirectDrawSurface3_SetPalette(p,a) (p)->lpVtbl->SetPalette(p,a) +#define IDirectDrawSurface3_Unlock(p,b) (p)->lpVtbl->Unlock(p,b) +#define IDirectDrawSurface3_UpdateOverlay(p,a,b,c,d,e) (p)->lpVtbl->UpdateOverlay(p,a,b,c,d,e) +#define IDirectDrawSurface3_UpdateOverlayDisplay(p,a) (p)->lpVtbl->UpdateOverlayDisplay(p,a) +#define IDirectDrawSurface3_UpdateOverlayZOrder(p,a,b) (p)->lpVtbl->UpdateOverlayZOrder(p,a,b) +#define IDirectDrawSurface3_GetDDInterface(p,a) (p)->lpVtbl->GetDDInterface(p,a) +#define IDirectDrawSurface3_PageLock(p,a) (p)->lpVtbl->PageLock(p,a) +#define IDirectDrawSurface3_PageUnlock(p,a) (p)->lpVtbl->PageUnlock(p,a) +#define IDirectDrawSurface3_SetSurfaceDesc(p,a,b) (p)->lpVtbl->SetSurfaceDesc(p,a,b) +#else +#define IDirectDrawSurface3_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirectDrawSurface3_AddRef(p) (p)->AddRef() +#define IDirectDrawSurface3_Release(p) (p)->Release() +#define IDirectDrawSurface3_AddAttachedSurface(p,a) (p)->AddAttachedSurface(a) +#define IDirectDrawSurface3_AddOverlayDirtyRect(p,a) (p)->AddOverlayDirtyRect(a) +#define IDirectDrawSurface3_Blt(p,a,b,c,d,e) (p)->Blt(a,b,c,d,e) +#define IDirectDrawSurface3_BltBatch(p,a,b,c) (p)->BltBatch(a,b,c) +#define IDirectDrawSurface3_BltFast(p,a,b,c,d,e) (p)->BltFast(a,b,c,d,e) +#define IDirectDrawSurface3_DeleteAttachedSurface(p,a,b) (p)->DeleteAttachedSurface(a,b) +#define IDirectDrawSurface3_EnumAttachedSurfaces(p,a,b) (p)->EnumAttachedSurfaces(a,b) +#define IDirectDrawSurface3_EnumOverlayZOrders(p,a,b,c) (p)->EnumOverlayZOrders(a,b,c) +#define IDirectDrawSurface3_Flip(p,a,b) (p)->Flip(a,b) +#define IDirectDrawSurface3_GetAttachedSurface(p,a,b) (p)->GetAttachedSurface(a,b) +#define IDirectDrawSurface3_GetBltStatus(p,a) (p)->GetBltStatus(a) +#define IDirectDrawSurface3_GetCaps(p,b) (p)->GetCaps(b) +#define IDirectDrawSurface3_GetClipper(p,a) (p)->GetClipper(a) +#define IDirectDrawSurface3_GetColorKey(p,a,b) (p)->GetColorKey(a,b) +#define IDirectDrawSurface3_GetDC(p,a) (p)->GetDC(a) +#define IDirectDrawSurface3_GetFlipStatus(p,a) (p)->GetFlipStatus(a) +#define IDirectDrawSurface3_GetOverlayPosition(p,a,b) (p)->GetOverlayPosition(a,b) +#define IDirectDrawSurface3_GetPalette(p,a) (p)->GetPalette(a) +#define IDirectDrawSurface3_GetPixelFormat(p,a) (p)->GetPixelFormat(a) +#define IDirectDrawSurface3_GetSurfaceDesc(p,a) (p)->GetSurfaceDesc(a) +#define IDirectDrawSurface3_Initialize(p,a,b) (p)->Initialize(a,b) +#define IDirectDrawSurface3_IsLost(p) (p)->IsLost() +#define IDirectDrawSurface3_Lock(p,a,b,c,d) (p)->Lock(a,b,c,d) +#define IDirectDrawSurface3_ReleaseDC(p,a) (p)->ReleaseDC(a) +#define IDirectDrawSurface3_Restore(p) (p)->Restore() +#define IDirectDrawSurface3_SetClipper(p,a) (p)->SetClipper(a) +#define IDirectDrawSurface3_SetColorKey(p,a,b) (p)->SetColorKey(a,b) +#define IDirectDrawSurface3_SetOverlayPosition(p,a,b) (p)->SetOverlayPosition(a,b) +#define IDirectDrawSurface3_SetPalette(p,a) (p)->SetPalette(a) +#define IDirectDrawSurface3_Unlock(p,b) (p)->Unlock(b) +#define IDirectDrawSurface3_UpdateOverlay(p,a,b,c,d,e) (p)->UpdateOverlay(a,b,c,d,e) +#define IDirectDrawSurface3_UpdateOverlayDisplay(p,a) (p)->UpdateOverlayDisplay(a) +#define IDirectDrawSurface3_UpdateOverlayZOrder(p,a,b) (p)->UpdateOverlayZOrder(a,b) +#define IDirectDrawSurface3_GetDDInterface(p,a) (p)->GetDDInterface(a) +#define IDirectDrawSurface3_PageLock(p,a) (p)->PageLock(a) +#define IDirectDrawSurface3_PageUnlock(p,a) (p)->PageUnlock(a) +#define IDirectDrawSurface3_SetSurfaceDesc(p,a,b) (p)->SetSurfaceDesc(a,b) +#endif + +/* + * IDirectDrawSurface4 and related interfaces + */ +#undef INTERFACE +#define INTERFACE IDirectDrawSurface4 +DECLARE_INTERFACE_( IDirectDrawSurface4, IUnknown ) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + /*** IDirectDrawSurface methods ***/ + STDMETHOD(AddAttachedSurface)(THIS_ LPDIRECTDRAWSURFACE4) PURE; + STDMETHOD(AddOverlayDirtyRect)(THIS_ LPRECT) PURE; + STDMETHOD(Blt)(THIS_ LPRECT,LPDIRECTDRAWSURFACE4, LPRECT,DWORD, LPDDBLTFX) PURE; + STDMETHOD(BltBatch)(THIS_ LPDDBLTBATCH, DWORD, DWORD ) PURE; + STDMETHOD(BltFast)(THIS_ DWORD,DWORD,LPDIRECTDRAWSURFACE4, LPRECT,DWORD) PURE; + STDMETHOD(DeleteAttachedSurface)(THIS_ DWORD,LPDIRECTDRAWSURFACE4) PURE; + STDMETHOD(EnumAttachedSurfaces)(THIS_ LPVOID,LPDDENUMSURFACESCALLBACK2) PURE; + STDMETHOD(EnumOverlayZOrders)(THIS_ DWORD,LPVOID,LPDDENUMSURFACESCALLBACK2) PURE; + STDMETHOD(Flip)(THIS_ LPDIRECTDRAWSURFACE4, DWORD) PURE; + STDMETHOD(GetAttachedSurface)(THIS_ LPDDSCAPS2, LPDIRECTDRAWSURFACE4 FAR *) PURE; + STDMETHOD(GetBltStatus)(THIS_ DWORD) PURE; + STDMETHOD(GetCaps)(THIS_ LPDDSCAPS2) PURE; + STDMETHOD(GetClipper)(THIS_ LPDIRECTDRAWCLIPPER FAR*) PURE; + STDMETHOD(GetColorKey)(THIS_ DWORD, LPDDCOLORKEY) PURE; + STDMETHOD(GetDC)(THIS_ HDC FAR *) PURE; + STDMETHOD(GetFlipStatus)(THIS_ DWORD) PURE; + STDMETHOD(GetOverlayPosition)(THIS_ LPLONG, LPLONG ) PURE; + STDMETHOD(GetPalette)(THIS_ LPDIRECTDRAWPALETTE FAR*) PURE; + STDMETHOD(GetPixelFormat)(THIS_ LPDDPIXELFORMAT) PURE; + STDMETHOD(GetSurfaceDesc)(THIS_ LPDDSURFACEDESC2) PURE; + STDMETHOD(Initialize)(THIS_ LPDIRECTDRAW, LPDDSURFACEDESC2) PURE; + STDMETHOD(IsLost)(THIS) PURE; + STDMETHOD(Lock)(THIS_ LPRECT,LPDDSURFACEDESC2,DWORD,HANDLE) PURE; + STDMETHOD(ReleaseDC)(THIS_ HDC) PURE; + STDMETHOD(Restore)(THIS) PURE; + STDMETHOD(SetClipper)(THIS_ LPDIRECTDRAWCLIPPER) PURE; + STDMETHOD(SetColorKey)(THIS_ DWORD, LPDDCOLORKEY) PURE; + STDMETHOD(SetOverlayPosition)(THIS_ LONG, LONG ) PURE; + STDMETHOD(SetPalette)(THIS_ LPDIRECTDRAWPALETTE) PURE; + STDMETHOD(Unlock)(THIS_ LPRECT) PURE; + STDMETHOD(UpdateOverlay)(THIS_ LPRECT, LPDIRECTDRAWSURFACE4,LPRECT,DWORD, LPDDOVERLAYFX) PURE; + STDMETHOD(UpdateOverlayDisplay)(THIS_ DWORD) PURE; + STDMETHOD(UpdateOverlayZOrder)(THIS_ DWORD, LPDIRECTDRAWSURFACE4) PURE; + /*** Added in the v2 interface ***/ + STDMETHOD(GetDDInterface)(THIS_ LPVOID FAR *) PURE; + STDMETHOD(PageLock)(THIS_ DWORD) PURE; + STDMETHOD(PageUnlock)(THIS_ DWORD) PURE; + /*** Added in the v3 interface ***/ + STDMETHOD(SetSurfaceDesc)(THIS_ LPDDSURFACEDESC2, DWORD) PURE; + /*** Added in the v4 interface ***/ + STDMETHOD(SetPrivateData)(THIS_ REFGUID, LPVOID, DWORD, DWORD) PURE; + STDMETHOD(GetPrivateData)(THIS_ REFGUID, LPVOID, LPDWORD) PURE; + STDMETHOD(FreePrivateData)(THIS_ REFGUID) PURE; + STDMETHOD(GetUniquenessValue)(THIS_ LPDWORD) PURE; + STDMETHOD(ChangeUniquenessValue)(THIS) PURE; +}; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirectDrawSurface4_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirectDrawSurface4_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirectDrawSurface4_Release(p) (p)->lpVtbl->Release(p) +#define IDirectDrawSurface4_AddAttachedSurface(p,a) (p)->lpVtbl->AddAttachedSurface(p,a) +#define IDirectDrawSurface4_AddOverlayDirtyRect(p,a) (p)->lpVtbl->AddOverlayDirtyRect(p,a) +#define IDirectDrawSurface4_Blt(p,a,b,c,d,e) (p)->lpVtbl->Blt(p,a,b,c,d,e) +#define IDirectDrawSurface4_BltBatch(p,a,b,c) (p)->lpVtbl->BltBatch(p,a,b,c) +#define IDirectDrawSurface4_BltFast(p,a,b,c,d,e) (p)->lpVtbl->BltFast(p,a,b,c,d,e) +#define IDirectDrawSurface4_DeleteAttachedSurface(p,a,b) (p)->lpVtbl->DeleteAttachedSurface(p,a,b) +#define IDirectDrawSurface4_EnumAttachedSurfaces(p,a,b) (p)->lpVtbl->EnumAttachedSurfaces(p,a,b) +#define IDirectDrawSurface4_EnumOverlayZOrders(p,a,b,c) (p)->lpVtbl->EnumOverlayZOrders(p,a,b,c) +#define IDirectDrawSurface4_Flip(p,a,b) (p)->lpVtbl->Flip(p,a,b) +#define IDirectDrawSurface4_GetAttachedSurface(p,a,b) (p)->lpVtbl->GetAttachedSurface(p,a,b) +#define IDirectDrawSurface4_GetBltStatus(p,a) (p)->lpVtbl->GetBltStatus(p,a) +#define IDirectDrawSurface4_GetCaps(p,b) (p)->lpVtbl->GetCaps(p,b) +#define IDirectDrawSurface4_GetClipper(p,a) (p)->lpVtbl->GetClipper(p,a) +#define IDirectDrawSurface4_GetColorKey(p,a,b) (p)->lpVtbl->GetColorKey(p,a,b) +#define IDirectDrawSurface4_GetDC(p,a) (p)->lpVtbl->GetDC(p,a) +#define IDirectDrawSurface4_GetFlipStatus(p,a) (p)->lpVtbl->GetFlipStatus(p,a) +#define IDirectDrawSurface4_GetOverlayPosition(p,a,b) (p)->lpVtbl->GetOverlayPosition(p,a,b) +#define IDirectDrawSurface4_GetPalette(p,a) (p)->lpVtbl->GetPalette(p,a) +#define IDirectDrawSurface4_GetPixelFormat(p,a) (p)->lpVtbl->GetPixelFormat(p,a) +#define IDirectDrawSurface4_GetSurfaceDesc(p,a) (p)->lpVtbl->GetSurfaceDesc(p,a) +#define IDirectDrawSurface4_Initialize(p,a,b) (p)->lpVtbl->Initialize(p,a,b) +#define IDirectDrawSurface4_IsLost(p) (p)->lpVtbl->IsLost(p) +#define IDirectDrawSurface4_Lock(p,a,b,c,d) (p)->lpVtbl->Lock(p,a,b,c,d) +#define IDirectDrawSurface4_ReleaseDC(p,a) (p)->lpVtbl->ReleaseDC(p,a) +#define IDirectDrawSurface4_Restore(p) (p)->lpVtbl->Restore(p) +#define IDirectDrawSurface4_SetClipper(p,a) (p)->lpVtbl->SetClipper(p,a) +#define IDirectDrawSurface4_SetColorKey(p,a,b) (p)->lpVtbl->SetColorKey(p,a,b) +#define IDirectDrawSurface4_SetOverlayPosition(p,a,b) (p)->lpVtbl->SetOverlayPosition(p,a,b) +#define IDirectDrawSurface4_SetPalette(p,a) (p)->lpVtbl->SetPalette(p,a) +#define IDirectDrawSurface4_Unlock(p,b) (p)->lpVtbl->Unlock(p,b) +#define IDirectDrawSurface4_UpdateOverlay(p,a,b,c,d,e) (p)->lpVtbl->UpdateOverlay(p,a,b,c,d,e) +#define IDirectDrawSurface4_UpdateOverlayDisplay(p,a) (p)->lpVtbl->UpdateOverlayDisplay(p,a) +#define IDirectDrawSurface4_UpdateOverlayZOrder(p,a,b) (p)->lpVtbl->UpdateOverlayZOrder(p,a,b) +#define IDirectDrawSurface4_GetDDInterface(p,a) (p)->lpVtbl->GetDDInterface(p,a) +#define IDirectDrawSurface4_PageLock(p,a) (p)->lpVtbl->PageLock(p,a) +#define IDirectDrawSurface4_PageUnlock(p,a) (p)->lpVtbl->PageUnlock(p,a) +#define IDirectDrawSurface4_SetSurfaceDesc(p,a,b) (p)->lpVtbl->SetSurfaceDesc(p,a,b) +#define IDirectDrawSurface4_SetPrivateData(p,a,b,c,d) (p)->lpVtbl->SetPrivateData(p,a,b,c,d) +#define IDirectDrawSurface4_GetPrivateData(p,a,b,c) (p)->lpVtbl->GetPrivateData(p,a,b,c) +#define IDirectDrawSurface4_FreePrivateData(p,a) (p)->lpVtbl->FreePrivateData(p,a) +#define IDirectDrawSurface4_GetUniquenessValue(p, a) (p)->lpVtbl->GetUniquenessValue(p, a) +#define IDirectDrawSurface4_ChangeUniquenessValue(p) (p)->lpVtbl->ChangeUniquenessValue(p) +#else +#define IDirectDrawSurface4_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirectDrawSurface4_AddRef(p) (p)->AddRef() +#define IDirectDrawSurface4_Release(p) (p)->Release() +#define IDirectDrawSurface4_AddAttachedSurface(p,a) (p)->AddAttachedSurface(a) +#define IDirectDrawSurface4_AddOverlayDirtyRect(p,a) (p)->AddOverlayDirtyRect(a) +#define IDirectDrawSurface4_Blt(p,a,b,c,d,e) (p)->Blt(a,b,c,d,e) +#define IDirectDrawSurface4_BltBatch(p,a,b,c) (p)->BltBatch(a,b,c) +#define IDirectDrawSurface4_BltFast(p,a,b,c,d,e) (p)->BltFast(a,b,c,d,e) +#define IDirectDrawSurface4_DeleteAttachedSurface(p,a,b) (p)->DeleteAttachedSurface(a,b) +#define IDirectDrawSurface4_EnumAttachedSurfaces(p,a,b) (p)->EnumAttachedSurfaces(a,b) +#define IDirectDrawSurface4_EnumOverlayZOrders(p,a,b,c) (p)->EnumOverlayZOrders(a,b,c) +#define IDirectDrawSurface4_Flip(p,a,b) (p)->Flip(a,b) +#define IDirectDrawSurface4_GetAttachedSurface(p,a,b) (p)->GetAttachedSurface(a,b) +#define IDirectDrawSurface4_GetBltStatus(p,a) (p)->GetBltStatus(a) +#define IDirectDrawSurface4_GetCaps(p,b) (p)->GetCaps(b) +#define IDirectDrawSurface4_GetClipper(p,a) (p)->GetClipper(a) +#define IDirectDrawSurface4_GetColorKey(p,a,b) (p)->GetColorKey(a,b) +#define IDirectDrawSurface4_GetDC(p,a) (p)->GetDC(a) +#define IDirectDrawSurface4_GetFlipStatus(p,a) (p)->GetFlipStatus(a) +#define IDirectDrawSurface4_GetOverlayPosition(p,a,b) (p)->GetOverlayPosition(a,b) +#define IDirectDrawSurface4_GetPalette(p,a) (p)->GetPalette(a) +#define IDirectDrawSurface4_GetPixelFormat(p,a) (p)->GetPixelFormat(a) +#define IDirectDrawSurface4_GetSurfaceDesc(p,a) (p)->GetSurfaceDesc(a) +#define IDirectDrawSurface4_Initialize(p,a,b) (p)->Initialize(a,b) +#define IDirectDrawSurface4_IsLost(p) (p)->IsLost() +#define IDirectDrawSurface4_Lock(p,a,b,c,d) (p)->Lock(a,b,c,d) +#define IDirectDrawSurface4_ReleaseDC(p,a) (p)->ReleaseDC(a) +#define IDirectDrawSurface4_Restore(p) (p)->Restore() +#define IDirectDrawSurface4_SetClipper(p,a) (p)->SetClipper(a) +#define IDirectDrawSurface4_SetColorKey(p,a,b) (p)->SetColorKey(a,b) +#define IDirectDrawSurface4_SetOverlayPosition(p,a,b) (p)->SetOverlayPosition(a,b) +#define IDirectDrawSurface4_SetPalette(p,a) (p)->SetPalette(a) +#define IDirectDrawSurface4_Unlock(p,b) (p)->Unlock(b) +#define IDirectDrawSurface4_UpdateOverlay(p,a,b,c,d,e) (p)->UpdateOverlay(a,b,c,d,e) +#define IDirectDrawSurface4_UpdateOverlayDisplay(p,a) (p)->UpdateOverlayDisplay(a) +#define IDirectDrawSurface4_UpdateOverlayZOrder(p,a,b) (p)->UpdateOverlayZOrder(a,b) +#define IDirectDrawSurface4_GetDDInterface(p,a) (p)->GetDDInterface(a) +#define IDirectDrawSurface4_PageLock(p,a) (p)->PageLock(a) +#define IDirectDrawSurface4_PageUnlock(p,a) (p)->PageUnlock(a) +#define IDirectDrawSurface4_SetSurfaceDesc(p,a,b) (p)->SetSurfaceDesc(a,b) +#define IDirectDrawSurface4_SetPrivateData(p,a,b,c,d) (p)->SetPrivateData(a,b,c,d) +#define IDirectDrawSurface4_GetPrivateData(p,a,b,c) (p)->GetPrivateData(a,b,c) +#define IDirectDrawSurface4_FreePrivateData(p,a) (p)->FreePrivateData(a) +#define IDirectDrawSurface4_GetUniquenessValue(p, a) (p)->GetUniquenessValue(a) +#define IDirectDrawSurface4_ChangeUniquenessValue(p) (p)->ChangeUniquenessValue() +#endif + +/* + * IDirectDrawSurface7 and related interfaces + */ +#undef INTERFACE +#define INTERFACE IDirectDrawSurface7 +DECLARE_INTERFACE_( IDirectDrawSurface7, IUnknown ) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + /*** IDirectDrawSurface methods ***/ + STDMETHOD(AddAttachedSurface)(THIS_ LPDIRECTDRAWSURFACE7) PURE; + STDMETHOD(AddOverlayDirtyRect)(THIS_ LPRECT) PURE; + STDMETHOD(Blt)(THIS_ LPRECT,LPDIRECTDRAWSURFACE7, LPRECT,DWORD, LPDDBLTFX) PURE; + STDMETHOD(BltBatch)(THIS_ LPDDBLTBATCH, DWORD, DWORD ) PURE; + STDMETHOD(BltFast)(THIS_ DWORD,DWORD,LPDIRECTDRAWSURFACE7, LPRECT,DWORD) PURE; + STDMETHOD(DeleteAttachedSurface)(THIS_ DWORD,LPDIRECTDRAWSURFACE7) PURE; + STDMETHOD(EnumAttachedSurfaces)(THIS_ LPVOID,LPDDENUMSURFACESCALLBACK7) PURE; + STDMETHOD(EnumOverlayZOrders)(THIS_ DWORD,LPVOID,LPDDENUMSURFACESCALLBACK7) PURE; + STDMETHOD(Flip)(THIS_ LPDIRECTDRAWSURFACE7, DWORD) PURE; + STDMETHOD(GetAttachedSurface)(THIS_ LPDDSCAPS2, LPDIRECTDRAWSURFACE7 FAR *) PURE; + STDMETHOD(GetBltStatus)(THIS_ DWORD) PURE; + STDMETHOD(GetCaps)(THIS_ LPDDSCAPS2) PURE; + STDMETHOD(GetClipper)(THIS_ LPDIRECTDRAWCLIPPER FAR*) PURE; + STDMETHOD(GetColorKey)(THIS_ DWORD, LPDDCOLORKEY) PURE; + STDMETHOD(GetDC)(THIS_ HDC FAR *) PURE; + STDMETHOD(GetFlipStatus)(THIS_ DWORD) PURE; + STDMETHOD(GetOverlayPosition)(THIS_ LPLONG, LPLONG ) PURE; + STDMETHOD(GetPalette)(THIS_ LPDIRECTDRAWPALETTE FAR*) PURE; + STDMETHOD(GetPixelFormat)(THIS_ LPDDPIXELFORMAT) PURE; + STDMETHOD(GetSurfaceDesc)(THIS_ LPDDSURFACEDESC2) PURE; + STDMETHOD(Initialize)(THIS_ LPDIRECTDRAW, LPDDSURFACEDESC2) PURE; + STDMETHOD(IsLost)(THIS) PURE; + STDMETHOD(Lock)(THIS_ LPRECT,LPDDSURFACEDESC2,DWORD,HANDLE) PURE; + STDMETHOD(ReleaseDC)(THIS_ HDC) PURE; + STDMETHOD(Restore)(THIS) PURE; + STDMETHOD(SetClipper)(THIS_ LPDIRECTDRAWCLIPPER) PURE; + STDMETHOD(SetColorKey)(THIS_ DWORD, LPDDCOLORKEY) PURE; + STDMETHOD(SetOverlayPosition)(THIS_ LONG, LONG ) PURE; + STDMETHOD(SetPalette)(THIS_ LPDIRECTDRAWPALETTE) PURE; + STDMETHOD(Unlock)(THIS_ LPRECT) PURE; + STDMETHOD(UpdateOverlay)(THIS_ LPRECT, LPDIRECTDRAWSURFACE7,LPRECT,DWORD, LPDDOVERLAYFX) PURE; + STDMETHOD(UpdateOverlayDisplay)(THIS_ DWORD) PURE; + STDMETHOD(UpdateOverlayZOrder)(THIS_ DWORD, LPDIRECTDRAWSURFACE7) PURE; + /*** Added in the v2 interface ***/ + STDMETHOD(GetDDInterface)(THIS_ LPVOID FAR *) PURE; + STDMETHOD(PageLock)(THIS_ DWORD) PURE; + STDMETHOD(PageUnlock)(THIS_ DWORD) PURE; + /*** Added in the v3 interface ***/ + STDMETHOD(SetSurfaceDesc)(THIS_ LPDDSURFACEDESC2, DWORD) PURE; + /*** Added in the v4 interface ***/ + STDMETHOD(SetPrivateData)(THIS_ REFGUID, LPVOID, DWORD, DWORD) PURE; + STDMETHOD(GetPrivateData)(THIS_ REFGUID, LPVOID, LPDWORD) PURE; + STDMETHOD(FreePrivateData)(THIS_ REFGUID) PURE; + STDMETHOD(GetUniquenessValue)(THIS_ LPDWORD) PURE; + STDMETHOD(ChangeUniquenessValue)(THIS) PURE; + /*** Moved Texture7 methods here ***/ + STDMETHOD(SetPriority)(THIS_ DWORD) PURE; + STDMETHOD(GetPriority)(THIS_ LPDWORD) PURE; + STDMETHOD(SetLOD)(THIS_ DWORD) PURE; + STDMETHOD(GetLOD)(THIS_ LPDWORD) PURE; +}; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirectDrawSurface7_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IDirectDrawSurface7_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirectDrawSurface7_Release(p) (p)->lpVtbl->Release(p) +#define IDirectDrawSurface7_AddAttachedSurface(p,a) (p)->lpVtbl->AddAttachedSurface(p,a) +#define IDirectDrawSurface7_AddOverlayDirtyRect(p,a) (p)->lpVtbl->AddOverlayDirtyRect(p,a) +#define IDirectDrawSurface7_Blt(p,a,b,c,d,e) (p)->lpVtbl->Blt(p,a,b,c,d,e) +#define IDirectDrawSurface7_BltBatch(p,a,b,c) (p)->lpVtbl->BltBatch(p,a,b,c) +#define IDirectDrawSurface7_BltFast(p,a,b,c,d,e) (p)->lpVtbl->BltFast(p,a,b,c,d,e) +#define IDirectDrawSurface7_DeleteAttachedSurface(p,a,b) (p)->lpVtbl->DeleteAttachedSurface(p,a,b) +#define IDirectDrawSurface7_EnumAttachedSurfaces(p,a,b) (p)->lpVtbl->EnumAttachedSurfaces(p,a,b) +#define IDirectDrawSurface7_EnumOverlayZOrders(p,a,b,c) (p)->lpVtbl->EnumOverlayZOrders(p,a,b,c) +#define IDirectDrawSurface7_Flip(p,a,b) (p)->lpVtbl->Flip(p,a,b) +#define IDirectDrawSurface7_GetAttachedSurface(p,a,b) (p)->lpVtbl->GetAttachedSurface(p,a,b) +#define IDirectDrawSurface7_GetBltStatus(p,a) (p)->lpVtbl->GetBltStatus(p,a) +#define IDirectDrawSurface7_GetCaps(p,b) (p)->lpVtbl->GetCaps(p,b) +#define IDirectDrawSurface7_GetClipper(p,a) (p)->lpVtbl->GetClipper(p,a) +#define IDirectDrawSurface7_GetColorKey(p,a,b) (p)->lpVtbl->GetColorKey(p,a,b) +#define IDirectDrawSurface7_GetDC(p,a) (p)->lpVtbl->GetDC(p,a) +#define IDirectDrawSurface7_GetFlipStatus(p,a) (p)->lpVtbl->GetFlipStatus(p,a) +#define IDirectDrawSurface7_GetOverlayPosition(p,a,b) (p)->lpVtbl->GetOverlayPosition(p,a,b) +#define IDirectDrawSurface7_GetPalette(p,a) (p)->lpVtbl->GetPalette(p,a) +#define IDirectDrawSurface7_GetPixelFormat(p,a) (p)->lpVtbl->GetPixelFormat(p,a) +#define IDirectDrawSurface7_GetSurfaceDesc(p,a) (p)->lpVtbl->GetSurfaceDesc(p,a) +#define IDirectDrawSurface7_Initialize(p,a,b) (p)->lpVtbl->Initialize(p,a,b) +#define IDirectDrawSurface7_IsLost(p) (p)->lpVtbl->IsLost(p) +#define IDirectDrawSurface7_Lock(p,a,b,c,d) (p)->lpVtbl->Lock(p,a,b,c,d) +#define IDirectDrawSurface7_ReleaseDC(p,a) (p)->lpVtbl->ReleaseDC(p,a) +#define IDirectDrawSurface7_Restore(p) (p)->lpVtbl->Restore(p) +#define IDirectDrawSurface7_SetClipper(p,a) (p)->lpVtbl->SetClipper(p,a) +#define IDirectDrawSurface7_SetColorKey(p,a,b) (p)->lpVtbl->SetColorKey(p,a,b) +#define IDirectDrawSurface7_SetOverlayPosition(p,a,b) (p)->lpVtbl->SetOverlayPosition(p,a,b) +#define IDirectDrawSurface7_SetPalette(p,a) (p)->lpVtbl->SetPalette(p,a) +#define IDirectDrawSurface7_Unlock(p,b) (p)->lpVtbl->Unlock(p,b) +#define IDirectDrawSurface7_UpdateOverlay(p,a,b,c,d,e) (p)->lpVtbl->UpdateOverlay(p,a,b,c,d,e) +#define IDirectDrawSurface7_UpdateOverlayDisplay(p,a) (p)->lpVtbl->UpdateOverlayDisplay(p,a) +#define IDirectDrawSurface7_UpdateOverlayZOrder(p,a,b) (p)->lpVtbl->UpdateOverlayZOrder(p,a,b) +#define IDirectDrawSurface7_GetDDInterface(p,a) (p)->lpVtbl->GetDDInterface(p,a) +#define IDirectDrawSurface7_PageLock(p,a) (p)->lpVtbl->PageLock(p,a) +#define IDirectDrawSurface7_PageUnlock(p,a) (p)->lpVtbl->PageUnlock(p,a) +#define IDirectDrawSurface7_SetSurfaceDesc(p,a,b) (p)->lpVtbl->SetSurfaceDesc(p,a,b) +#define IDirectDrawSurface7_SetPrivateData(p,a,b,c,d) (p)->lpVtbl->SetPrivateData(p,a,b,c,d) +#define IDirectDrawSurface7_GetPrivateData(p,a,b,c) (p)->lpVtbl->GetPrivateData(p,a,b,c) +#define IDirectDrawSurface7_FreePrivateData(p,a) (p)->lpVtbl->FreePrivateData(p,a) +#define IDirectDrawSurface7_GetUniquenessValue(p, a) (p)->lpVtbl->GetUniquenessValue(p, a) +#define IDirectDrawSurface7_ChangeUniquenessValue(p) (p)->lpVtbl->ChangeUniquenessValue(p) +#define IDirectDrawSurface7_SetPriority(p,a) (p)->lpVtbl->SetPriority(p,a) +#define IDirectDrawSurface7_GetPriority(p,a) (p)->lpVtbl->GetPriority(p,a) +#define IDirectDrawSurface7_SetLOD(p,a) (p)->lpVtbl->SetLOD(p,a) +#define IDirectDrawSurface7_GetLOD(p,a) (p)->lpVtbl->GetLOD(p,a) +#else +#define IDirectDrawSurface7_QueryInterface(p,a,b) (p)->QueryInterface(a,b) +#define IDirectDrawSurface7_AddRef(p) (p)->AddRef() +#define IDirectDrawSurface7_Release(p) (p)->Release() +#define IDirectDrawSurface7_AddAttachedSurface(p,a) (p)->AddAttachedSurface(a) +#define IDirectDrawSurface7_AddOverlayDirtyRect(p,a) (p)->AddOverlayDirtyRect(a) +#define IDirectDrawSurface7_Blt(p,a,b,c,d,e) (p)->Blt(a,b,c,d,e) +#define IDirectDrawSurface7_BltBatch(p,a,b,c) (p)->BltBatch(a,b,c) +#define IDirectDrawSurface7_BltFast(p,a,b,c,d,e) (p)->BltFast(a,b,c,d,e) +#define IDirectDrawSurface7_DeleteAttachedSurface(p,a,b) (p)->DeleteAttachedSurface(a,b) +#define IDirectDrawSurface7_EnumAttachedSurfaces(p,a,b) (p)->EnumAttachedSurfaces(a,b) +#define IDirectDrawSurface7_EnumOverlayZOrders(p,a,b,c) (p)->EnumOverlayZOrders(a,b,c) +#define IDirectDrawSurface7_Flip(p,a,b) (p)->Flip(a,b) +#define IDirectDrawSurface7_GetAttachedSurface(p,a,b) (p)->GetAttachedSurface(a,b) +#define IDirectDrawSurface7_GetBltStatus(p,a) (p)->GetBltStatus(a) +#define IDirectDrawSurface7_GetCaps(p,b) (p)->GetCaps(b) +#define IDirectDrawSurface7_GetClipper(p,a) (p)->GetClipper(a) +#define IDirectDrawSurface7_GetColorKey(p,a,b) (p)->GetColorKey(a,b) +#define IDirectDrawSurface7_GetDC(p,a) (p)->GetDC(a) +#define IDirectDrawSurface7_GetFlipStatus(p,a) (p)->GetFlipStatus(a) +#define IDirectDrawSurface7_GetOverlayPosition(p,a,b) (p)->GetOverlayPosition(a,b) +#define IDirectDrawSurface7_GetPalette(p,a) (p)->GetPalette(a) +#define IDirectDrawSurface7_GetPixelFormat(p,a) (p)->GetPixelFormat(a) +#define IDirectDrawSurface7_GetSurfaceDesc(p,a) (p)->GetSurfaceDesc(a) +#define IDirectDrawSurface7_Initialize(p,a,b) (p)->Initialize(a,b) +#define IDirectDrawSurface7_IsLost(p) (p)->IsLost() +#define IDirectDrawSurface7_Lock(p,a,b,c,d) (p)->Lock(a,b,c,d) +#define IDirectDrawSurface7_ReleaseDC(p,a) (p)->ReleaseDC(a) +#define IDirectDrawSurface7_Restore(p) (p)->Restore() +#define IDirectDrawSurface7_SetClipper(p,a) (p)->SetClipper(a) +#define IDirectDrawSurface7_SetColorKey(p,a,b) (p)->SetColorKey(a,b) +#define IDirectDrawSurface7_SetOverlayPosition(p,a,b) (p)->SetOverlayPosition(a,b) +#define IDirectDrawSurface7_SetPalette(p,a) (p)->SetPalette(a) +#define IDirectDrawSurface7_Unlock(p,b) (p)->Unlock(b) +#define IDirectDrawSurface7_UpdateOverlay(p,a,b,c,d,e) (p)->UpdateOverlay(a,b,c,d,e) +#define IDirectDrawSurface7_UpdateOverlayDisplay(p,a) (p)->UpdateOverlayDisplay(a) +#define IDirectDrawSurface7_UpdateOverlayZOrder(p,a,b) (p)->UpdateOverlayZOrder(a,b) +#define IDirectDrawSurface7_GetDDInterface(p,a) (p)->GetDDInterface(a) +#define IDirectDrawSurface7_PageLock(p,a) (p)->PageLock(a) +#define IDirectDrawSurface7_PageUnlock(p,a) (p)->PageUnlock(a) +#define IDirectDrawSurface7_SetSurfaceDesc(p,a,b) (p)->SetSurfaceDesc(a,b) +#define IDirectDrawSurface7_SetPrivateData(p,a,b,c,d) (p)->SetPrivateData(a,b,c,d) +#define IDirectDrawSurface7_GetPrivateData(p,a,b,c) (p)->GetPrivateData(a,b,c) +#define IDirectDrawSurface7_FreePrivateData(p,a) (p)->FreePrivateData(a) +#define IDirectDrawSurface7_GetUniquenessValue(p, a) (p)->GetUniquenessValue(a) +#define IDirectDrawSurface7_ChangeUniquenessValue(p) (p)->ChangeUniquenessValue() +#define IDirectDrawSurface7_SetPriority(p,a) (p)->SetPriority(a) +#define IDirectDrawSurface7_GetPriority(p,a) (p)->GetPriority(a) +#define IDirectDrawSurface7_SetLOD(p,a) (p)->SetLOD(a) +#define IDirectDrawSurface7_GetLOD(p,a) (p)->GetLOD(a) +#endif + + + +/* + * IDirectDrawColorControl + */ +#if defined( _WIN32 ) && !defined( _NO_COM ) +#undef INTERFACE +#define INTERFACE IDirectDrawColorControl +DECLARE_INTERFACE_( IDirectDrawColorControl, IUnknown ) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + /*** IDirectDrawColorControl methods ***/ + STDMETHOD(GetColorControls)(THIS_ LPDDCOLORCONTROL) PURE; + STDMETHOD(SetColorControls)(THIS_ LPDDCOLORCONTROL) PURE; +}; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirectDrawColorControl_QueryInterface(p, a, b) (p)->lpVtbl->QueryInterface(p, a, b) +#define IDirectDrawColorControl_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirectDrawColorControl_Release(p) (p)->lpVtbl->Release(p) +#define IDirectDrawColorControl_GetColorControls(p, a) (p)->lpVtbl->GetColorControls(p, a) +#define IDirectDrawColorControl_SetColorControls(p, a) (p)->lpVtbl->SetColorControls(p, a) +#else +#define IDirectDrawColorControl_QueryInterface(p, a, b) (p)->QueryInterface(a, b) +#define IDirectDrawColorControl_AddRef(p) (p)->AddRef() +#define IDirectDrawColorControl_Release(p) (p)->Release() +#define IDirectDrawColorControl_GetColorControls(p, a) (p)->GetColorControls(a) +#define IDirectDrawColorControl_SetColorControls(p, a) (p)->SetColorControls(a) +#endif + +#endif + + +/* + * IDirectDrawGammaControl + */ +#if defined( _WIN32 ) && !defined( _NO_COM ) +#undef INTERFACE +#define INTERFACE IDirectDrawGammaControl +DECLARE_INTERFACE_( IDirectDrawGammaControl, IUnknown ) +{ + /*** IUnknown methods ***/ + STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR * ppvObj) PURE; + STDMETHOD_(ULONG,AddRef) (THIS) PURE; + STDMETHOD_(ULONG,Release) (THIS) PURE; + /*** IDirectDrawGammaControl methods ***/ + STDMETHOD(GetGammaRamp)(THIS_ DWORD, LPDDGAMMARAMP) PURE; + STDMETHOD(SetGammaRamp)(THIS_ DWORD, LPDDGAMMARAMP) PURE; +}; + +#if !defined(__cplusplus) || defined(CINTERFACE) +#define IDirectDrawGammaControl_QueryInterface(p, a, b) (p)->lpVtbl->QueryInterface(p, a, b) +#define IDirectDrawGammaControl_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IDirectDrawGammaControl_Release(p) (p)->lpVtbl->Release(p) +#define IDirectDrawGammaControl_GetGammaRamp(p, a, b) (p)->lpVtbl->GetGammaRamp(p, a, b) +#define IDirectDrawGammaControl_SetGammaRamp(p, a, b) (p)->lpVtbl->SetGammaRamp(p, a, b) +#else +#define IDirectDrawGammaControl_QueryInterface(p, a, b) (p)->QueryInterface(a, b) +#define IDirectDrawGammaControl_AddRef(p) (p)->AddRef() +#define IDirectDrawGammaControl_Release(p) (p)->Release() +#define IDirectDrawGammaControl_GetGammaRamp(p, a, b) (p)->GetGammaRamp(a, b) +#define IDirectDrawGammaControl_SetGammaRamp(p, a, b) (p)->SetGammaRamp(a, b) +#endif + +#endif + + + +#endif + + +/* + * DDSURFACEDESC + */ +typedef struct _DDSURFACEDESC +{ + DWORD dwSize; // size of the DDSURFACEDESC structure + DWORD dwFlags; // determines what fields are valid + DWORD dwHeight; // height of surface to be created + DWORD dwWidth; // width of input surface + union + { + LONG lPitch; // distance to start of next line (return value only) + DWORD dwLinearSize; // Formless late-allocated optimized surface size + } DUMMYUNIONNAMEN(1); + DWORD dwBackBufferCount; // number of back buffers requested + union + { + DWORD dwMipMapCount; // number of mip-map levels requested + DWORD dwZBufferBitDepth; // depth of Z buffer requested + DWORD dwRefreshRate; // refresh rate (used when display mode is described) + } DUMMYUNIONNAMEN(2); + DWORD dwAlphaBitDepth; // depth of alpha buffer requested + DWORD dwReserved; // reserved + LPVOID lpSurface; // pointer to the associated surface memory + DDCOLORKEY ddckCKDestOverlay; // color key for destination overlay use + DDCOLORKEY ddckCKDestBlt; // color key for destination blt use + DDCOLORKEY ddckCKSrcOverlay; // color key for source overlay use + DDCOLORKEY ddckCKSrcBlt; // color key for source blt use + DDPIXELFORMAT ddpfPixelFormat; // pixel format description of the surface + DDSCAPS ddsCaps; // direct draw surface capabilities +} DDSURFACEDESC; + +/* + * DDSURFACEDESC2 + */ +typedef struct _DDSURFACEDESC2 +{ + DWORD dwSize; // size of the DDSURFACEDESC structure + DWORD dwFlags; // determines what fields are valid + DWORD dwHeight; // height of surface to be created + DWORD dwWidth; // width of input surface + union + { + LONG lPitch; // distance to start of next line (return value only) + DWORD dwLinearSize; // Formless late-allocated optimized surface size + } DUMMYUNIONNAMEN(1); + DWORD dwBackBufferCount; // number of back buffers requested + union + { + DWORD dwMipMapCount; // number of mip-map levels requestde + // dwZBufferBitDepth removed, use ddpfPixelFormat one instead + DWORD dwRefreshRate; // refresh rate (used when display mode is described) + DWORD dwSrcVBHandle; // The source used in VB::Optimize + } DUMMYUNIONNAMEN(2); + DWORD dwAlphaBitDepth; // depth of alpha buffer requested + DWORD dwReserved; // reserved + LPVOID lpSurface; // pointer to the associated surface memory + union + { + DDCOLORKEY ddckCKDestOverlay; // color key for destination overlay use + DWORD dwEmptyFaceColor; // Physical color for empty cubemap faces + } DUMMYUNIONNAMEN(3); + DDCOLORKEY ddckCKDestBlt; // color key for destination blt use + DDCOLORKEY ddckCKSrcOverlay; // color key for source overlay use + DDCOLORKEY ddckCKSrcBlt; // color key for source blt use + union + { + DDPIXELFORMAT ddpfPixelFormat; // pixel format description of the surface + DWORD dwFVF; // vertex format description of vertex buffers + } DUMMYUNIONNAMEN(4); + DDSCAPS2 ddsCaps; // direct draw surface capabilities + DWORD dwTextureStage; // stage in multitexture cascade +} DDSURFACEDESC2; + +/* + * ddsCaps field is valid. + */ +#define DDSD_CAPS 0x00000001l // default + +/* + * dwHeight field is valid. + */ +#define DDSD_HEIGHT 0x00000002l + +/* + * dwWidth field is valid. + */ +#define DDSD_WIDTH 0x00000004l + +/* + * lPitch is valid. + */ +#define DDSD_PITCH 0x00000008l + +/* + * dwBackBufferCount is valid. + */ +#define DDSD_BACKBUFFERCOUNT 0x00000020l + +/* + * dwZBufferBitDepth is valid. (shouldnt be used in DDSURFACEDESC2) + */ +#define DDSD_ZBUFFERBITDEPTH 0x00000040l + +/* + * dwAlphaBitDepth is valid. + */ +#define DDSD_ALPHABITDEPTH 0x00000080l + + +/* + * lpSurface is valid. + */ +#define DDSD_LPSURFACE 0x00000800l + +/* + * ddpfPixelFormat is valid. + */ +#define DDSD_PIXELFORMAT 0x00001000l + +/* + * ddckCKDestOverlay is valid. + */ +#define DDSD_CKDESTOVERLAY 0x00002000l + +/* + * ddckCKDestBlt is valid. + */ +#define DDSD_CKDESTBLT 0x00004000l + +/* + * ddckCKSrcOverlay is valid. + */ +#define DDSD_CKSRCOVERLAY 0x00008000l + +/* + * ddckCKSrcBlt is valid. + */ +#define DDSD_CKSRCBLT 0x00010000l + +/* + * dwMipMapCount is valid. + */ +#define DDSD_MIPMAPCOUNT 0x00020000l + + /* + * dwRefreshRate is valid + */ +#define DDSD_REFRESHRATE 0x00040000l + +/* + * dwLinearSize is valid + */ +#define DDSD_LINEARSIZE 0x00080000l + +/* + * dwTextureStage is valid + */ +#define DDSD_TEXTURESTAGE 0x00100000l +/* + * dwFVF is valid + */ +#define DDSD_FVF 0x00200000l +/* + * dwSrcVBHandle is valid + */ +#define DDSD_SRCVBHANDLE 0x00400000l +/* + * All input fields are valid. + */ +#define DDSD_ALL 0x007ff9eel + + +/* + * DDOPTSURFACEDESC + */ +typedef struct _DDOPTSURFACEDESC +{ + DWORD dwSize; // size of the DDOPTSURFACEDESC structure + DWORD dwFlags; // determines what fields are valid + DDSCAPS2 ddSCaps; // Common caps like: Memory type + DDOSCAPS ddOSCaps; // Common caps like: Memory type + GUID guid; // Compression technique GUID + DWORD dwCompressionRatio; // Compression ratio +} DDOPTSURFACEDESC; + +/* + * guid field is valid. + */ +#define DDOSD_GUID 0x00000001l + +/* + * dwCompressionRatio field is valid. + */ +#define DDOSD_COMPRESSION_RATIO 0x00000002l + +/* + * ddSCaps field is valid. + */ +#define DDOSD_SCAPS 0x00000004l + +/* + * ddOSCaps field is valid. + */ +#define DDOSD_OSCAPS 0x00000008l + +/* + * All input fields are valid. + */ +#define DDOSD_ALL 0x0000000fl + +/* + * The surface's optimized pixelformat is compressed + */ +#define DDOSDCAPS_OPTCOMPRESSED 0x00000001l + +/* + * The surface's optimized pixelformat is reordered + */ +#define DDOSDCAPS_OPTREORDERED 0x00000002l + +/* + * The opt surface is a monolithic mipmap + */ +#define DDOSDCAPS_MONOLITHICMIPMAP 0x00000004l + +/* + * The valid Surf caps: + * #define DDSCAPS_SYSTEMMEMORY 0x00000800l + * #define DDSCAPS_VIDEOMEMORY 0x00004000l + * #define DDSCAPS_LOCALVIDMEM 0x10000000l + * #define DDSCAPS_NONLOCALVIDMEM 0x20000000l + */ +#define DDOSDCAPS_VALIDSCAPS 0x30004800l + +/* + * The valid OptSurf caps + */ +#define DDOSDCAPS_VALIDOSCAPS 0x00000007l + + +/* + * DDCOLORCONTROL + */ +typedef struct _DDCOLORCONTROL +{ + DWORD dwSize; + DWORD dwFlags; + LONG lBrightness; + LONG lContrast; + LONG lHue; + LONG lSaturation; + LONG lSharpness; + LONG lGamma; + LONG lColorEnable; + DWORD dwReserved1; +} DDCOLORCONTROL; + + +/* + * lBrightness field is valid. + */ +#define DDCOLOR_BRIGHTNESS 0x00000001l + +/* + * lContrast field is valid. + */ +#define DDCOLOR_CONTRAST 0x00000002l + +/* + * lHue field is valid. + */ +#define DDCOLOR_HUE 0x00000004l + +/* + * lSaturation field is valid. + */ +#define DDCOLOR_SATURATION 0x00000008l + +/* + * lSharpness field is valid. + */ +#define DDCOLOR_SHARPNESS 0x00000010l + +/* + * lGamma field is valid. + */ +#define DDCOLOR_GAMMA 0x00000020l + +/* + * lColorEnable field is valid. + */ +#define DDCOLOR_COLORENABLE 0x00000040l + + + +/*============================================================================ + * + * Direct Draw Capability Flags + * + * These flags are used to describe the capabilities of a given Surface. + * All flags are bit flags. + * + *==========================================================================*/ + +/**************************************************************************** + * + * DIRECTDRAWSURFACE CAPABILITY FLAGS + * + ****************************************************************************/ + +/* + * This bit is reserved. It should not be specified. + */ +#define DDSCAPS_RESERVED1 0x00000001l + +/* + * Indicates that this surface contains alpha-only information. + * (To determine if a surface is RGBA/YUVA, the pixel format must be + * interrogated.) + */ +#define DDSCAPS_ALPHA 0x00000002l + +/* + * Indicates that this surface is a backbuffer. It is generally + * set by CreateSurface when the DDSCAPS_FLIP capability bit is set. + * It indicates that this surface is THE back buffer of a surface + * flipping structure. DirectDraw supports N surfaces in a + * surface flipping structure. Only the surface that immediately + * precedeces the DDSCAPS_FRONTBUFFER has this capability bit set. + * The other surfaces are identified as back buffers by the presence + * of the DDSCAPS_FLIP capability, their attachment order, and the + * absence of the DDSCAPS_FRONTBUFFER and DDSCAPS_BACKBUFFER + * capabilities. The bit is sent to CreateSurface when a standalone + * back buffer is being created. This surface could be attached to + * a front buffer and/or back buffers to form a flipping surface + * structure after the CreateSurface call. See AddAttachments for + * a detailed description of the behaviors in this case. + */ +#define DDSCAPS_BACKBUFFER 0x00000004l + +/* + * Indicates a complex surface structure is being described. A + * complex surface structure results in the creation of more than + * one surface. The additional surfaces are attached to the root + * surface. The complex structure can only be destroyed by + * destroying the root. + */ +#define DDSCAPS_COMPLEX 0x00000008l + +/* + * Indicates that this surface is a part of a surface flipping structure. + * When it is passed to CreateSurface the DDSCAPS_FRONTBUFFER and + * DDSCAP_BACKBUFFER bits are not set. They are set by CreateSurface + * on the resulting creations. The dwBackBufferCount field in the + * DDSURFACEDESC structure must be set to at least 1 in order for + * the CreateSurface call to succeed. The DDSCAPS_COMPLEX capability + * must always be set with creating multiple surfaces through CreateSurface. + */ +#define DDSCAPS_FLIP 0x00000010l + +/* + * Indicates that this surface is THE front buffer of a surface flipping + * structure. It is generally set by CreateSurface when the DDSCAPS_FLIP + * capability bit is set. + * If this capability is sent to CreateSurface then a standalonw front buffer + * is created. This surface will not have the DDSCAPS_FLIP capability. + * It can be attached to other back buffers to form a flipping structure. + * See AddAttachments for a detailed description of the behaviors in this + * case. + */ +#define DDSCAPS_FRONTBUFFER 0x00000020l + +/* + * Indicates that this surface is any offscreen surface that is not an overlay, + * texture, zbuffer, front buffer, back buffer, or alpha surface. It is used + * to identify plain vanilla surfaces. + */ +#define DDSCAPS_OFFSCREENPLAIN 0x00000040l + +/* + * Indicates that this surface is an overlay. It may or may not be directly visible + * depending on whether or not it is currently being overlayed onto the primary + * surface. DDSCAPS_VISIBLE can be used to determine whether or not it is being + * overlayed at the moment. + */ +#define DDSCAPS_OVERLAY 0x00000080l + +/* + * Indicates that unique DirectDrawPalette objects can be created and + * attached to this surface. + */ +#define DDSCAPS_PALETTE 0x00000100l + +/* + * Indicates that this surface is the primary surface. The primary + * surface represents what the user is seeing at the moment. + */ +#define DDSCAPS_PRIMARYSURFACE 0x00000200l + + +/* + * This flag used to be DDSCAPS_PRIMARYSURFACELEFT, which is now + * obsolete. + */ +#define DDSCAPS_RESERVED3 0x00000400l + +/* + * Indicates that this surface memory was allocated in system memory + */ +#define DDSCAPS_SYSTEMMEMORY 0x00000800l + +/* + * Indicates that this surface can be used as a 3D texture. It does not + * indicate whether or not the surface is being used for that purpose. + */ +#define DDSCAPS_TEXTURE 0x00001000l + +/* + * Indicates that a surface may be a destination for 3D rendering. This + * bit must be set in order to query for a Direct3D Device Interface + * from this surface. + */ +#define DDSCAPS_3DDEVICE 0x00002000l + +/* + * Indicates that this surface exists in video memory. + */ +#define DDSCAPS_VIDEOMEMORY 0x00004000l + +/* + * Indicates that changes made to this surface are immediately visible. + * It is always set for the primary surface and is set for overlays while + * they are being overlayed and texture maps while they are being textured. + */ +#define DDSCAPS_VISIBLE 0x00008000l + +/* + * Indicates that only writes are permitted to the surface. Read accesses + * from the surface may or may not generate a protection fault, but the + * results of a read from this surface will not be meaningful. READ ONLY. + */ +#define DDSCAPS_WRITEONLY 0x00010000l + +/* + * Indicates that this surface is a z buffer. A z buffer does not contain + * displayable information. Instead it contains bit depth information that is + * used to determine which pixels are visible and which are obscured. + */ +#define DDSCAPS_ZBUFFER 0x00020000l + +/* + * Indicates surface will have a DC associated long term + */ +#define DDSCAPS_OWNDC 0x00040000l + +/* + * Indicates surface should be able to receive live video + */ +#define DDSCAPS_LIVEVIDEO 0x00080000l + +/* + * Indicates surface should be able to have a stream decompressed + * to it by the hardware. + */ +#define DDSCAPS_HWCODEC 0x00100000l + +/* + * Surface is a ModeX surface. + * + */ +#define DDSCAPS_MODEX 0x00200000l + +/* + * Indicates surface is one level of a mip-map. This surface will + * be attached to other DDSCAPS_MIPMAP surfaces to form the mip-map. + * This can be done explicitly, by creating a number of surfaces and + * attaching them with AddAttachedSurface or by implicitly by CreateSurface. + * If this bit is set then DDSCAPS_TEXTURE must also be set. + */ +#define DDSCAPS_MIPMAP 0x00400000l + +/* + * This bit is reserved. It should not be specified. + */ +#define DDSCAPS_RESERVED2 0x00800000l + + +/* + * Indicates that memory for the surface is not allocated until the surface + * is loaded (via the Direct3D texture Load() function). + */ +#define DDSCAPS_ALLOCONLOAD 0x04000000l + +/* + * Indicates that the surface will recieve data from a video port. + */ +#define DDSCAPS_VIDEOPORT 0x08000000l + +/* + * Indicates that a video memory surface is resident in true, local video + * memory rather than non-local video memory. If this flag is specified then + * so must DDSCAPS_VIDEOMEMORY. This flag is mutually exclusive with + * DDSCAPS_NONLOCALVIDMEM. + */ +#define DDSCAPS_LOCALVIDMEM 0x10000000l + +/* + * Indicates that a video memory surface is resident in non-local video + * memory rather than true, local video memory. If this flag is specified + * then so must DDSCAPS_VIDEOMEMORY. This flag is mutually exclusive with + * DDSCAPS_LOCALVIDMEM. + */ +#define DDSCAPS_NONLOCALVIDMEM 0x20000000l + +/* + * Indicates that this surface is a standard VGA mode surface, and not a + * ModeX surface. (This flag will never be set in combination with the + * DDSCAPS_MODEX flag). + */ +#define DDSCAPS_STANDARDVGAMODE 0x40000000l + +/* + * Indicates that this surface will be an optimized surface. This flag is + * currently only valid in conjunction with the DDSCAPS_TEXTURE flag. The surface + * will be created without any underlying video memory until loaded. + */ +#define DDSCAPS_OPTIMIZED 0x80000000l + + + + +/* + * Indicates that this surface will receive data from a video port using + * the de-interlacing hardware. This allows the driver to allocate memory + * for any extra buffers that may be required. The DDSCAPS_VIDEOPORT and + * DDSCAPS_OVERLAY flags must also be set. + */ +#define DDSCAPS2_HARDWAREDEINTERLACE 0x00000002L + +/* + * Indicates to the driver that this surface will be locked very frequently + * (for procedural textures, dynamic lightmaps, etc). Surfaces with this cap + * set must also have DDSCAPS_TEXTURE. This cap cannot be used with + * DDSCAPS2_HINTSTATIC and DDSCAPS2_OPAQUE. + */ +#define DDSCAPS2_HINTDYNAMIC 0x00000004L + +/* + * Indicates to the driver that this surface can be re-ordered/retiled on + * load. This operation will not change the size of the texture. It is + * relatively fast and symmetrical, since the application may lock these + * bits (although it will take a performance hit when doing so). Surfaces + * with this cap set must also have DDSCAPS_TEXTURE. This cap cannot be + * used with DDSCAPS2_HINTDYNAMIC and DDSCAPS2_OPAQUE. + */ +#define DDSCAPS2_HINTSTATIC 0x00000008L + +/* + * Indicates that the client would like this texture surface to be managed by the + * DirectDraw/Direct3D runtime. Surfaces with this cap set must also have + * DDSCAPS_TEXTURE set. + */ +#define DDSCAPS2_TEXTUREMANAGE 0x00000010L + +/* + * These bits are reserved for internal use */ +#define DDSCAPS2_RESERVED1 0x00000020L +#define DDSCAPS2_RESERVED2 0x00000040L + +/* + * Indicates to the driver that this surface will never be locked again. + * The driver is free to optimize this surface via retiling and actual compression. + * All calls to Lock() or Blts from this surface will fail. Surfaces with this + * cap set must also have DDSCAPS_TEXTURE. This cap cannot be used with + * DDSCAPS2_HINTDYNAMIC and DDSCAPS2_HINTSTATIC. + */ +#define DDSCAPS2_OPAQUE 0x00000080L + +/* + * Applications should set this bit at CreateSurface time to indicate that they + * intend to use antialiasing. Only valid if DDSCAPS_3DDEVICE is also set. + */ +#define DDSCAPS2_HINTANTIALIASING 0x00000100L + + +/* + * This flag is used at CreateSurface time to indicate that this set of + * surfaces is a cubic environment map + */ +#define DDSCAPS2_CUBEMAP 0x00000200L + +/* + * These flags preform two functions: + * - At CreateSurface time, they define which of the six cube faces are + * required by the application. + * - After creation, each face in the cubemap will have exactly one of these + * bits set. + */ +#define DDSCAPS2_CUBEMAP_POSITIVEX 0x00000400L +#define DDSCAPS2_CUBEMAP_NEGATIVEX 0x00000800L +#define DDSCAPS2_CUBEMAP_POSITIVEY 0x00001000L +#define DDSCAPS2_CUBEMAP_NEGATIVEY 0x00002000L +#define DDSCAPS2_CUBEMAP_POSITIVEZ 0x00004000L +#define DDSCAPS2_CUBEMAP_NEGATIVEZ 0x00008000L + +/* + * This macro may be used to specify all faces of a cube map at CreateSurface time + */ +#define DDSCAPS2_CUBEMAP_ALLFACES ( DDSCAPS2_CUBEMAP_POSITIVEX |\ + DDSCAPS2_CUBEMAP_NEGATIVEX |\ + DDSCAPS2_CUBEMAP_POSITIVEY |\ + DDSCAPS2_CUBEMAP_NEGATIVEY |\ + DDSCAPS2_CUBEMAP_POSITIVEZ |\ + DDSCAPS2_CUBEMAP_NEGATIVEZ ) + + +/* + * This flag is an additional flag which is present on mipmap sublevels from DX7 onwards + * It enables easier use of GetAttachedSurface rather than EnumAttachedSurfaces for surface + * constructs such as Cube Maps, wherein there are more than one mipmap surface attached + * to the root surface. + * This caps bit is ignored by CreateSurface + */ +#define DDSCAPS2_MIPMAPSUBLEVEL 0x00010000L + +/* This flag indicates that the texture should be managed by D3D only */ +#define DDSCAPS2_D3DTEXTUREMANAGE 0x00020000L + +/* This flag indicates that the managed surface can be safely lost */ +#define DDSCAPS2_DONOTPERSIST 0x00040000L + +/* indicates that this surface is part of a stereo flipping chain */ +#define DDSCAPS2_STEREOSURFACELEFT 0x00080000L + + + + + + /**************************************************************************** + * + * DIRECTDRAW DRIVER CAPABILITY FLAGS + * + ****************************************************************************/ + +/* + * Display hardware has 3D acceleration. + */ +#define DDCAPS_3D 0x00000001l + +/* + * Indicates that DirectDraw will support only dest rectangles that are aligned + * on DIRECTDRAWCAPS.dwAlignBoundaryDest boundaries of the surface, respectively. + * READ ONLY. + */ +#define DDCAPS_ALIGNBOUNDARYDEST 0x00000002l + +/* + * Indicates that DirectDraw will support only source rectangles whose sizes in + * BYTEs are DIRECTDRAWCAPS.dwAlignSizeDest multiples, respectively. READ ONLY. + */ +#define DDCAPS_ALIGNSIZEDEST 0x00000004l +/* + * Indicates that DirectDraw will support only source rectangles that are aligned + * on DIRECTDRAWCAPS.dwAlignBoundarySrc boundaries of the surface, respectively. + * READ ONLY. + */ +#define DDCAPS_ALIGNBOUNDARYSRC 0x00000008l + +/* + * Indicates that DirectDraw will support only source rectangles whose sizes in + * BYTEs are DIRECTDRAWCAPS.dwAlignSizeSrc multiples, respectively. READ ONLY. + */ +#define DDCAPS_ALIGNSIZESRC 0x00000010l + +/* + * Indicates that DirectDraw will create video memory surfaces that have a stride + * alignment equal to DIRECTDRAWCAPS.dwAlignStride. READ ONLY. + */ +#define DDCAPS_ALIGNSTRIDE 0x00000020l + +/* + * Display hardware is capable of blt operations. + */ +#define DDCAPS_BLT 0x00000040l + +/* + * Display hardware is capable of asynchronous blt operations. + */ +#define DDCAPS_BLTQUEUE 0x00000080l + +/* + * Display hardware is capable of color space conversions during the blt operation. + */ +#define DDCAPS_BLTFOURCC 0x00000100l + +/* + * Display hardware is capable of stretching during blt operations. + */ +#define DDCAPS_BLTSTRETCH 0x00000200l + +/* + * Display hardware is shared with GDI. + */ +#define DDCAPS_GDI 0x00000400l + +/* + * Display hardware can overlay. + */ +#define DDCAPS_OVERLAY 0x00000800l + +/* + * Set if display hardware supports overlays but can not clip them. + */ +#define DDCAPS_OVERLAYCANTCLIP 0x00001000l + +/* + * Indicates that overlay hardware is capable of color space conversions during + * the overlay operation. + */ +#define DDCAPS_OVERLAYFOURCC 0x00002000l + +/* + * Indicates that stretching can be done by the overlay hardware. + */ +#define DDCAPS_OVERLAYSTRETCH 0x00004000l + +/* + * Indicates that unique DirectDrawPalettes can be created for DirectDrawSurfaces + * other than the primary surface. + */ +#define DDCAPS_PALETTE 0x00008000l + +/* + * Indicates that palette changes can be syncd with the veritcal refresh. + */ +#define DDCAPS_PALETTEVSYNC 0x00010000l + +/* + * Display hardware can return the current scan line. + */ +#define DDCAPS_READSCANLINE 0x00020000l + + +/* + * This flag used to bo DDCAPS_STEREOVIEW, which is now obsolete + */ +#define DDCAPS_RESERVED1 0x00040000l + +/* + * Display hardware is capable of generating a vertical blank interrupt. + */ +#define DDCAPS_VBI 0x00080000l + +/* + * Supports the use of z buffers with blt operations. + */ +#define DDCAPS_ZBLTS 0x00100000l + +/* + * Supports Z Ordering of overlays. + */ +#define DDCAPS_ZOVERLAYS 0x00200000l + +/* + * Supports color key + */ +#define DDCAPS_COLORKEY 0x00400000l + +/* + * Supports alpha surfaces + */ +#define DDCAPS_ALPHA 0x00800000l + +/* + * colorkey is hardware assisted(DDCAPS_COLORKEY will also be set) + */ +#define DDCAPS_COLORKEYHWASSIST 0x01000000l + +/* + * no hardware support at all + */ +#define DDCAPS_NOHARDWARE 0x02000000l + +/* + * Display hardware is capable of color fill with bltter + */ +#define DDCAPS_BLTCOLORFILL 0x04000000l + +/* + * Display hardware is bank switched, and potentially very slow at + * random access to VRAM. + */ +#define DDCAPS_BANKSWITCHED 0x08000000l + +/* + * Display hardware is capable of depth filling Z-buffers with bltter + */ +#define DDCAPS_BLTDEPTHFILL 0x10000000l + +/* + * Display hardware is capable of clipping while bltting. + */ +#define DDCAPS_CANCLIP 0x20000000l + +/* + * Display hardware is capable of clipping while stretch bltting. + */ +#define DDCAPS_CANCLIPSTRETCHED 0x40000000l + +/* + * Display hardware is capable of bltting to or from system memory + */ +#define DDCAPS_CANBLTSYSMEM 0x80000000l + + + /**************************************************************************** + * + * MORE DIRECTDRAW DRIVER CAPABILITY FLAGS (dwCaps2) + * + ****************************************************************************/ + +/* + * Display hardware is certified + */ +#define DDCAPS2_CERTIFIED 0x00000001l + +/* + * Driver cannot interleave 2D operations (lock and blt) to surfaces with + * Direct3D rendering operations between calls to BeginScene() and EndScene() + */ +#define DDCAPS2_NO2DDURING3DSCENE 0x00000002l + +/* + * Display hardware contains a video port + */ +#define DDCAPS2_VIDEOPORT 0x00000004l + +/* + * The overlay can be automatically flipped according to the video port + * VSYNCs, providing automatic doubled buffered display of video port + * data using an overlay + */ +#define DDCAPS2_AUTOFLIPOVERLAY 0x00000008l + +/* + * Overlay can display each field of interlaced data individually while + * it is interleaved in memory without causing jittery artifacts. + */ +#define DDCAPS2_CANBOBINTERLEAVED 0x00000010l + +/* + * Overlay can display each field of interlaced data individually while + * it is not interleaved in memory without causing jittery artifacts. + */ +#define DDCAPS2_CANBOBNONINTERLEAVED 0x00000020l + +/* + * The overlay surface contains color controls (brightness, sharpness, etc.) + */ +#define DDCAPS2_COLORCONTROLOVERLAY 0x00000040l + +/* + * The primary surface contains color controls (gamma, etc.) + */ +#define DDCAPS2_COLORCONTROLPRIMARY 0x00000080l + +/* + * RGBZ -> RGB supported for 16:16 RGB:Z + */ +#define DDCAPS2_CANDROPZ16BIT 0x00000100l + +/* + * Driver supports non-local video memory. + */ +#define DDCAPS2_NONLOCALVIDMEM 0x00000200l + +/* + * Dirver supports non-local video memory but has different capabilities for + * non-local video memory surfaces. If this bit is set then so must + * DDCAPS2_NONLOCALVIDMEM. + */ +#define DDCAPS2_NONLOCALVIDMEMCAPS 0x00000400l + +/* + * Driver neither requires nor prefers surfaces to be pagelocked when performing + * blts involving system memory surfaces + */ +#define DDCAPS2_NOPAGELOCKREQUIRED 0x00000800l + +/* + * Driver can create surfaces which are wider than the primary surface + */ +#define DDCAPS2_WIDESURFACES 0x00001000l + +/* + * Driver supports bob without using a video port by handling the + * DDFLIP_ODD and DDFLIP_EVEN flags specified in Flip. + */ +#define DDCAPS2_CANFLIPODDEVEN 0x00002000l + +/* + * Driver supports bob using hardware + */ +#define DDCAPS2_CANBOBHARDWARE 0x00004000l + +/* + * Driver supports bltting any FOURCC surface to another surface of the same FOURCC + */ +#define DDCAPS2_COPYFOURCC 0x00008000l + + +/* + * Driver supports loadable gamma ramps for the primary surface + */ +#define DDCAPS2_PRIMARYGAMMA 0x00020000l + +/* + * Driver can render in windowed mode. + */ +#define DDCAPS2_CANRENDERWINDOWED 0x00080000l + +/* + * A calibrator is available to adjust the gamma ramp according to the + * physical display properties so that the result will be identical on + * all calibrated systems. + */ +#define DDCAPS2_CANCALIBRATEGAMMA 0x00100000l + +/* + * Indicates that the driver will respond to DDFLIP_INTERVALn flags + */ +#define DDCAPS2_FLIPINTERVAL 0x00200000l + +/* + * Indicates that the driver will respond to DDFLIP_NOVSYNC + */ +#define DDCAPS2_FLIPNOVSYNC 0x00400000l + +/* + * Driver supports management of video memory, if this flag is ON, + * driver manages the texture if requested with DDSCAPS2_TEXTUREMANAGE on + * DirectX manages the texture if this flag is OFF and surface has DDSCAPS2_TEXTUREMANAGE on + */ +#define DDCAPS2_CANMANAGETEXTURE 0x00800000l + +/* + * The Direct3D texture manager uses this cap to decide whether to put managed + * surfaces in non-local video memory. If the cap is set, the texture manager will + * put managed surfaces in non-local vidmem. Drivers that cannot texture from + * local vidmem SHOULD NOT set this cap. + */ +#define DDCAPS2_TEXMANINNONLOCALVIDMEM 0x01000000l + +/* + * Indicates that the driver supports DX7 type of stereo in at least one mode (which may + * not necessarily be the current mode). Applications should use IDirectDraw7 (or higher) + * ::EnumDisplayModes and check the DDSURFACEDESC.ddsCaps.dwCaps2 field for the presence of + * DDSCAPS2_STEREOSURFACELEFT to check if a particular mode supports stereo. The application + * can also use IDirectDraw7(or higher)::GetDisplayMode to check the current mode. + */ +#define DDCAPS2_STEREO 0x02000000L + +/* + * This caps bit is intended for internal DirectDraw use. + * -It is only valid if DDCAPS2_NONLOCALVIDMEMCAPS is set. + * -If this bit is set, then DDCAPS_CANBLTSYSMEM MUST be set by the driver (and + * all the assoicated system memory blt caps must be correct). + * -It implies that the system->video blt caps in DDCAPS also apply to system to + * nonlocal blts. I.e. the dwSVBCaps, dwSVBCKeyCaps, dwSVBFXCaps and dwSVBRops + * members of DDCAPS (DDCORECAPS) are filled in correctly. + * -Any blt from system to nonlocal memory that matches these caps bits will + * be passed to the driver. + * + * NOTE: This is intended to enable the driver itself to do efficient reordering + * of textures. This is NOT meant to imply that hardware can write into AGP memory. + * This operation is not currently supported. + */ +#define DDCAPS2_SYSTONONLOCAL_AS_SYSTOLOCAL 0x04000000L + + + +/**************************************************************************** + * + * DIRECTDRAW FX ALPHA CAPABILITY FLAGS + * + ****************************************************************************/ + +/* + * Supports alpha blending around the edge of a source color keyed surface. + * For Blt. + */ +#define DDFXALPHACAPS_BLTALPHAEDGEBLEND 0x00000001l + +/* + * Supports alpha information in the pixel format. The bit depth of alpha + * information in the pixel format can be 1,2,4, or 8. The alpha value becomes + * more opaque as the alpha value increases. (0 is transparent.) + * For Blt. + */ +#define DDFXALPHACAPS_BLTALPHAPIXELS 0x00000002l + +/* + * Supports alpha information in the pixel format. The bit depth of alpha + * information in the pixel format can be 1,2,4, or 8. The alpha value + * becomes more transparent as the alpha value increases. (0 is opaque.) + * This flag can only be set if DDCAPS_ALPHA is set. + * For Blt. + */ +#define DDFXALPHACAPS_BLTALPHAPIXELSNEG 0x00000004l + +/* + * Supports alpha only surfaces. The bit depth of an alpha only surface can be + * 1,2,4, or 8. The alpha value becomes more opaque as the alpha value increases. + * (0 is transparent.) + * For Blt. + */ +#define DDFXALPHACAPS_BLTALPHASURFACES 0x00000008l + +/* + * The depth of the alpha channel data can range can be 1,2,4, or 8. + * The NEG suffix indicates that this alpha channel becomes more transparent + * as the alpha value increases. (0 is opaque.) This flag can only be set if + * DDCAPS_ALPHA is set. + * For Blt. + */ +#define DDFXALPHACAPS_BLTALPHASURFACESNEG 0x00000010l + +/* + * Supports alpha blending around the edge of a source color keyed surface. + * For Overlays. + */ +#define DDFXALPHACAPS_OVERLAYALPHAEDGEBLEND 0x00000020l + +/* + * Supports alpha information in the pixel format. The bit depth of alpha + * information in the pixel format can be 1,2,4, or 8. The alpha value becomes + * more opaque as the alpha value increases. (0 is transparent.) + * For Overlays. + */ +#define DDFXALPHACAPS_OVERLAYALPHAPIXELS 0x00000040l + +/* + * Supports alpha information in the pixel format. The bit depth of alpha + * information in the pixel format can be 1,2,4, or 8. The alpha value + * becomes more transparent as the alpha value increases. (0 is opaque.) + * This flag can only be set if DDCAPS_ALPHA is set. + * For Overlays. + */ +#define DDFXALPHACAPS_OVERLAYALPHAPIXELSNEG 0x00000080l + +/* + * Supports alpha only surfaces. The bit depth of an alpha only surface can be + * 1,2,4, or 8. The alpha value becomes more opaque as the alpha value increases. + * (0 is transparent.) + * For Overlays. + */ +#define DDFXALPHACAPS_OVERLAYALPHASURFACES 0x00000100l + +/* + * The depth of the alpha channel data can range can be 1,2,4, or 8. + * The NEG suffix indicates that this alpha channel becomes more transparent + * as the alpha value increases. (0 is opaque.) This flag can only be set if + * DDCAPS_ALPHA is set. + * For Overlays. + */ +#define DDFXALPHACAPS_OVERLAYALPHASURFACESNEG 0x00000200l + +#if DIRECTDRAW_VERSION < 0x0600 +#endif //DIRECTDRAW_VERSION + + + +/**************************************************************************** + * + * DIRECTDRAW FX CAPABILITY FLAGS + * + ****************************************************************************/ + +/* + * Uses arithmetic operations to stretch and shrink surfaces during blt + * rather than pixel doubling techniques. Along the Y axis. + */ +#define DDFXCAPS_BLTARITHSTRETCHY 0x00000020l + +/* + * Uses arithmetic operations to stretch during blt + * rather than pixel doubling techniques. Along the Y axis. Only + * works for x1, x2, etc. + */ +#define DDFXCAPS_BLTARITHSTRETCHYN 0x00000010l + +/* + * Supports mirroring left to right in blt. + */ +#define DDFXCAPS_BLTMIRRORLEFTRIGHT 0x00000040l + +/* + * Supports mirroring top to bottom in blt. + */ +#define DDFXCAPS_BLTMIRRORUPDOWN 0x00000080l + +/* + * Supports arbitrary rotation for blts. + */ +#define DDFXCAPS_BLTROTATION 0x00000100l + +/* + * Supports 90 degree rotations for blts. + */ +#define DDFXCAPS_BLTROTATION90 0x00000200l + +/* + * DirectDraw supports arbitrary shrinking of a surface along the + * x axis (horizontal direction) for blts. + */ +#define DDFXCAPS_BLTSHRINKX 0x00000400l + +/* + * DirectDraw supports integer shrinking (1x,2x,) of a surface + * along the x axis (horizontal direction) for blts. + */ +#define DDFXCAPS_BLTSHRINKXN 0x00000800l + +/* + * DirectDraw supports arbitrary shrinking of a surface along the + * y axis (horizontal direction) for blts. + */ +#define DDFXCAPS_BLTSHRINKY 0x00001000l + +/* + * DirectDraw supports integer shrinking (1x,2x,) of a surface + * along the y axis (vertical direction) for blts. + */ +#define DDFXCAPS_BLTSHRINKYN 0x00002000l + +/* + * DirectDraw supports arbitrary stretching of a surface along the + * x axis (horizontal direction) for blts. + */ +#define DDFXCAPS_BLTSTRETCHX 0x00004000l + +/* + * DirectDraw supports integer stretching (1x,2x,) of a surface + * along the x axis (horizontal direction) for blts. + */ +#define DDFXCAPS_BLTSTRETCHXN 0x00008000l + +/* + * DirectDraw supports arbitrary stretching of a surface along the + * y axis (horizontal direction) for blts. + */ +#define DDFXCAPS_BLTSTRETCHY 0x00010000l + +/* + * DirectDraw supports integer stretching (1x,2x,) of a surface + * along the y axis (vertical direction) for blts. + */ +#define DDFXCAPS_BLTSTRETCHYN 0x00020000l + +/* + * Uses arithmetic operations to stretch and shrink surfaces during + * overlay rather than pixel doubling techniques. Along the Y axis + * for overlays. + */ +#define DDFXCAPS_OVERLAYARITHSTRETCHY 0x00040000l + +/* + * Uses arithmetic operations to stretch surfaces during + * overlay rather than pixel doubling techniques. Along the Y axis + * for overlays. Only works for x1, x2, etc. + */ +#define DDFXCAPS_OVERLAYARITHSTRETCHYN 0x00000008l + +/* + * DirectDraw supports arbitrary shrinking of a surface along the + * x axis (horizontal direction) for overlays. + */ +#define DDFXCAPS_OVERLAYSHRINKX 0x00080000l + +/* + * DirectDraw supports integer shrinking (1x,2x,) of a surface + * along the x axis (horizontal direction) for overlays. + */ +#define DDFXCAPS_OVERLAYSHRINKXN 0x00100000l + +/* + * DirectDraw supports arbitrary shrinking of a surface along the + * y axis (horizontal direction) for overlays. + */ +#define DDFXCAPS_OVERLAYSHRINKY 0x00200000l + +/* + * DirectDraw supports integer shrinking (1x,2x,) of a surface + * along the y axis (vertical direction) for overlays. + */ +#define DDFXCAPS_OVERLAYSHRINKYN 0x00400000l + +/* + * DirectDraw supports arbitrary stretching of a surface along the + * x axis (horizontal direction) for overlays. + */ +#define DDFXCAPS_OVERLAYSTRETCHX 0x00800000l + +/* + * DirectDraw supports integer stretching (1x,2x,) of a surface + * along the x axis (horizontal direction) for overlays. + */ +#define DDFXCAPS_OVERLAYSTRETCHXN 0x01000000l + +/* + * DirectDraw supports arbitrary stretching of a surface along the + * y axis (horizontal direction) for overlays. + */ +#define DDFXCAPS_OVERLAYSTRETCHY 0x02000000l + +/* + * DirectDraw supports integer stretching (1x,2x,) of a surface + * along the y axis (vertical direction) for overlays. + */ +#define DDFXCAPS_OVERLAYSTRETCHYN 0x04000000l + +/* + * DirectDraw supports mirroring of overlays across the vertical axis + */ +#define DDFXCAPS_OVERLAYMIRRORLEFTRIGHT 0x08000000l + +/* + * DirectDraw supports mirroring of overlays across the horizontal axis + */ +#define DDFXCAPS_OVERLAYMIRRORUPDOWN 0x10000000l + +/* + * Driver can do alpha blending for blits. + */ +#define DDFXCAPS_BLTALPHA 0x00000001l + + +/* + * Driver can do surface-reconstruction filtering for warped blits. + */ +#define DDFXCAPS_BLTFILTER DDFXCAPS_BLTARITHSTRETCHY + +/* + * Driver can do alpha blending for overlays. + */ +#define DDFXCAPS_OVERLAYALPHA 0x00000004l + + +/* + * Driver can do surface-reconstruction filtering for warped overlays. + */ +#define DDFXCAPS_OVERLAYFILTER DDFXCAPS_OVERLAYARITHSTRETCHY + + +/**************************************************************************** + * + * DIRECTDRAW STEREO VIEW CAPABILITIES + * + ****************************************************************************/ + +/* + * This flag used to be DDSVCAPS_ENIGMA, which is now obsolete + */ + +#define DDSVCAPS_RESERVED1 0x00000001l + +/* + * This flag used to be DDSVCAPS_FLICKER, which is now obsolete + */ +#define DDSVCAPS_RESERVED2 0x00000002l + +/* + * This flag used to be DDSVCAPS_REDBLUE, which is now obsolete + */ +#define DDSVCAPS_RESERVED3 0x00000004l + +/* + * This flag used to be DDSVCAPS_SPLIT, which is now obsolete + */ +#define DDSVCAPS_RESERVED4 0x00000008l + +/* + * The stereo view is accomplished with switching technology + */ + +#define DDSVCAPS_STEREOSEQUENTIAL 0x00000010L + + + + +/**************************************************************************** + * + * DIRECTDRAWPALETTE CAPABILITIES + * + ****************************************************************************/ + +/* + * Index is 4 bits. There are sixteen color entries in the palette table. + */ +#define DDPCAPS_4BIT 0x00000001l + +/* + * Index is onto a 8 bit color index. This field is only valid with the + * DDPCAPS_1BIT, DDPCAPS_2BIT or DDPCAPS_4BIT capability and the target + * surface is in 8bpp. Each color entry is one byte long and is an index + * into destination surface's 8bpp palette. + */ +#define DDPCAPS_8BITENTRIES 0x00000002l + +/* + * Index is 8 bits. There are 256 color entries in the palette table. + */ +#define DDPCAPS_8BIT 0x00000004l + +/* + * Indicates that this DIRECTDRAWPALETTE should use the palette color array + * passed into the lpDDColorArray parameter to initialize the DIRECTDRAWPALETTE + * object. + * This flag is obsolete. DirectDraw always initializes the color array from + * the lpDDColorArray parameter. The definition remains for source-level + * compatibility. + */ +#define DDPCAPS_INITIALIZE 0x00000000l + +/* + * This palette is the one attached to the primary surface. Changing this + * table has immediate effect on the display unless DDPSETPAL_VSYNC is specified + * and supported. + */ +#define DDPCAPS_PRIMARYSURFACE 0x00000010l + +/* + * This palette is the one attached to the primary surface left. Changing + * this table has immediate effect on the display for the left eye unless + * DDPSETPAL_VSYNC is specified and supported. + */ +#define DDPCAPS_PRIMARYSURFACELEFT 0x00000020l + +/* + * This palette can have all 256 entries defined + */ +#define DDPCAPS_ALLOW256 0x00000040l + +/* + * This palette can have modifications to it synced with the monitors + * refresh rate. + */ +#define DDPCAPS_VSYNC 0x00000080l + +/* + * Index is 1 bit. There are two color entries in the palette table. + */ +#define DDPCAPS_1BIT 0x00000100l + +/* + * Index is 2 bit. There are four color entries in the palette table. + */ +#define DDPCAPS_2BIT 0x00000200l + +/* + * The peFlags member of PALETTEENTRY denotes an 8 bit alpha value + */ +#define DDPCAPS_ALPHA 0x00000400l + + +/**************************************************************************** + * + * DIRECTDRAWPALETTE SETENTRY CONSTANTS + * + ****************************************************************************/ + + +/**************************************************************************** + * + * DIRECTDRAWPALETTE GETENTRY CONSTANTS + * + ****************************************************************************/ + +/* 0 is the only legal value */ + +/**************************************************************************** + * + * DIRECTDRAWSURFACE SETPRIVATEDATA CONSTANTS + * + ****************************************************************************/ + +/* + * The passed pointer is an IUnknown ptr. The cbData argument to SetPrivateData + * must be set to sizeof(IUnknown*). DirectDraw will call AddRef through this + * pointer and Release when the private data is destroyed. This includes when + * the surface or palette is destroyed before such priovate data is destroyed. + */ +#define DDSPD_IUNKNOWNPOINTER 0x00000001L + +/* + * Private data is only valid for the current state of the object, + * as determined by the uniqueness value. + */ +#define DDSPD_VOLATILE 0x00000002L + + +/**************************************************************************** + * + * DIRECTDRAWSURFACE SETPALETTE CONSTANTS + * + ****************************************************************************/ + + +/**************************************************************************** + * + * DIRECTDRAW BITDEPTH CONSTANTS + * + * NOTE: These are only used to indicate supported bit depths. These + * are flags only, they are not to be used as an actual bit depth. The + * absolute numbers 1, 2, 4, 8, 16, 24 and 32 are used to indicate actual + * bit depths in a surface or for changing the display mode. + * + ****************************************************************************/ + +/* + * 1 bit per pixel. + */ +#define DDBD_1 0x00004000l + +/* + * 2 bits per pixel. + */ +#define DDBD_2 0x00002000l + +/* + * 4 bits per pixel. + */ +#define DDBD_4 0x00001000l + +/* + * 8 bits per pixel. + */ +#define DDBD_8 0x00000800l + +/* + * 16 bits per pixel. + */ +#define DDBD_16 0x00000400l + +/* + * 24 bits per pixel. + */ +#define DDBD_24 0X00000200l + +/* + * 32 bits per pixel. + */ +#define DDBD_32 0x00000100l + +/**************************************************************************** + * + * DIRECTDRAWSURFACE SET/GET COLOR KEY FLAGS + * + ****************************************************************************/ + +/* + * Set if the structure contains a color space. Not set if the structure + * contains a single color key. + */ +#define DDCKEY_COLORSPACE 0x00000001l + +/* + * Set if the structure specifies a color key or color space which is to be + * used as a destination color key for blt operations. + */ +#define DDCKEY_DESTBLT 0x00000002l + +/* + * Set if the structure specifies a color key or color space which is to be + * used as a destination color key for overlay operations. + */ +#define DDCKEY_DESTOVERLAY 0x00000004l + +/* + * Set if the structure specifies a color key or color space which is to be + * used as a source color key for blt operations. + */ +#define DDCKEY_SRCBLT 0x00000008l + +/* + * Set if the structure specifies a color key or color space which is to be + * used as a source color key for overlay operations. + */ +#define DDCKEY_SRCOVERLAY 0x00000010l + + +/**************************************************************************** + * + * DIRECTDRAW COLOR KEY CAPABILITY FLAGS + * + ****************************************************************************/ + +/* + * Supports transparent blting using a color key to identify the replaceable + * bits of the destination surface for RGB colors. + */ +#define DDCKEYCAPS_DESTBLT 0x00000001l + +/* + * Supports transparent blting using a color space to identify the replaceable + * bits of the destination surface for RGB colors. + */ +#define DDCKEYCAPS_DESTBLTCLRSPACE 0x00000002l + +/* + * Supports transparent blting using a color space to identify the replaceable + * bits of the destination surface for YUV colors. + */ +#define DDCKEYCAPS_DESTBLTCLRSPACEYUV 0x00000004l + +/* + * Supports transparent blting using a color key to identify the replaceable + * bits of the destination surface for YUV colors. + */ +#define DDCKEYCAPS_DESTBLTYUV 0x00000008l + +/* + * Supports overlaying using colorkeying of the replaceable bits of the surface + * being overlayed for RGB colors. + */ +#define DDCKEYCAPS_DESTOVERLAY 0x00000010l + +/* + * Supports a color space as the color key for the destination for RGB colors. + */ +#define DDCKEYCAPS_DESTOVERLAYCLRSPACE 0x00000020l + +/* + * Supports a color space as the color key for the destination for YUV colors. + */ +#define DDCKEYCAPS_DESTOVERLAYCLRSPACEYUV 0x00000040l + +/* + * Supports only one active destination color key value for visible overlay + * surfaces. + */ +#define DDCKEYCAPS_DESTOVERLAYONEACTIVE 0x00000080l + +/* + * Supports overlaying using colorkeying of the replaceable bits of the + * surface being overlayed for YUV colors. + */ +#define DDCKEYCAPS_DESTOVERLAYYUV 0x00000100l + +/* + * Supports transparent blting using the color key for the source with + * this surface for RGB colors. + */ +#define DDCKEYCAPS_SRCBLT 0x00000200l + +/* + * Supports transparent blting using a color space for the source with + * this surface for RGB colors. + */ +#define DDCKEYCAPS_SRCBLTCLRSPACE 0x00000400l + +/* + * Supports transparent blting using a color space for the source with + * this surface for YUV colors. + */ +#define DDCKEYCAPS_SRCBLTCLRSPACEYUV 0x00000800l + +/* + * Supports transparent blting using the color key for the source with + * this surface for YUV colors. + */ +#define DDCKEYCAPS_SRCBLTYUV 0x00001000l + +/* + * Supports overlays using the color key for the source with this + * overlay surface for RGB colors. + */ +#define DDCKEYCAPS_SRCOVERLAY 0x00002000l + +/* + * Supports overlays using a color space as the source color key for + * the overlay surface for RGB colors. + */ +#define DDCKEYCAPS_SRCOVERLAYCLRSPACE 0x00004000l + +/* + * Supports overlays using a color space as the source color key for + * the overlay surface for YUV colors. + */ +#define DDCKEYCAPS_SRCOVERLAYCLRSPACEYUV 0x00008000l + +/* + * Supports only one active source color key value for visible + * overlay surfaces. + */ +#define DDCKEYCAPS_SRCOVERLAYONEACTIVE 0x00010000l + +/* + * Supports overlays using the color key for the source with this + * overlay surface for YUV colors. + */ +#define DDCKEYCAPS_SRCOVERLAYYUV 0x00020000l + +/* + * there are no bandwidth trade-offs for using colorkey with an overlay + */ +#define DDCKEYCAPS_NOCOSTOVERLAY 0x00040000l + + +/**************************************************************************** + * + * DIRECTDRAW PIXELFORMAT FLAGS + * + ****************************************************************************/ + +/* + * The surface has alpha channel information in the pixel format. + */ +#define DDPF_ALPHAPIXELS 0x00000001l + +/* + * The pixel format contains alpha only information + */ +#define DDPF_ALPHA 0x00000002l + +/* + * The FourCC code is valid. + */ +#define DDPF_FOURCC 0x00000004l + +/* + * The surface is 4-bit color indexed. + */ +#define DDPF_PALETTEINDEXED4 0x00000008l + +/* + * The surface is indexed into a palette which stores indices + * into the destination surface's 8-bit palette. + */ +#define DDPF_PALETTEINDEXEDTO8 0x00000010l + +/* + * The surface is 8-bit color indexed. + */ +#define DDPF_PALETTEINDEXED8 0x00000020l + +/* + * The RGB data in the pixel format structure is valid. + */ +#define DDPF_RGB 0x00000040l + +/* + * The surface will accept pixel data in the format specified + * and compress it during the write. + */ +#define DDPF_COMPRESSED 0x00000080l + +/* + * The surface will accept RGB data and translate it during + * the write to YUV data. The format of the data to be written + * will be contained in the pixel format structure. The DDPF_RGB + * flag will be set. + */ +#define DDPF_RGBTOYUV 0x00000100l + +/* + * pixel format is YUV - YUV data in pixel format struct is valid + */ +#define DDPF_YUV 0x00000200l + +/* + * pixel format is a z buffer only surface + */ +#define DDPF_ZBUFFER 0x00000400l + +/* + * The surface is 1-bit color indexed. + */ +#define DDPF_PALETTEINDEXED1 0x00000800l + +/* + * The surface is 2-bit color indexed. + */ +#define DDPF_PALETTEINDEXED2 0x00001000l + +/* + * The surface contains Z information in the pixels + */ +#define DDPF_ZPIXELS 0x00002000l + +/* + * The surface contains stencil information along with Z + */ +#define DDPF_STENCILBUFFER 0x00004000l + +/* + * Premultiplied alpha format -- the color components have been + * premultiplied by the alpha component. + */ +#define DDPF_ALPHAPREMULT 0x00008000l + + +/* + * Luminance data in the pixel format is valid. + * Use this flag for luminance-only or luminance+alpha surfaces, + * the bit depth is then ddpf.dwLuminanceBitCount. + */ +#define DDPF_LUMINANCE 0x00020000l + +/* + * Luminance data in the pixel format is valid. + * Use this flag when hanging luminance off bumpmap surfaces, + * the bit mask for the luminance portion of the pixel is then + * ddpf.dwBumpLuminanceBitMask + */ +#define DDPF_BUMPLUMINANCE 0x00040000l + +/* + * Bump map dUdV data in the pixel format is valid. + */ +#define DDPF_BUMPDUDV 0x00080000l + + +/*=========================================================================== + * + * + * DIRECTDRAW CALLBACK FLAGS + * + * + *==========================================================================*/ + +/**************************************************************************** + * + * DIRECTDRAW ENUMSURFACES FLAGS + * + ****************************************************************************/ + +/* + * Enumerate all of the surfaces that meet the search criterion. + */ +#define DDENUMSURFACES_ALL 0x00000001l + +/* + * A search hit is a surface that matches the surface description. + */ +#define DDENUMSURFACES_MATCH 0x00000002l + +/* + * A search hit is a surface that does not match the surface description. + */ +#define DDENUMSURFACES_NOMATCH 0x00000004l + +/* + * Enumerate the first surface that can be created which meets the search criterion. + */ +#define DDENUMSURFACES_CANBECREATED 0x00000008l + +/* + * Enumerate the surfaces that already exist that meet the search criterion. + */ +#define DDENUMSURFACES_DOESEXIST 0x00000010l + + +/**************************************************************************** + * + * DIRECTDRAW SETDISPLAYMODE FLAGS + * + ****************************************************************************/ + +/* + * The desired mode is a standard VGA mode + */ +#define DDSDM_STANDARDVGAMODE 0x00000001l + + + +/**************************************************************************** + * + * DIRECTDRAW ENUMDISPLAYMODES FLAGS + * + ****************************************************************************/ + +/* + * Enumerate Modes with different refresh rates. EnumDisplayModes guarantees + * that a particular mode will be enumerated only once. This flag specifies whether + * the refresh rate is taken into account when determining if a mode is unique. + */ +#define DDEDM_REFRESHRATES 0x00000001l + +/* + * Enumerate VGA modes. Specify this flag if you wish to enumerate supported VGA + * modes such as mode 0x13 in addition to the usual ModeX modes (which are always + * enumerated if the application has previously called SetCooperativeLevel with the + * DDSCL_ALLOWMODEX flag set). + */ +#define DDEDM_STANDARDVGAMODES 0x00000002L + + +/**************************************************************************** + * + * DIRECTDRAW SETCOOPERATIVELEVEL FLAGS + * + ****************************************************************************/ + +/* + * Exclusive mode owner will be responsible for the entire primary surface. + * GDI can be ignored. used with DD + */ +#define DDSCL_FULLSCREEN 0x00000001l + +/* + * allow CTRL_ALT_DEL to work while in fullscreen exclusive mode + */ +#define DDSCL_ALLOWREBOOT 0x00000002l + +/* + * prevents DDRAW from modifying the application window. + * prevents DDRAW from minimize/restore the application window on activation. + */ +#define DDSCL_NOWINDOWCHANGES 0x00000004l + +/* + * app wants to work as a regular Windows application + */ +#define DDSCL_NORMAL 0x00000008l + +/* + * app wants exclusive access + */ +#define DDSCL_EXCLUSIVE 0x00000010l + + +/* + * app can deal with non-windows display modes + */ +#define DDSCL_ALLOWMODEX 0x00000040l + +/* + * this window will receive the focus messages + */ +#define DDSCL_SETFOCUSWINDOW 0x00000080l + +/* + * this window is associated with the DDRAW object and will + * cover the screen in fullscreen mode + */ +#define DDSCL_SETDEVICEWINDOW 0x00000100l + +/* + * app wants DDRAW to create a window to be associated with the + * DDRAW object + */ +#define DDSCL_CREATEDEVICEWINDOW 0x00000200l + +/* + * App explicitly asks DDRAW/D3D to be multithread safe. This makes D3D + * take the global crtisec more frequently. + */ +#define DDSCL_MULTITHREADED 0x00000400l + +/* + * App specifies that it would like to keep the FPU set up for optimal Direct3D + * performance (single precision and exceptions disabled) so Direct3D + * does not need to explicitly set the FPU each time. This is assumed by + * default in DirectX 7. See also DDSCL_FPUPRESERVE + */ +#define DDSCL_FPUSETUP 0x00000800l + +/* + * App specifies that it needs either double precision FPU or FPU exceptions + * enabled. This makes Direct3D explicitly set the FPU state eah time it is + * called. Setting the flag will reduce Direct3D performance. The flag is + * assumed by default in DirectX 6 and earlier. See also DDSCL_FPUSETUP + */ +#define DDSCL_FPUPRESERVE 0x00001000l + + +/**************************************************************************** + * + * DIRECTDRAW BLT FLAGS + * + ****************************************************************************/ + +/* + * Use the alpha information in the pixel format or the alpha channel surface + * attached to the destination surface as the alpha channel for this blt. + */ +#define DDBLT_ALPHADEST 0x00000001l + +/* + * Use the dwConstAlphaDest field in the DDBLTFX structure as the alpha channel + * for the destination surface for this blt. + */ +#define DDBLT_ALPHADESTCONSTOVERRIDE 0x00000002l + +/* + * The NEG suffix indicates that the destination surface becomes more + * transparent as the alpha value increases. (0 is opaque) + */ +#define DDBLT_ALPHADESTNEG 0x00000004l + +/* + * Use the lpDDSAlphaDest field in the DDBLTFX structure as the alpha + * channel for the destination for this blt. + */ +#define DDBLT_ALPHADESTSURFACEOVERRIDE 0x00000008l + +/* + * Use the dwAlphaEdgeBlend field in the DDBLTFX structure as the alpha channel + * for the edges of the image that border the color key colors. + */ +#define DDBLT_ALPHAEDGEBLEND 0x00000010l + +/* + * Use the alpha information in the pixel format or the alpha channel surface + * attached to the source surface as the alpha channel for this blt. + */ +#define DDBLT_ALPHASRC 0x00000020l + +/* + * Use the dwConstAlphaSrc field in the DDBLTFX structure as the alpha channel + * for the source for this blt. + */ +#define DDBLT_ALPHASRCCONSTOVERRIDE 0x00000040l + +/* + * The NEG suffix indicates that the source surface becomes more transparent + * as the alpha value increases. (0 is opaque) + */ +#define DDBLT_ALPHASRCNEG 0x00000080l + +/* + * Use the lpDDSAlphaSrc field in the DDBLTFX structure as the alpha channel + * for the source for this blt. + */ +#define DDBLT_ALPHASRCSURFACEOVERRIDE 0x00000100l + +/* + * Do this blt asynchronously through the FIFO in the order received. If + * there is no room in the hardware FIFO fail the call. + */ +#define DDBLT_ASYNC 0x00000200l + +/* + * Uses the dwFillColor field in the DDBLTFX structure as the RGB color + * to fill the destination rectangle on the destination surface with. + */ +#define DDBLT_COLORFILL 0x00000400l + +/* + * Uses the dwDDFX field in the DDBLTFX structure to specify the effects + * to use for the blt. + */ +#define DDBLT_DDFX 0x00000800l + +/* + * Uses the dwDDROPS field in the DDBLTFX structure to specify the ROPS + * that are not part of the Win32 API. + */ +#define DDBLT_DDROPS 0x00001000l + +/* + * Use the color key associated with the destination surface. + */ +#define DDBLT_KEYDEST 0x00002000l + +/* + * Use the dckDestColorkey field in the DDBLTFX structure as the color key + * for the destination surface. + */ +#define DDBLT_KEYDESTOVERRIDE 0x00004000l + +/* + * Use the color key associated with the source surface. + */ +#define DDBLT_KEYSRC 0x00008000l + +/* + * Use the dckSrcColorkey field in the DDBLTFX structure as the color key + * for the source surface. + */ +#define DDBLT_KEYSRCOVERRIDE 0x00010000l + +/* + * Use the dwROP field in the DDBLTFX structure for the raster operation + * for this blt. These ROPs are the same as the ones defined in the Win32 API. + */ +#define DDBLT_ROP 0x00020000l + +/* + * Use the dwRotationAngle field in the DDBLTFX structure as the angle + * (specified in 1/100th of a degree) to rotate the surface. + */ +#define DDBLT_ROTATIONANGLE 0x00040000l + +/* + * Z-buffered blt using the z-buffers attached to the source and destination + * surfaces and the dwZBufferOpCode field in the DDBLTFX structure as the + * z-buffer opcode. + */ +#define DDBLT_ZBUFFER 0x00080000l + +/* + * Z-buffered blt using the dwConstDest Zfield and the dwZBufferOpCode field + * in the DDBLTFX structure as the z-buffer and z-buffer opcode respectively + * for the destination. + */ +#define DDBLT_ZBUFFERDESTCONSTOVERRIDE 0x00100000l + +/* + * Z-buffered blt using the lpDDSDestZBuffer field and the dwZBufferOpCode + * field in the DDBLTFX structure as the z-buffer and z-buffer opcode + * respectively for the destination. + */ +#define DDBLT_ZBUFFERDESTOVERRIDE 0x00200000l + +/* + * Z-buffered blt using the dwConstSrcZ field and the dwZBufferOpCode field + * in the DDBLTFX structure as the z-buffer and z-buffer opcode respectively + * for the source. + */ +#define DDBLT_ZBUFFERSRCCONSTOVERRIDE 0x00400000l + +/* + * Z-buffered blt using the lpDDSSrcZBuffer field and the dwZBufferOpCode + * field in the DDBLTFX structure as the z-buffer and z-buffer opcode + * respectively for the source. + */ +#define DDBLT_ZBUFFERSRCOVERRIDE 0x00800000l + +/* + * wait until the device is ready to handle the blt + * this will cause blt to not return DDERR_WASSTILLDRAWING + */ +#define DDBLT_WAIT 0x01000000l + +/* + * Uses the dwFillDepth field in the DDBLTFX structure as the depth value + * to fill the destination rectangle on the destination Z-buffer surface + * with. + */ +#define DDBLT_DEPTHFILL 0x02000000l + + +/* + * wait until the device is ready to handle the blt + * this will cause blt to not return DDERR_WASSTILLDRAWING + */ +#define DDBLT_DONOTWAIT 0x08000000l + + +/**************************************************************************** + * + * BLTFAST FLAGS + * + ****************************************************************************/ + +#define DDBLTFAST_NOCOLORKEY 0x00000000 +#define DDBLTFAST_SRCCOLORKEY 0x00000001 +#define DDBLTFAST_DESTCOLORKEY 0x00000002 +#define DDBLTFAST_WAIT 0x00000010 +#define DDBLTFAST_DONOTWAIT 0x00000020 + + + +/**************************************************************************** + * + * FLIP FLAGS + * + ****************************************************************************/ + +#define DDFLIP_WAIT 0x00000001L + +/* + * Indicates that the target surface contains the even field of video data. + * This flag is only valid with an overlay surface. + */ +#define DDFLIP_EVEN 0x00000002L + +/* + * Indicates that the target surface contains the odd field of video data. + * This flag is only valid with an overlay surface. + */ +#define DDFLIP_ODD 0x00000004L + +/* + * Causes DirectDraw to perform the physical flip immediately and return + * to the application. Typically, what was the front buffer but is now the back + * buffer will still be visible (depending on timing) until the next vertical + * retrace. Subsequent operations involving the two flipped surfaces will + * not check to see if the physical flip has finished (i.e. will not return + * DDERR_WASSTILLDRAWING for that reason (but may for other reasons)). + * This allows an application to perform Flips at a higher frequency than the + * monitor refresh rate, but may introduce visible artifacts. + * Only effective if DDCAPS2_FLIPNOVSYNC is set. If that bit is not set, + * DDFLIP_NOVSYNC has no effect. + */ +#define DDFLIP_NOVSYNC 0x00000008L + + +/* + * Flip Interval Flags. These flags indicate how many vertical retraces to wait between + * each flip. The default is one. DirectDraw will return DDERR_WASSTILLDRAWING for each + * surface involved in the flip until the specified number of vertical retraces has + * ocurred. Only effective if DDCAPS2_FLIPINTERVAL is set. If that bit is not set, + * DDFLIP_INTERVALn has no effect. + */ + +/* + * DirectDraw will flip on every other vertical sync + */ +#define DDFLIP_INTERVAL2 0x02000000L + + +/* + * DirectDraw will flip on every third vertical sync + */ +#define DDFLIP_INTERVAL3 0x03000000L + + +/* + * DirectDraw will flip on every fourth vertical sync + */ +#define DDFLIP_INTERVAL4 0x04000000L + +/* + * DirectDraw will flip and display a main stereo surface + */ +#define DDFLIP_STEREO 0x00000010L + +/* + * On IDirectDrawSurface7 and higher interfaces, the default is DDFLIP_WAIT. If you wish + * to override the default and use time when the accelerator is busy (as denoted by + * the DDERR_WASSTILLDRAWING return code) then use DDFLIP_DONOTWAIT. + */ +#define DDFLIP_DONOTWAIT 0x00000020L + + + +/**************************************************************************** + * + * DIRECTDRAW SURFACE OVERLAY FLAGS + * + ****************************************************************************/ + +/* + * Use the alpha information in the pixel format or the alpha channel surface + * attached to the destination surface as the alpha channel for the + * destination overlay. + */ +#define DDOVER_ALPHADEST 0x00000001l + +/* + * Use the dwConstAlphaDest field in the DDOVERLAYFX structure as the + * destination alpha channel for this overlay. + */ +#define DDOVER_ALPHADESTCONSTOVERRIDE 0x00000002l + +/* + * The NEG suffix indicates that the destination surface becomes more + * transparent as the alpha value increases. + */ +#define DDOVER_ALPHADESTNEG 0x00000004l + +/* + * Use the lpDDSAlphaDest field in the DDOVERLAYFX structure as the alpha + * channel destination for this overlay. + */ +#define DDOVER_ALPHADESTSURFACEOVERRIDE 0x00000008l + +/* + * Use the dwAlphaEdgeBlend field in the DDOVERLAYFX structure as the alpha + * channel for the edges of the image that border the color key colors. + */ +#define DDOVER_ALPHAEDGEBLEND 0x00000010l + +/* + * Use the alpha information in the pixel format or the alpha channel surface + * attached to the source surface as the source alpha channel for this overlay. + */ +#define DDOVER_ALPHASRC 0x00000020l + +/* + * Use the dwConstAlphaSrc field in the DDOVERLAYFX structure as the source + * alpha channel for this overlay. + */ +#define DDOVER_ALPHASRCCONSTOVERRIDE 0x00000040l + +/* + * The NEG suffix indicates that the source surface becomes more transparent + * as the alpha value increases. + */ +#define DDOVER_ALPHASRCNEG 0x00000080l + +/* + * Use the lpDDSAlphaSrc field in the DDOVERLAYFX structure as the alpha channel + * source for this overlay. + */ +#define DDOVER_ALPHASRCSURFACEOVERRIDE 0x00000100l + +/* + * Turn this overlay off. + */ +#define DDOVER_HIDE 0x00000200l + +/* + * Use the color key associated with the destination surface. + */ +#define DDOVER_KEYDEST 0x00000400l + +/* + * Use the dckDestColorkey field in the DDOVERLAYFX structure as the color key + * for the destination surface + */ +#define DDOVER_KEYDESTOVERRIDE 0x00000800l + +/* + * Use the color key associated with the source surface. + */ +#define DDOVER_KEYSRC 0x00001000l + +/* + * Use the dckSrcColorkey field in the DDOVERLAYFX structure as the color key + * for the source surface. + */ +#define DDOVER_KEYSRCOVERRIDE 0x00002000l + +/* + * Turn this overlay on. + */ +#define DDOVER_SHOW 0x00004000l + +/* + * Add a dirty rect to an emulated overlayed surface. + */ +#define DDOVER_ADDDIRTYRECT 0x00008000l + +/* + * Redraw all dirty rects on an emulated overlayed surface. + */ +#define DDOVER_REFRESHDIRTYRECTS 0x00010000l + +/* + * Redraw the entire surface on an emulated overlayed surface. + */ +#define DDOVER_REFRESHALL 0x00020000l + + +/* + * Use the overlay FX flags to define special overlay FX + */ +#define DDOVER_DDFX 0x00080000l + +/* + * Autoflip the overlay when ever the video port autoflips + */ +#define DDOVER_AUTOFLIP 0x00100000l + +/* + * Display each field of video port data individually without + * causing any jittery artifacts + */ +#define DDOVER_BOB 0x00200000l + +/* + * Indicates that bob/weave decisions should not be overridden by other + * interfaces. + */ +#define DDOVER_OVERRIDEBOBWEAVE 0x00400000l + +/* + * Indicates that the surface memory is composed of interleaved fields. + */ +#define DDOVER_INTERLEAVED 0x00800000l + +/* + * Indicates that bob will be performed using hardware rather than + * software or emulated. + */ +#define DDOVER_BOBHARDWARE 0x01000000l + +/* + * Indicates that overlay FX structure contains valid ARGB scaling factors. + */ +#define DDOVER_ARGBSCALEFACTORS 0x02000000l + +/* + * Indicates that ARGB scaling factors can be degraded to fit driver capabilities. + */ +#define DDOVER_DEGRADEARGBSCALING 0x04000000l + + + + + + + + +/**************************************************************************** + * + * DIRECTDRAWSURFACE LOCK FLAGS + * + ****************************************************************************/ + +/* + * The default. Set to indicate that Lock should return a valid memory pointer + * to the top of the specified rectangle. If no rectangle is specified then a + * pointer to the top of the surface is returned. + */ +#define DDLOCK_SURFACEMEMORYPTR 0x00000000L // default + +/* + * Set to indicate that Lock should wait until it can obtain a valid memory + * pointer before returning. If this bit is set, Lock will never return + * DDERR_WASSTILLDRAWING. + */ +#define DDLOCK_WAIT 0x00000001L + +/* + * Set if an event handle is being passed to Lock. Lock will trigger the event + * when it can return the surface memory pointer requested. + */ +#define DDLOCK_EVENT 0x00000002L + +/* + * Indicates that the surface being locked will only be read from. + */ +#define DDLOCK_READONLY 0x00000010L + +/* + * Indicates that the surface being locked will only be written to + */ +#define DDLOCK_WRITEONLY 0x00000020L + + +/* + * Indicates that a system wide lock should not be taken when this surface + * is locked. This has several advantages (cursor responsiveness, ability + * to call more Windows functions, easier debugging) when locking video + * memory surfaces. However, an application specifying this flag must + * comply with a number of conditions documented in the help file. + * Furthermore, this flag cannot be specified when locking the primary. + */ +#define DDLOCK_NOSYSLOCK 0x00000800L + +/* + * Used only with Direct3D Vertex Buffer Locks. Indicates that no vertices + * that were referred to in Draw*PrimtiveVB calls since the start of the + * frame (or the last lock without this flag) will be modified during the + * lock. This can be useful when one is only appending data to the vertex + * buffer + */ +#define DDLOCK_NOOVERWRITE 0x00001000L + +/* + * Indicates that no assumptions will be made about the contents of the + * surface or vertex buffer during this lock. + * This enables two things: + * - Direct3D or the driver may provide an alternative memory + * area as the vertex buffer. This is useful when one plans to clear the + * contents of the vertex buffer and fill in new data. + * - Drivers sometimes store surface data in a re-ordered format. + * When the application locks the surface, the driver is forced to un-re-order + * the surface data before allowing the application to see the surface contents. + * This flag is a hint to the driver that it can skip the un-re-ordering process + * since the application plans to overwrite every single pixel in the surface + * or locked rectangle (and so erase any un-re-ordered pixels anyway). + * Applications should always set this flag when they intend to overwrite the entire + * surface or locked rectangle. + */ +#define DDLOCK_DISCARDCONTENTS 0x00002000L + /* + * DDLOCK_OKTOSWAP is an older, less informative name for DDLOCK_DISCARDCONTENTS + */ +#define DDLOCK_OKTOSWAP 0x00002000L + +/* + * On IDirectDrawSurface7 and higher interfaces, the default is DDLOCK_WAIT. If you wish + * to override the default and use time when the accelerator is busy (as denoted by + * the DDERR_WASSTILLDRAWING return code) then use DDLOCK_DONOTWAIT. + */ +#define DDLOCK_DONOTWAIT 0x00004000L + + + +/**************************************************************************** + * + * DIRECTDRAWSURFACE PAGELOCK FLAGS + * + ****************************************************************************/ + +/* + * No flags defined at present + */ + + +/**************************************************************************** + * + * DIRECTDRAWSURFACE PAGEUNLOCK FLAGS + * + ****************************************************************************/ + +/* + * No flags defined at present + */ + + +/**************************************************************************** + * + * DIRECTDRAWSURFACE BLT FX FLAGS + * + ****************************************************************************/ + +/* + * If stretching, use arithmetic stretching along the Y axis for this blt. + */ +#define DDBLTFX_ARITHSTRETCHY 0x00000001l + +/* + * Do this blt mirroring the surface left to right. Spin the + * surface around its y-axis. + */ +#define DDBLTFX_MIRRORLEFTRIGHT 0x00000002l + +/* + * Do this blt mirroring the surface up and down. Spin the surface + * around its x-axis. + */ +#define DDBLTFX_MIRRORUPDOWN 0x00000004l + +/* + * Schedule this blt to avoid tearing. + */ +#define DDBLTFX_NOTEARING 0x00000008l + +/* + * Do this blt rotating the surface one hundred and eighty degrees. + */ +#define DDBLTFX_ROTATE180 0x00000010l + +/* + * Do this blt rotating the surface two hundred and seventy degrees. + */ +#define DDBLTFX_ROTATE270 0x00000020l + +/* + * Do this blt rotating the surface ninety degrees. + */ +#define DDBLTFX_ROTATE90 0x00000040l + +/* + * Do this z blt using dwZBufferLow and dwZBufferHigh as range values + * specified to limit the bits copied from the source surface. + */ +#define DDBLTFX_ZBUFFERRANGE 0x00000080l + +/* + * Do this z blt adding the dwZBufferBaseDest to each of the sources z values + * before comparing it with the desting z values. + */ +#define DDBLTFX_ZBUFFERBASEDEST 0x00000100l + +/**************************************************************************** + * + * DIRECTDRAWSURFACE OVERLAY FX FLAGS + * + ****************************************************************************/ + +/* + * If stretching, use arithmetic stretching along the Y axis for this overlay. + */ +#define DDOVERFX_ARITHSTRETCHY 0x00000001l + +/* + * Mirror the overlay across the vertical axis + */ +#define DDOVERFX_MIRRORLEFTRIGHT 0x00000002l + +/* + * Mirror the overlay across the horizontal axis + */ +#define DDOVERFX_MIRRORUPDOWN 0x00000004l + + +/**************************************************************************** + * + * DIRECTDRAW WAITFORVERTICALBLANK FLAGS + * + ****************************************************************************/ + +/* + * return when the vertical blank interval begins + */ +#define DDWAITVB_BLOCKBEGIN 0x00000001l + +/* + * set up an event to trigger when the vertical blank begins + */ +#define DDWAITVB_BLOCKBEGINEVENT 0x00000002l + +/* + * return when the vertical blank interval ends and display begins + */ +#define DDWAITVB_BLOCKEND 0x00000004l + +/**************************************************************************** + * + * DIRECTDRAW GETFLIPSTATUS FLAGS + * + ****************************************************************************/ + +/* + * is it OK to flip now? + */ +#define DDGFS_CANFLIP 0x00000001l + +/* + * is the last flip finished? + */ +#define DDGFS_ISFLIPDONE 0x00000002l + +/**************************************************************************** + * + * DIRECTDRAW GETBLTSTATUS FLAGS + * + ****************************************************************************/ + +/* + * is it OK to blt now? + */ +#define DDGBS_CANBLT 0x00000001l + +/* + * is the blt to the surface finished? + */ +#define DDGBS_ISBLTDONE 0x00000002l + + +/**************************************************************************** + * + * DIRECTDRAW ENUMOVERLAYZORDER FLAGS + * + ****************************************************************************/ + +/* + * Enumerate overlays back to front. + */ +#define DDENUMOVERLAYZ_BACKTOFRONT 0x00000000l + +/* + * Enumerate overlays front to back + */ +#define DDENUMOVERLAYZ_FRONTTOBACK 0x00000001l + +/**************************************************************************** + * + * DIRECTDRAW UPDATEOVERLAYZORDER FLAGS + * + ****************************************************************************/ + +/* + * Send overlay to front + */ +#define DDOVERZ_SENDTOFRONT 0x00000000l + +/* + * Send overlay to back + */ +#define DDOVERZ_SENDTOBACK 0x00000001l + +/* + * Move Overlay forward + */ +#define DDOVERZ_MOVEFORWARD 0x00000002l + +/* + * Move Overlay backward + */ +#define DDOVERZ_MOVEBACKWARD 0x00000003l + +/* + * Move Overlay in front of relative surface + */ +#define DDOVERZ_INSERTINFRONTOF 0x00000004l + +/* + * Move Overlay in back of relative surface + */ +#define DDOVERZ_INSERTINBACKOF 0x00000005l + + + +/**************************************************************************** + * + * DIRECTDRAW SETGAMMARAMP FLAGS + * + ****************************************************************************/ + +/* + * Request calibrator to adjust the gamma ramp according to the physical + * properties of the display so that the result should appear identical + * on all systems. + */ +#define DDSGR_CALIBRATE 0x00000001L + + +/**************************************************************************** + * + * DIRECTDRAW STARTMODETEST FLAGS + * + ****************************************************************************/ + +/* + * Indicates that the mode being tested has passed + */ +#define DDSMT_ISTESTREQUIRED 0x00000001L + + +/**************************************************************************** + * + * DIRECTDRAW EVALUATEMODE FLAGS + * + ****************************************************************************/ + +/* + * Indicates that the mode being tested has passed + */ +#define DDEM_MODEPASSED 0x00000001L + +/* + * Indicates that the mode being tested has failed + */ +#define DDEM_MODEFAILED 0x00000002L + + +/*=========================================================================== + * + * + * DIRECTDRAW RETURN CODES + * + * The return values from DirectDraw Commands and Surface that return an HRESULT + * are codes from DirectDraw concerning the results of the action + * requested by DirectDraw. + * + *==========================================================================*/ + +/* + * Status is OK + * + * Issued by: DirectDraw Commands and all callbacks + */ +#define DD_OK 0 +#define DD_FALSE S_FALSE + +/**************************************************************************** + * + * DIRECTDRAW ENUMCALLBACK RETURN VALUES + * + * EnumCallback returns are used to control the flow of the DIRECTDRAW and + * DIRECTDRAWSURFACE object enumerations. They can only be returned by + * enumeration callback routines. + * + ****************************************************************************/ + +/* + * stop the enumeration + */ +#define DDENUMRET_CANCEL 0 + +/* + * continue the enumeration + */ +#define DDENUMRET_OK 1 + +/**************************************************************************** + * + * DIRECTDRAW ERRORS + * + * Errors are represented by negative values and cannot be combined. + * + ****************************************************************************/ + +/* + * This object is already initialized + */ +#define DDERR_ALREADYINITIALIZED MAKE_DDHRESULT( 5 ) + +/* + * This surface can not be attached to the requested surface. + */ +#define DDERR_CANNOTATTACHSURFACE MAKE_DDHRESULT( 10 ) + +/* + * This surface can not be detached from the requested surface. + */ +#define DDERR_CANNOTDETACHSURFACE MAKE_DDHRESULT( 20 ) + +/* + * Support is currently not available. + */ +#define DDERR_CURRENTLYNOTAVAIL MAKE_DDHRESULT( 40 ) + +/* + * An exception was encountered while performing the requested operation + */ +#define DDERR_EXCEPTION MAKE_DDHRESULT( 55 ) + +/* + * Generic failure. + */ +#define DDERR_GENERIC E_FAIL + +/* + * Height of rectangle provided is not a multiple of reqd alignment + */ +#define DDERR_HEIGHTALIGN MAKE_DDHRESULT( 90 ) + +/* + * Unable to match primary surface creation request with existing + * primary surface. + */ +#define DDERR_INCOMPATIBLEPRIMARY MAKE_DDHRESULT( 95 ) + +/* + * One or more of the caps bits passed to the callback are incorrect. + */ +#define DDERR_INVALIDCAPS MAKE_DDHRESULT( 100 ) + +/* + * DirectDraw does not support provided Cliplist. + */ +#define DDERR_INVALIDCLIPLIST MAKE_DDHRESULT( 110 ) + +/* + * DirectDraw does not support the requested mode + */ +#define DDERR_INVALIDMODE MAKE_DDHRESULT( 120 ) + +/* + * DirectDraw received a pointer that was an invalid DIRECTDRAW object. + */ +#define DDERR_INVALIDOBJECT MAKE_DDHRESULT( 130 ) + +/* + * One or more of the parameters passed to the callback function are + * incorrect. + */ +#define DDERR_INVALIDPARAMS E_INVALIDARG + +/* + * pixel format was invalid as specified + */ +#define DDERR_INVALIDPIXELFORMAT MAKE_DDHRESULT( 145 ) + +/* + * Rectangle provided was invalid. + */ +#define DDERR_INVALIDRECT MAKE_DDHRESULT( 150 ) + +/* + * Operation could not be carried out because one or more surfaces are locked + */ +#define DDERR_LOCKEDSURFACES MAKE_DDHRESULT( 160 ) + +/* + * There is no 3D present. + */ +#define DDERR_NO3D MAKE_DDHRESULT( 170 ) + +/* + * Operation could not be carried out because there is no alpha accleration + * hardware present or available. + */ +#define DDERR_NOALPHAHW MAKE_DDHRESULT( 180 ) + +/* + * Operation could not be carried out because there is no stereo + * hardware present or available. + */ +#define DDERR_NOSTEREOHARDWARE MAKE_DDHRESULT( 181 ) + +/* + * Operation could not be carried out because there is no hardware + * present which supports stereo surfaces + */ +#define DDERR_NOSURFACELEFT MAKE_DDHRESULT( 182 ) + + + +/* + * no clip list available + */ +#define DDERR_NOCLIPLIST MAKE_DDHRESULT( 205 ) + +/* + * Operation could not be carried out because there is no color conversion + * hardware present or available. + */ +#define DDERR_NOCOLORCONVHW MAKE_DDHRESULT( 210 ) + +/* + * Create function called without DirectDraw object method SetCooperativeLevel + * being called. + */ +#define DDERR_NOCOOPERATIVELEVELSET MAKE_DDHRESULT( 212 ) + +/* + * Surface doesn't currently have a color key + */ +#define DDERR_NOCOLORKEY MAKE_DDHRESULT( 215 ) + +/* + * Operation could not be carried out because there is no hardware support + * of the dest color key. + */ +#define DDERR_NOCOLORKEYHW MAKE_DDHRESULT( 220 ) + +/* + * No DirectDraw support possible with current display driver + */ +#define DDERR_NODIRECTDRAWSUPPORT MAKE_DDHRESULT( 222 ) + +/* + * Operation requires the application to have exclusive mode but the + * application does not have exclusive mode. + */ +#define DDERR_NOEXCLUSIVEMODE MAKE_DDHRESULT( 225 ) + +/* + * Flipping visible surfaces is not supported. + */ +#define DDERR_NOFLIPHW MAKE_DDHRESULT( 230 ) + +/* + * There is no GDI present. + */ +#define DDERR_NOGDI MAKE_DDHRESULT( 240 ) + +/* + * Operation could not be carried out because there is no hardware present + * or available. + */ +#define DDERR_NOMIRRORHW MAKE_DDHRESULT( 250 ) + +/* + * Requested item was not found + */ +#define DDERR_NOTFOUND MAKE_DDHRESULT( 255 ) + +/* + * Operation could not be carried out because there is no overlay hardware + * present or available. + */ +#define DDERR_NOOVERLAYHW MAKE_DDHRESULT( 260 ) + +/* + * Operation could not be carried out because the source and destination + * rectangles are on the same surface and overlap each other. + */ +#define DDERR_OVERLAPPINGRECTS MAKE_DDHRESULT( 270 ) + +/* + * Operation could not be carried out because there is no appropriate raster + * op hardware present or available. + */ +#define DDERR_NORASTEROPHW MAKE_DDHRESULT( 280 ) + +/* + * Operation could not be carried out because there is no rotation hardware + * present or available. + */ +#define DDERR_NOROTATIONHW MAKE_DDHRESULT( 290 ) + +/* + * Operation could not be carried out because there is no hardware support + * for stretching + */ +#define DDERR_NOSTRETCHHW MAKE_DDHRESULT( 310 ) + +/* + * DirectDrawSurface is not in 4 bit color palette and the requested operation + * requires 4 bit color palette. + */ +#define DDERR_NOT4BITCOLOR MAKE_DDHRESULT( 316 ) + +/* + * DirectDrawSurface is not in 4 bit color index palette and the requested + * operation requires 4 bit color index palette. + */ +#define DDERR_NOT4BITCOLORINDEX MAKE_DDHRESULT( 317 ) + +/* + * DirectDraw Surface is not in 8 bit color mode and the requested operation + * requires 8 bit color. + */ +#define DDERR_NOT8BITCOLOR MAKE_DDHRESULT( 320 ) + +/* + * Operation could not be carried out because there is no texture mapping + * hardware present or available. + */ +#define DDERR_NOTEXTUREHW MAKE_DDHRESULT( 330 ) + +/* + * Operation could not be carried out because there is no hardware support + * for vertical blank synchronized operations. + */ +#define DDERR_NOVSYNCHW MAKE_DDHRESULT( 335 ) + +/* + * Operation could not be carried out because there is no hardware support + * for zbuffer blting. + */ +#define DDERR_NOZBUFFERHW MAKE_DDHRESULT( 340 ) + +/* + * Overlay surfaces could not be z layered based on their BltOrder because + * the hardware does not support z layering of overlays. + */ +#define DDERR_NOZOVERLAYHW MAKE_DDHRESULT( 350 ) + +/* + * The hardware needed for the requested operation has already been + * allocated. + */ +#define DDERR_OUTOFCAPS MAKE_DDHRESULT( 360 ) + +/* + * DirectDraw does not have enough memory to perform the operation. + */ +#define DDERR_OUTOFMEMORY E_OUTOFMEMORY + +/* + * DirectDraw does not have enough memory to perform the operation. + */ +#define DDERR_OUTOFVIDEOMEMORY MAKE_DDHRESULT( 380 ) + +/* + * hardware does not support clipped overlays + */ +#define DDERR_OVERLAYCANTCLIP MAKE_DDHRESULT( 382 ) + +/* + * Can only have ony color key active at one time for overlays + */ +#define DDERR_OVERLAYCOLORKEYONLYONEACTIVE MAKE_DDHRESULT( 384 ) + +/* + * Access to this palette is being refused because the palette is already + * locked by another thread. + */ +#define DDERR_PALETTEBUSY MAKE_DDHRESULT( 387 ) + +/* + * No src color key specified for this operation. + */ +#define DDERR_COLORKEYNOTSET MAKE_DDHRESULT( 400 ) + +/* + * This surface is already attached to the surface it is being attached to. + */ +#define DDERR_SURFACEALREADYATTACHED MAKE_DDHRESULT( 410 ) + +/* + * This surface is already a dependency of the surface it is being made a + * dependency of. + */ +#define DDERR_SURFACEALREADYDEPENDENT MAKE_DDHRESULT( 420 ) + +/* + * Access to this surface is being refused because the surface is already + * locked by another thread. + */ +#define DDERR_SURFACEBUSY MAKE_DDHRESULT( 430 ) + +/* + * Access to this surface is being refused because no driver exists + * which can supply a pointer to the surface. + * This is most likely to happen when attempting to lock the primary + * surface when no DCI provider is present. + * Will also happen on attempts to lock an optimized surface. + */ +#define DDERR_CANTLOCKSURFACE MAKE_DDHRESULT( 435 ) + +/* + * Access to Surface refused because Surface is obscured. + */ +#define DDERR_SURFACEISOBSCURED MAKE_DDHRESULT( 440 ) + +/* + * Access to this surface is being refused because the surface is gone. + * The DIRECTDRAWSURFACE object representing this surface should + * have Restore called on it. + */ +#define DDERR_SURFACELOST MAKE_DDHRESULT( 450 ) + +/* + * The requested surface is not attached. + */ +#define DDERR_SURFACENOTATTACHED MAKE_DDHRESULT( 460 ) + +/* + * Height requested by DirectDraw is too large. + */ +#define DDERR_TOOBIGHEIGHT MAKE_DDHRESULT( 470 ) + +/* + * Size requested by DirectDraw is too large -- The individual height and + * width are OK. + */ +#define DDERR_TOOBIGSIZE MAKE_DDHRESULT( 480 ) + +/* + * Width requested by DirectDraw is too large. + */ +#define DDERR_TOOBIGWIDTH MAKE_DDHRESULT( 490 ) + +/* + * Action not supported. + */ +#define DDERR_UNSUPPORTED E_NOTIMPL + +/* + * Pixel format requested is unsupported by DirectDraw + */ +#define DDERR_UNSUPPORTEDFORMAT MAKE_DDHRESULT( 510 ) + +/* + * Bitmask in the pixel format requested is unsupported by DirectDraw + */ +#define DDERR_UNSUPPORTEDMASK MAKE_DDHRESULT( 520 ) + +/* + * The specified stream contains invalid data + */ +#define DDERR_INVALIDSTREAM MAKE_DDHRESULT( 521 ) + +/* + * vertical blank is in progress + */ +#define DDERR_VERTICALBLANKINPROGRESS MAKE_DDHRESULT( 537 ) + +/* + * Informs DirectDraw that the previous Blt which is transfering information + * to or from this Surface is incomplete. + */ +#define DDERR_WASSTILLDRAWING MAKE_DDHRESULT( 540 ) + + +/* + * The specified surface type requires specification of the COMPLEX flag + */ +#define DDERR_DDSCAPSCOMPLEXREQUIRED MAKE_DDHRESULT( 542 ) + + +/* + * Rectangle provided was not horizontally aligned on reqd. boundary + */ +#define DDERR_XALIGN MAKE_DDHRESULT( 560 ) + +/* + * The GUID passed to DirectDrawCreate is not a valid DirectDraw driver + * identifier. + */ +#define DDERR_INVALIDDIRECTDRAWGUID MAKE_DDHRESULT( 561 ) + +/* + * A DirectDraw object representing this driver has already been created + * for this process. + */ +#define DDERR_DIRECTDRAWALREADYCREATED MAKE_DDHRESULT( 562 ) + +/* + * A hardware only DirectDraw object creation was attempted but the driver + * did not support any hardware. + */ +#define DDERR_NODIRECTDRAWHW MAKE_DDHRESULT( 563 ) + +/* + * this process already has created a primary surface + */ +#define DDERR_PRIMARYSURFACEALREADYEXISTS MAKE_DDHRESULT( 564 ) + +/* + * software emulation not available. + */ +#define DDERR_NOEMULATION MAKE_DDHRESULT( 565 ) + +/* + * region passed to Clipper::GetClipList is too small. + */ +#define DDERR_REGIONTOOSMALL MAKE_DDHRESULT( 566 ) + +/* + * an attempt was made to set a clip list for a clipper objec that + * is already monitoring an hwnd. + */ +#define DDERR_CLIPPERISUSINGHWND MAKE_DDHRESULT( 567 ) + +/* + * No clipper object attached to surface object + */ +#define DDERR_NOCLIPPERATTACHED MAKE_DDHRESULT( 568 ) + +/* + * Clipper notification requires an HWND or + * no HWND has previously been set as the CooperativeLevel HWND. + */ +#define DDERR_NOHWND MAKE_DDHRESULT( 569 ) + +/* + * HWND used by DirectDraw CooperativeLevel has been subclassed, + * this prevents DirectDraw from restoring state. + */ +#define DDERR_HWNDSUBCLASSED MAKE_DDHRESULT( 570 ) + +/* + * The CooperativeLevel HWND has already been set. + * It can not be reset while the process has surfaces or palettes created. + */ +#define DDERR_HWNDALREADYSET MAKE_DDHRESULT( 571 ) + +/* + * No palette object attached to this surface. + */ +#define DDERR_NOPALETTEATTACHED MAKE_DDHRESULT( 572 ) + +/* + * No hardware support for 16 or 256 color palettes. + */ +#define DDERR_NOPALETTEHW MAKE_DDHRESULT( 573 ) + +/* + * If a clipper object is attached to the source surface passed into a + * BltFast call. + */ +#define DDERR_BLTFASTCANTCLIP MAKE_DDHRESULT( 574 ) + +/* + * No blter. + */ +#define DDERR_NOBLTHW MAKE_DDHRESULT( 575 ) + +/* + * No DirectDraw ROP hardware. + */ +#define DDERR_NODDROPSHW MAKE_DDHRESULT( 576 ) + +/* + * returned when GetOverlayPosition is called on a hidden overlay + */ +#define DDERR_OVERLAYNOTVISIBLE MAKE_DDHRESULT( 577 ) + +/* + * returned when GetOverlayPosition is called on a overlay that UpdateOverlay + * has never been called on to establish a destionation. + */ +#define DDERR_NOOVERLAYDEST MAKE_DDHRESULT( 578 ) + +/* + * returned when the position of the overlay on the destionation is no longer + * legal for that destionation. + */ +#define DDERR_INVALIDPOSITION MAKE_DDHRESULT( 579 ) + +/* + * returned when an overlay member is called for a non-overlay surface + */ +#define DDERR_NOTAOVERLAYSURFACE MAKE_DDHRESULT( 580 ) + +/* + * An attempt was made to set the cooperative level when it was already + * set to exclusive. + */ +#define DDERR_EXCLUSIVEMODEALREADYSET MAKE_DDHRESULT( 581 ) + +/* + * An attempt has been made to flip a surface that is not flippable. + */ +#define DDERR_NOTFLIPPABLE MAKE_DDHRESULT( 582 ) + +/* + * Can't duplicate primary & 3D surfaces, or surfaces that are implicitly + * created. + */ +#define DDERR_CANTDUPLICATE MAKE_DDHRESULT( 583 ) + +/* + * Surface was not locked. An attempt to unlock a surface that was not + * locked at all, or by this process, has been attempted. + */ +#define DDERR_NOTLOCKED MAKE_DDHRESULT( 584 ) + +/* + * Windows can not create any more DCs, or a DC was requested for a paltte-indexed + * surface when the surface had no palette AND the display mode was not palette-indexed + * (in this case DirectDraw cannot select a proper palette into the DC) + */ +#define DDERR_CANTCREATEDC MAKE_DDHRESULT( 585 ) + +/* + * No DC was ever created for this surface. + */ +#define DDERR_NODC MAKE_DDHRESULT( 586 ) + +/* + * This surface can not be restored because it was created in a different + * mode. + */ +#define DDERR_WRONGMODE MAKE_DDHRESULT( 587 ) + +/* + * This surface can not be restored because it is an implicitly created + * surface. + */ +#define DDERR_IMPLICITLYCREATED MAKE_DDHRESULT( 588 ) + +/* + * The surface being used is not a palette-based surface + */ +#define DDERR_NOTPALETTIZED MAKE_DDHRESULT( 589 ) + + +/* + * The display is currently in an unsupported mode + */ +#define DDERR_UNSUPPORTEDMODE MAKE_DDHRESULT( 590 ) + +/* + * Operation could not be carried out because there is no mip-map + * texture mapping hardware present or available. + */ +#define DDERR_NOMIPMAPHW MAKE_DDHRESULT( 591 ) + +/* + * The requested action could not be performed because the surface was of + * the wrong type. + */ +#define DDERR_INVALIDSURFACETYPE MAKE_DDHRESULT( 592 ) + + + +/* + * Device does not support optimized surfaces, therefore no video memory optimized surfaces + */ +#define DDERR_NOOPTIMIZEHW MAKE_DDHRESULT( 600 ) + +/* + * Surface is an optimized surface, but has not yet been allocated any memory + */ +#define DDERR_NOTLOADED MAKE_DDHRESULT( 601 ) + +/* + * Attempt was made to create or set a device window without first setting + * the focus window + */ +#define DDERR_NOFOCUSWINDOW MAKE_DDHRESULT( 602 ) + +/* + * Attempt was made to set a palette on a mipmap sublevel + */ +#define DDERR_NOTONMIPMAPSUBLEVEL MAKE_DDHRESULT( 603 ) + +/* + * A DC has already been returned for this surface. Only one DC can be + * retrieved per surface. + */ +#define DDERR_DCALREADYCREATED MAKE_DDHRESULT( 620 ) + +/* + * An attempt was made to allocate non-local video memory from a device + * that does not support non-local video memory. + */ +#define DDERR_NONONLOCALVIDMEM MAKE_DDHRESULT( 630 ) + +/* + * The attempt to page lock a surface failed. + */ +#define DDERR_CANTPAGELOCK MAKE_DDHRESULT( 640 ) + + +/* + * The attempt to page unlock a surface failed. + */ +#define DDERR_CANTPAGEUNLOCK MAKE_DDHRESULT( 660 ) + +/* + * An attempt was made to page unlock a surface with no outstanding page locks. + */ +#define DDERR_NOTPAGELOCKED MAKE_DDHRESULT( 680 ) + +/* + * There is more data available than the specified buffer size could hold + */ +#define DDERR_MOREDATA MAKE_DDHRESULT( 690 ) + +/* + * The data has expired and is therefore no longer valid. + */ +#define DDERR_EXPIRED MAKE_DDHRESULT( 691 ) + +/* + * The mode test has finished executing. + */ +#define DDERR_TESTFINISHED MAKE_DDHRESULT( 692 ) + +/* + * The mode test has switched to a new mode. + */ +#define DDERR_NEWMODE MAKE_DDHRESULT( 693 ) + +/* + * D3D has not yet been initialized. + */ +#define DDERR_D3DNOTINITIALIZED MAKE_DDHRESULT( 694 ) + +/* + * The video port is not active + */ +#define DDERR_VIDEONOTACTIVE MAKE_DDHRESULT( 695 ) + +/* + * The monitor does not have EDID data. + */ +#define DDERR_NOMONITORINFORMATION MAKE_DDHRESULT( 696 ) + +/* + * The driver does not enumerate display mode refresh rates. + */ +#define DDERR_NODRIVERSUPPORT MAKE_DDHRESULT( 697 ) + +/* + * Surfaces created by one direct draw device cannot be used directly by + * another direct draw device. + */ +#define DDERR_DEVICEDOESNTOWNSURFACE MAKE_DDHRESULT( 699 ) + + + +/* + * An attempt was made to invoke an interface member of a DirectDraw object + * created by CoCreateInstance() before it was initialized. + */ +#define DDERR_NOTINITIALIZED CO_E_NOTINITIALIZED + + +/* Alpha bit depth constants */ + + +#ifdef __cplusplus +}; +#endif + +#ifdef _MSC_VER +#pragma warning(default:4201) +#endif + +#endif //__DDRAW_INCLUDED__ + diff --git a/engine/libs/dxsdk7/lib/d3dx.lib b/engine/libs/dxsdk7/lib/d3dx.lib new file mode 100644 index 0000000000000000000000000000000000000000..60491447f4e1d274e45ba640b294534549222b49 GIT binary patch literal 563186 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%0Dv)-lpOKCdANkUu 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%0A2YU*XweDppbzk}Ng4E*_L{dGnC8nuIv|r7S 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 literal 0 HcmV?d00001 diff --git a/engine/libs/dxsdk7/lib/ddraw.lib b/engine/libs/dxsdk7/lib/ddraw.lib new file mode 100644 index 0000000000000000000000000000000000000000..be1c984604e76034420e4e7fc61478b9f7e51695 GIT binary patch literal 28000 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 oy*f9CcO~DlwIB5i^hLx6*E*QU zjRR>ELycNdEYC7oOqzd(b8T8@DWjLnRHP%9)k-P7WTqN&3l{W27x$#~dro7UF)iPd zZq>waJXcI+jA_gtX}}3I5RK1i!AVHV$69lED%ulu-D#NHtZ{vt_HbA$6q4;)A=cg1 z1tVDl%i2k}8Qo+@trV^Dxx}5r(_L^r1(a%cp>1{Jj>aPTL>zAN2f~(eED#O(aKxKH zyfzYwSjwTuZ2KPDws4ZYDJR(=ht8<7K@MGDPTBP#e{CjNFfViATz3J^YfC_DODC;? znOfh19L&cQvz(5hY*%+N67u`=X}CDDM(C-tbA50tp27zL(K4>JrfA&8b{C4d&R{Oz zYF;gZ`Ly-vCj=*GF`YCoC2*C*jp}Z!E1%Aq&mFPk;$kjW?7%tJ%u}cto-TDE4i7om z_R@6;u9W6RW9N65FFaA$h_ywqI|X=vDOzK(zJl3BfljlRSS3jAe|eK(9P{fv-1h4ufc)wa{xR z%(eVI$MW}V<8Sf6`Zb(hPJtQ8CBw(KK2D6m;ATvBtxFi?dR@l$T@{C|JGJ!`2hOP- zPAzcQHq>UF?ko*;NO)S}_*gVM7-|UAYqs@*+4$64lg=jd{Mx9;{mEjobhTz3T1wla z4(k;<9fSK`w_G6G-RYJy_o>#n{nG2AovQLj!_jnmN3kBB%kV0o?EYJ9atVJWt#I=E|kr{IgkBiK^m}W zz9QTTbn8nXVk!cO&INg!5{0=0=8w{*^m>{F(%01`Y_2xhso5*D)DwiI2rUYiW@8Pg zRKFfiXmB@{F2X3_ad>h~3%oCz?$qmO>Y|mMl7i2HZ9!N}D#Dxrvq33Q1IuVyGCSRR zkg!LC$yRL^th_m}7CQ`2EilDqkhF%Of&|RsS})vp=JM7$LNFkDwKhF&G2&V;-tAci zb*Y7v!t)^u{bZ4h8;}yH*BPy=u@Ghm&dd^KwmFhpj29MLJkXie$CcPb(~EU!t=*Yq z-YxG>r&4&a#XWbZ-q*Px4No9q+UeMoj;B7)ml|3M>-W?4FyClC-Fs3m++UQq+8nGS z6l@2)5tn!~)=3-Gwxsk?3u^<}0$8C2ZB}N6Hq(qi(MQqc#*Lh??$n2A)an&9Nly z)mf5`wc3I%BUm3b_HFB7`&RX^L)FIcvh(J^vnj@yvv1dk+bc3>BH>UP!_$tNcVotl zCf$4C#3f8Qw!H0*$wtsv;1i6EGDqY$VEO?11_qDxHz4|9`3A;36yJcEbD(XHth1mk zSvsHfi>-Uw;ZkDultaomdu_Fq&PH2?&PQ9^IQMK}b`Cja9U4WafDJeM*FiA{ul}Uz z_lIEt$+G4iP8V9WOeUGtVD({oZ8DR=mF@yPvW8*dFPFtHS;UOL$`9Xs6*PM6rSC;d z%6uk3tD!gGz5aR~5EYRqLDa;^9P)COMzSa9eg zvqK6n*%$}F5`&pTkAbM=aP`sR>i3@XB0#AUJI`Cf4yMIo^OkYbZ!D&sB210eoS34k zxHxN?BTt+L&A3oapcn4Ui%v_%Retki6gOeU#Z8!TVG~Z*MVE_f>11X-WSlW#-xyJ` zZAMgVnR(8!YUA04`eep2)!3bJPQb&KqYw_yc8u5i8XV*B$mJY|RW-+ixcB0Ii+jwD zfj^&ItPg5mD@-o%U~Rb%_KOJ| z(=ZmAFiS_z%nIEB7eyEpeXu>_T2}VT89|{68@0u@)>DcPT1zAN+Px*ghqWbP?+Dt4 aZQJ&Z+P7w}&A#8p&0*f2fDMR!