Initial vendor packages

Signed-off-by: Valentin Popov <valentin@popov.link>

1 files changed, 1268 insertions, 0 deletions

diff --git a/vendor/winapi/src/shared/d3d9.rs b/vendor/winapi/src/shared/d3d9.rs
new file mode 100644
index 0000000..437c811
--- /dev/null
+++ b/vendor/winapi/src/shared/d3d9.rs
@@ -0,0 +1,1268 @@
+// Licensed under the Apache License, Version 2.0
+// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
+// All files in the project carrying such notice may not be copied, modified, or distributed
+// except according to those terms.
+//! Direct3D include file
+use shared::basetsd::UINT32;
+use shared::d3d9caps::{D3DCAPS9, D3DCONTENTPROTECTIONCAPS, D3DOVERLAYCAPS};
+use shared::d3d9types::{
+    D3DADAPTER_IDENTIFIER9, D3DAUTHENTICATEDCHANNELTYPE, D3DAUTHENTICATEDCHANNEL_CONFIGURE_OUTPUT,
+    D3DBACKBUFFER_TYPE, D3DBOX, D3DCLIPSTATUS9, D3DCOLOR, D3DCOMPOSERECTSOP, D3DCUBEMAP_FACES,
+    D3DDEVICE_CREATION_PARAMETERS, D3DDEVTYPE, D3DDISPLAYMODE, D3DDISPLAYMODEEX,
+    D3DDISPLAYMODEFILTER, D3DDISPLAYROTATION, D3DENCRYPTED_BLOCK_INFO, D3DFORMAT, D3DGAMMARAMP,
+    D3DINDEXBUFFER_DESC, D3DLIGHT9, D3DLOCKED_BOX, D3DLOCKED_RECT, D3DMATERIAL9, D3DMATRIX,
+    D3DMULTISAMPLE_TYPE, D3DPOOL, D3DPRESENTSTATS, D3DPRESENT_PARAMETERS, D3DPRIMITIVETYPE,
+    D3DQUERYTYPE, D3DRASTER_STATUS, D3DRECT, D3DRECTPATCH_INFO, D3DRENDERSTATETYPE,
+    D3DRESOURCETYPE, D3DSAMPLERSTATETYPE, D3DSTATEBLOCKTYPE, D3DSURFACE_DESC, D3DTEXTUREFILTERTYPE,
+    D3DTEXTURESTAGESTATETYPE, D3DTRANSFORMSTATETYPE, D3DTRIPATCH_INFO, D3DVERTEXBUFFER_DESC,
+    D3DVERTEXELEMENT9, D3DVIEWPORT9, D3DVOLUME_DESC,
+};
+use shared::guiddef::{GUID, IID};
+use shared::minwindef::{BOOL, BYTE, DWORD, FLOAT, INT, UINT};
+use shared::windef::{HDC, HMONITOR, HWND, POINT, RECT};
+use um::unknwnbase::{IUnknown, IUnknownVtbl};
+use um::wingdi::{PALETTEENTRY, RGNDATA};
+use um::winnt::{HANDLE, HRESULT, LPCWSTR, LUID, VOID};
+pub const D3D_SDK_VERSION: DWORD = 32;
+pub const D3D9b_SDK_VERSION: DWORD = 31;
+DEFINE_GUID!{IID_IDirect3D9,
+    0x81bdcbca, 0x64d4, 0x426d, 0xae, 0x8d, 0xad, 0x01, 0x47, 0xf4, 0x27, 0x5c}
+DEFINE_GUID!{IID_IDirect3DDevice9,
+    0xd0223b96, 0xbf7a, 0x43fd, 0x92, 0xbd, 0xa4, 0x3b, 0x0d, 0x82, 0xb9, 0xeb}
+DEFINE_GUID!{IID_IDirect3DResource9,
+    0x05eec05d, 0x8f7d, 0x4362, 0xb9, 0x99, 0xd1, 0xba, 0xf3, 0x57, 0xc7, 0x04}
+DEFINE_GUID!{IID_IDirect3DBaseTexture9,
+    0x580ca87e, 0x1d3c, 0x4d54, 0x99, 0x1d, 0xb7, 0xd3, 0xe3, 0xc2, 0x98, 0xce}
+DEFINE_GUID!{IID_IDirect3DTexture9,
+    0x85c31227, 0x3de5, 0x4f00, 0x9b, 0x3a, 0xf1, 0x1a, 0xc3, 0x8c, 0x18, 0xb5}
+DEFINE_GUID!{IID_IDirect3DCubeTexture9,
+    0xfff32f81, 0xd953, 0x473a, 0x92, 0x23, 0x93, 0xd6, 0x52, 0xab, 0xa9, 0x3f}
+DEFINE_GUID!{IID_IDirect3DVolumeTexture9,
+    0x2518526c, 0xe789, 0x4111, 0xa7, 0xb9, 0x47, 0xef, 0x32, 0x8d, 0x13, 0xe6}
+DEFINE_GUID!{IID_IDirect3DVertexBuffer9,
+    0xb64bb1b5, 0xfd70, 0x4df6, 0xbf, 0x91, 0x19, 0xd0, 0xa1, 0x24, 0x55, 0xe3}
+DEFINE_GUID!{IID_IDirect3DIndexBuffer9,
+    0x7c9dd65e, 0xd3f7, 0x4529, 0xac, 0xee, 0x78, 0x58, 0x30, 0xac, 0xde, 0x35}
+DEFINE_GUID!{IID_IDirect3DSurface9,
+    0x0cfbaf3a, 0x9ff6, 0x429a, 0x99, 0xb3, 0xa2, 0x79, 0x6a, 0xf8, 0xb8, 0x9b}
+DEFINE_GUID!{IID_IDirect3DVolume9,
+    0x24f416e6, 0x1f67, 0x4aa7, 0xb8, 0x8e, 0xd3, 0x3f, 0x6f, 0x31, 0x28, 0xa1}
+DEFINE_GUID!{IID_IDirect3DSwapChain9,
+    0x794950f2, 0xadfc, 0x458a, 0x90, 0x5e, 0x10, 0xa1, 0x0b, 0x0b, 0x50, 0x3b}
+DEFINE_GUID!{IID_IDirect3DVertexDeclaration9,
+    0xdd13c59c, 0x36fa, 0x4098, 0xa8, 0xfb, 0xc7, 0xed, 0x39, 0xdc, 0x85, 0x46}
+DEFINE_GUID!{IID_IDirect3DVertexShader9,
+    0xefc5557e, 0x6265, 0x4613, 0x8a, 0x94, 0x43, 0x85, 0x78, 0x89, 0xeb, 0x36}
+DEFINE_GUID!{IID_IDirect3DPixelShader9,
+    0x6d3bdbdc, 0x5b02, 0x4415, 0xb8, 0x52, 0xce, 0x5e, 0x8b, 0xcc, 0xb2, 0x89}
+DEFINE_GUID!{IID_IDirect3DStateBlock9,
+    0xb07c4fe5, 0x310d, 0x4ba8, 0xa2, 0x3c, 0x4f, 0x0f, 0x20, 0x6f, 0x21, 0x8b}
+DEFINE_GUID!{IID_IDirect3DQuery9,
+    0xd9771460, 0xa695, 0x4f26, 0xbb, 0xd3, 0x27, 0xb8, 0x40, 0xb5, 0x41, 0xcc}
+DEFINE_GUID!{IID_HelperName,
+    0xe4a36723, 0xfdfe, 0x4b22, 0xb1, 0x46, 0x3c, 0x04, 0xc0, 0x7f, 0x4c, 0xc8}
+DEFINE_GUID!{IID_IDirect3D9Ex,
+    0x02177241, 0x69fc, 0x400c, 0x8f, 0xf1, 0x93, 0xa4, 0x4d, 0xf6, 0x86, 0x1d}
+DEFINE_GUID!{IID_IDirect3DDevice9Ex,
+    0xb18b10ce, 0x2649, 0x405a, 0x87, 0x0f, 0x95, 0xf7, 0x77, 0xd4, 0x31, 0x3a}
+DEFINE_GUID!{IID_IDirect3DSwapChain9Ex,
+    0x91886caf, 0x1c3d, 0x4d2e, 0xa0, 0xab, 0x3e, 0x4c, 0x7d, 0x8d, 0x33, 0x03}
+DEFINE_GUID!{IID_IDirect3D9ExOverlayExtension,
+    0x187aeb13, 0xaaf5, 0x4c59, 0x87, 0x6d, 0xe0, 0x59, 0x08, 0x8c, 0x0d, 0xf8}
+DEFINE_GUID!{IID_IDirect3DDevice9Video,
+    0x26dc4561, 0xa1ee, 0x4ae7, 0x96, 0xda, 0x11, 0x8a, 0x36, 0xc0, 0xec, 0x95}
+DEFINE_GUID!{IID_IDirect3DAuthenticatedChannel9,
+    0xff24beee, 0xda21, 0x4beb, 0x98, 0xb5, 0xd2, 0xf8, 0x99, 0xf9, 0x8a, 0xf9}
+DEFINE_GUID!{IID_IDirect3DCryptoSession9,
+    0xfa0ab799, 0x7a9c, 0x48ca, 0x8c, 0x5b, 0x23, 0x7e, 0x71, 0xa5, 0x44, 0x34}
+extern "system" {
+    pub fn Direct3DCreate9(
+        SDKVersion: UINT,
+    ) -> *mut IDirect3D9;
+    pub fn D3DPERF_BeginEvent(
+        col: D3DCOLOR,
+        wszName: LPCWSTR,
+    ) -> INT;
+    pub fn D3DPERF_EndEvent() -> INT;
+    pub fn D3DPERF_SetMarker(
+        col: D3DCOLOR,
+        wszName: LPCWSTR,
+    ) -> ();
+    pub fn D3DPERF_SetRegion(
+        col: D3DCOLOR,
+        wszName: LPCWSTR,
+    ) -> ();
+    pub fn D3DPERF_QueryRepeatFrame() -> BOOL;
+    pub fn D3DPERF_SetOptions(
+        dwOptions: DWORD,
+    ) -> ();
+    pub fn D3DPERF_GetStatus() -> DWORD;
+}
+RIDL!{#[uuid(0x81bdcbca, 0x64d4, 0x426d, 0xae, 0x8d, 0xad, 0x1, 0x47, 0xf4, 0x27, 0x5c)]
+interface IDirect3D9(IDirect3D9Vtbl): IUnknown(IUnknownVtbl) {
+    fn RegisterSoftwareDevice(
+        pInitializeFunction: *mut VOID,
+    ) -> HRESULT,
+    fn GetAdapterCount() -> UINT,
+    fn GetAdapterIdentifier(
+        Adapter: UINT,
+        Flags: DWORD,
+        pIdentifier: *mut D3DADAPTER_IDENTIFIER9,
+    ) -> HRESULT,
+    fn GetAdapterModeCount(
+        Adapter: UINT,
+        Format: D3DFORMAT,
+    ) -> UINT,
+    fn EnumAdapterModes(
+        Adapter: UINT,
+        Format: D3DFORMAT,
+        Mode: UINT,
+        pMode: *mut D3DDISPLAYMODE,
+    ) -> HRESULT,
+    fn GetAdapterDisplayMode(
+        Adapter: UINT,
+        pMode: *mut D3DDISPLAYMODE,
+    ) -> HRESULT,
+    fn CheckDeviceType(
+        Adapter: UINT,
+        DevType: D3DDEVTYPE,
+        AdapterFormat: D3DFORMAT,
+        BackBufferFormat: D3DFORMAT,
+        bWindowed: BOOL,
+    ) -> HRESULT,
+    fn CheckDeviceFormat(
+        Adapter: UINT,
+        DeviceType: D3DDEVTYPE,
+        AdapterFormat: D3DFORMAT,
+        Usage: DWORD,
+        RType: D3DRESOURCETYPE,
+        CheckFormat: D3DFORMAT,
+    ) -> HRESULT,
+    fn CheckDeviceMultiSampleType(
+        Adapter: UINT,
+        DeviceType: D3DDEVTYPE,
+        SurfaceFormat: D3DFORMAT,
+        Windowed: BOOL,
+        MultiSampleType: D3DMULTISAMPLE_TYPE,
+        pQualityLevels: *mut DWORD,
+    ) -> HRESULT,
+    fn CheckDepthStencilMatch(
+        Adapter: UINT,
+        DeviceType: D3DDEVTYPE,
+        AdapterFormat: D3DFORMAT,
+        RenderTargetFormat: D3DFORMAT,
+        DepthStencilFormat: D3DFORMAT,
+    ) -> HRESULT,
+    fn CheckDeviceFormatConversion(
+        Adapter: UINT,
+        DeviceType: D3DDEVTYPE,
+        SourceFormat: D3DFORMAT,
+        TargetFormat: D3DFORMAT,
+    ) -> HRESULT,
+    fn GetDeviceCaps(
+        Adapter: UINT,
+        DeviceType: D3DDEVTYPE,
+        pCaps: *mut D3DCAPS9,
+    ) -> HRESULT,
+    fn GetAdapterMonitor(
+        Adapter: UINT,
+    ) -> HMONITOR,
+    fn CreateDevice(
+        Adapter: UINT,
+        DeviceType: D3DDEVTYPE,
+        hFocusWindow: HWND,
+        BehaviorFlags: DWORD,
+        pPresentationParameters: *mut D3DPRESENT_PARAMETERS,
+        ppReturnedDeviceInterface: *mut *mut IDirect3DDevice9,
+    ) -> HRESULT,
+}}
+pub type LPDIRECT3D9 = *mut IDirect3D9;
+pub type PDIRECT3D9 = *mut IDirect3D9;
+RIDL!{#[uuid(0xd0223b96, 0xbf7a, 0x43fd, 0x92, 0xbd, 0xa4, 0x3b, 0xd, 0x82, 0xb9, 0xeb)]
+interface IDirect3DDevice9(IDirect3DDevice9Vtbl): IUnknown(IUnknownVtbl) {
+    fn TestCooperativeLevel() -> HRESULT,
+    fn GetAvailableTextureMem() -> UINT,
+    fn EvictManagedResources() -> HRESULT,
+    fn GetDirect3D(
+        ppD3D9: *mut *mut IDirect3D9,
+    ) -> HRESULT,
+    fn GetDeviceCaps(
+        pCaps: *mut D3DCAPS9,
+    ) -> HRESULT,
+    fn GetDisplayMode(
+        iSwapChain: UINT,
+        pMode: *mut D3DDISPLAYMODE,
+    ) -> HRESULT,
+    fn GetCreationParameters(
+        pParameters: *mut D3DDEVICE_CREATION_PARAMETERS,
+    ) -> HRESULT,
+    fn SetCursorProperties(
+        XHotSpot: UINT,
+        YHotSpot: UINT,
+        pCursorBitmap: *mut IDirect3DSurface9,
+    ) -> HRESULT,
+    fn SetCursorPosition(
+        X: INT,
+        Y: INT,
+        Flags: DWORD,
+    ) -> (),
+    fn ShowCursor(
+        bShow: BOOL,
+    ) -> BOOL,
+    fn CreateAdditionalSwapChain(
+        pPresentationParameters: *mut D3DPRESENT_PARAMETERS,
+        pSwapChain: *mut *mut IDirect3DSwapChain9,
+    ) -> HRESULT,
+    fn GetSwapChain(
+        iSwapChain: UINT,
+        pSwapChain: *mut *mut IDirect3DSwapChain9,
+    ) -> HRESULT,
+    fn GetNumberOfSwapChains() -> UINT,
+    fn Reset(
+        pPresentationParameters: *mut D3DPRESENT_PARAMETERS,
+    ) -> HRESULT,
+    fn Present(
+        pSourceRect: *const RECT,
+        pDestRect: *const RECT,
+        hDestWindowOverride: HWND,
+        pDirtyRegion: *const RGNDATA,
+    ) -> HRESULT,
+    fn GetBackBuffer(
+        iSwapChain: UINT,
+        iBackBuffer: UINT,
+        Type: D3DBACKBUFFER_TYPE,
+        ppBackBuffer: *mut *mut IDirect3DSurface9,
+    ) -> HRESULT,
+    fn GetRasterStatus(
+        iSwapChain: UINT,
+        pRasterStatus: *mut D3DRASTER_STATUS,
+    ) -> HRESULT,
+    fn SetDialogBoxMode(
+        bEnableDialogs: BOOL,
+    ) -> HRESULT,
+    fn SetGammaRamp(
+        iSwapChain: UINT,
+        Flags: DWORD,
+        pRamp: *const D3DGAMMARAMP,
+    ) -> (),
+    fn GetGammaRamp(
+        iSwapChain: UINT,
+        pRamp: *mut D3DGAMMARAMP,
+    ) -> (),
+    fn CreateTexture(
+        Width: UINT,
+        Height: UINT,
+        Levels: UINT,
+        Usage: DWORD,
+        Format: D3DFORMAT,
+        Pool: D3DPOOL,
+        ppTexture: *mut *mut IDirect3DTexture9,
+        pSharedHandle: *mut HANDLE,
+    ) -> HRESULT,
+    fn CreateVolumeTexture(
+        Width: UINT,
+        Height: UINT,
+        Depth: UINT,
+        Levels: UINT,
+        Usage: DWORD,
+        Format: D3DFORMAT,
+        Pool: D3DPOOL,
+        ppVolumeTexture: *mut *mut IDirect3DVolumeTexture9,
+        pSharedHandle: *mut HANDLE,
+    ) -> HRESULT,
+    fn CreateCubeTexture(
+        EdgeLength: UINT,
+        Levels: UINT,
+        Usage: DWORD,
+        Format: D3DFORMAT,
+        Pool: D3DPOOL,
+        ppCubeTexture: *mut *mut IDirect3DCubeTexture9,
+        pSharedHandle: *mut HANDLE,
+    ) -> HRESULT,
+    fn CreateVertexBuffer(
+        Length: UINT,
+        Usage: DWORD,
+        FVF: DWORD,
+        Pool: D3DPOOL,
+        ppVertexBuffer: *mut *mut IDirect3DVertexBuffer9,
+        pSharedHandle: *mut HANDLE,
+    ) -> HRESULT,
+    fn CreateIndexBuffer(
+        Length: UINT,
+        Usage: DWORD,
+        Format: D3DFORMAT,
+        Pool: D3DPOOL,
+        ppIndexBuffer: *mut *mut IDirect3DIndexBuffer9,
+        pSharedHandle: *mut HANDLE,
+    ) -> HRESULT,
+    fn CreateRenderTarget(
+        Width: UINT,
+        Height: UINT,
+        Format: D3DFORMAT,
+        MultiSample: D3DMULTISAMPLE_TYPE,
+        MultisampleQuality: DWORD,
+        Lockable: BOOL,
+        ppSurface: *mut *mut IDirect3DSurface9,
+        pSharedHandle: *mut HANDLE,
+    ) -> HRESULT,
+    fn CreateDepthStencilSurface(
+        Width: UINT,
+        Height: UINT,
+        Format: D3DFORMAT,
+        MultiSample: D3DMULTISAMPLE_TYPE,
+        MultisampleQuality: DWORD,
+        Discard: BOOL,
+        ppSurface: *mut *mut IDirect3DSurface9,
+        pSharedHandle: *mut HANDLE,
+    ) -> HRESULT,
+    fn UpdateSurface(
+        pSourceSurface: *mut IDirect3DSurface9,
+        pSourceRect: *const RECT,
+        pDestinationSurface: *mut IDirect3DSurface9,
+        pDestPoint: *const POINT,
+    ) -> HRESULT,
+    fn UpdateTexture(
+        pSourceTexture: *mut IDirect3DBaseTexture9,
+        pDestinationTexture: *mut IDirect3DBaseTexture9,
+    ) -> HRESULT,
+    fn GetRenderTargetData(
+        pRenderTarget: *mut IDirect3DSurface9,
+        pDestSurface: *mut IDirect3DSurface9,
+    ) -> HRESULT,
+    fn GetFrontBufferData(
+        iSwapChain: UINT,
+        pDestSurface: *mut IDirect3DSurface9,
+    ) -> HRESULT,
+    fn StretchRect(
+        pSourceSurface: *mut IDirect3DSurface9,
+        pSourceRect: *const RECT,
+        pDestSurface: *mut IDirect3DSurface9,
+        pDestRect: *const RECT,
+        Filter: D3DTEXTUREFILTERTYPE,
+    ) -> HRESULT,
+    fn ColorFill(
+        pSurface: *mut IDirect3DSurface9,
+        pRect: *const RECT,
+        color: D3DCOLOR,
+    ) -> HRESULT,
+    fn CreateOffscreenPlainSurface(
+        Width: UINT,
+        Height: UINT,
+        Format: D3DFORMAT,
+        Pool: D3DPOOL,
+        ppSurface: *mut *mut IDirect3DSurface9,
+        pSharedHandle: *mut HANDLE,
+    ) -> HRESULT,
+    fn SetRenderTarget(
+        RenderTargetIndex: DWORD,
+        pRenderTarget: *mut IDirect3DSurface9,
+    ) -> HRESULT,
+    fn GetRenderTarget(
+        RenderTargetIndex: DWORD,
+        ppRenderTarget: *mut *mut IDirect3DSurface9,
+    ) -> HRESULT,
+    fn SetDepthStencilSurface(
+        pNewZStencil: *mut IDirect3DSurface9,
+    ) -> HRESULT,
+    fn GetDepthStencilSurface(
+        ppZStencilSurface: *mut *mut IDirect3DSurface9,
+    ) -> HRESULT,
+    fn BeginScene() -> HRESULT,
+    fn EndScene() -> HRESULT,
+    fn Clear(
+        Count: DWORD,
+        pRects: *const D3DRECT,
+        Flags: DWORD,
+        Color: D3DCOLOR,
+        Z: FLOAT,
+        Stencil: DWORD,
+    ) -> HRESULT,
+    fn SetTransform(
+        State: D3DTRANSFORMSTATETYPE,
+        pMatrix: *const D3DMATRIX,
+    ) -> HRESULT,
+    fn GetTransform(
+        State: D3DTRANSFORMSTATETYPE,
+        pMatrix: *mut D3DMATRIX,
+    ) -> HRESULT,
+    fn MultiplyTransform(
+        arg1: D3DTRANSFORMSTATETYPE,
+        arg2: *const D3DMATRIX,
+    ) -> HRESULT,
+    fn SetViewport(
+        pViewport: *const D3DVIEWPORT9,
+    ) -> HRESULT,
+    fn GetViewport(
+        pViewport: *mut D3DVIEWPORT9,
+    ) -> HRESULT,
+    fn SetMaterial(
+        pMaterial: *const D3DMATERIAL9,
+    ) -> HRESULT,
+    fn GetMaterial(
+        pMaterial: *mut D3DMATERIAL9,
+    ) -> HRESULT,
+    fn SetLight(
+        Index: DWORD,
+        arg1: *const D3DLIGHT9,
+    ) -> HRESULT,
+    fn GetLight(
+        Index: DWORD,
+        arg1: *mut D3DLIGHT9,
+    ) -> HRESULT,
+    fn LightEnable(
+        Index: DWORD,
+        Enable: BOOL,
+    ) -> HRESULT,
+    fn GetLightEnable(
+        Index: DWORD,
+        pEnable: *mut BOOL,
+    ) -> HRESULT,
+    fn SetClipPlane(
+        Index: DWORD,
+        pPlane: *const FLOAT,
+    ) -> HRESULT,
+    fn GetClipPlane(
+        Index: DWORD,
+        pPlane: *mut FLOAT,
+    ) -> HRESULT,
+    fn SetRenderState(
+        State: D3DRENDERSTATETYPE,
+        Value: DWORD,
+    ) -> HRESULT,
+    fn GetRenderState(
+        State: D3DRENDERSTATETYPE,
+        pValue: *mut DWORD,
+    ) -> HRESULT,
+    fn CreateStateBlock(
+        Type: D3DSTATEBLOCKTYPE,
+        ppSB: *mut *mut IDirect3DStateBlock9,
+    ) -> HRESULT,
+    fn BeginStateBlock() -> HRESULT,
+    fn EndStateBlock(
+        ppSB: *mut *mut IDirect3DStateBlock9,
+    ) -> HRESULT,
+    fn SetClipStatus(
+        pClipStatus: *const D3DCLIPSTATUS9,
+    ) -> HRESULT,
+    fn GetClipStatus(
+        pClipStatus: *mut D3DCLIPSTATUS9,
+    ) -> HRESULT,
+    fn GetTexture(
+        Stage: DWORD,
+        ppTexture: *mut *mut IDirect3DBaseTexture9,
+    ) -> HRESULT,
+    fn SetTexture(
+        Stage: DWORD,
+        pTexture: *mut IDirect3DBaseTexture9,
+    ) -> HRESULT,
+    fn GetTextureStageState(
+        Stage: DWORD,
+        Type: D3DTEXTURESTAGESTATETYPE,
+        pValue: *mut DWORD,
+    ) -> HRESULT,
+    fn SetTextureStageState(
+        Stage: DWORD,
+        Type: D3DTEXTURESTAGESTATETYPE,
+        Value: DWORD,
+    ) -> HRESULT,
+    fn GetSamplerState(
+        Sampler: DWORD,
+        Type: D3DSAMPLERSTATETYPE,
+        pValue: *mut DWORD,
+    ) -> HRESULT,
+    fn SetSamplerState(
+        Sampler: DWORD,
+        Type: D3DSAMPLERSTATETYPE,
+        Value: DWORD,
+    ) -> HRESULT,
+    fn ValidateDevice(
+        pNumPasses: *mut DWORD,
+    ) -> HRESULT,
+    fn SetPaletteEntries(
+        PaletteNumber: UINT,
+        pEntries: *const PALETTEENTRY,
+    ) -> HRESULT,
+    fn GetPaletteEntries(
+        PaletteNumber: UINT,
+        pEntries: *mut PALETTEENTRY,
+    ) -> HRESULT,
+    fn SetCurrentTexturePalette(
+        PaletteNumber: UINT,
+    ) -> HRESULT,
+    fn GetCurrentTexturePalette(
+        PaletteNumber: *mut UINT,
+    ) -> HRESULT,
+    fn SetScissorRect(
+        pRect: *const RECT,
+    ) -> HRESULT,
+    fn GetScissorRect(
+        pRect: *mut RECT,
+    ) -> HRESULT,
+    fn SetSoftwareVertexProcessing(
+        bSoftware: BOOL,
+    ) -> HRESULT,
+    fn GetSoftwareVertexProcessing() -> BOOL,
+    fn SetNPatchMode(
+        nSegments: FLOAT,
+    ) -> HRESULT,
+    fn GetNPatchMode() -> FLOAT,
+    fn DrawPrimitive(
+        PrimitiveType: D3DPRIMITIVETYPE,
+        StartVertex: UINT,
+        PrimitiveCount: UINT,
+    ) -> HRESULT,
+    fn DrawIndexedPrimitive(
+        arg1: D3DPRIMITIVETYPE,
+        BaseVertexIndex: INT,
+        MinVertexIndex: UINT,
+        NumVertices: UINT,
+        startIndex: UINT,
+        primCount: UINT,
+    ) -> HRESULT,
+    fn DrawPrimitiveUP(
+        PrimitiveType: D3DPRIMITIVETYPE,
+        PrimitiveCount: UINT,
+        pVertexStreamZeroData: *const VOID,
+        VertexStreamZeroStride: UINT,
+    ) -> HRESULT,
+    fn DrawIndexedPrimitiveUP(
+        PrimitiveType: D3DPRIMITIVETYPE,
+        MinVertexIndex: UINT,
+        NumVertices: UINT,
+        PrimitiveCount: UINT,
+        pIndexData: *const VOID,
+        IndexDataFormat: D3DFORMAT,
+        pVertexStreamZeroData: *const VOID,
+        VertexStreamZeroStride: UINT,
+    ) -> HRESULT,
+    fn ProcessVertices(
+        SrcStartIndex: UINT,
+        DestIndex: UINT,
+        VertexCount: UINT,
+        pDestBuffer: *mut IDirect3DVertexBuffer9,
+        pVertexDecl: *mut IDirect3DVertexDeclaration9,
+        Flags: DWORD,
+    ) -> HRESULT,
+    fn CreateVertexDeclaration(
+        pVertexElements: *const D3DVERTEXELEMENT9,
+        ppDecl: *mut *mut IDirect3DVertexDeclaration9,
+    ) -> HRESULT,
+    fn SetVertexDeclaration(
+        pDecl: *mut IDirect3DVertexDeclaration9,
+    ) -> HRESULT,
+    fn GetVertexDeclaration(
+        ppDecl: *mut *mut IDirect3DVertexDeclaration9,
+    ) -> HRESULT,
+    fn SetFVF(
+        FVF: DWORD,
+    ) -> HRESULT,
+    fn GetFVF(
+        pFVF: *mut DWORD,
+    ) -> HRESULT,
+    fn CreateVertexShader(
+        pFunction: *const DWORD,
+        ppShader: *mut *mut IDirect3DVertexShader9,
+    ) -> HRESULT,
+    fn SetVertexShader(
+        pShader: *mut IDirect3DVertexShader9,
+    ) -> HRESULT,
+    fn GetVertexShader(
+        ppShader: *mut *mut IDirect3DVertexShader9,
+    ) -> HRESULT,
+    fn SetVertexShaderConstantF(
+        StartRegister: UINT,
+        pConstantData: *const FLOAT,
+        Vector4fCount: UINT,
+    ) -> HRESULT,
+    fn GetVertexShaderConstantF(
+        StartRegister: UINT,
+        pConstantData: *mut FLOAT,
+        Vector4fCount: UINT,
+    ) -> HRESULT,
+    fn SetVertexShaderConstantI(
+        StartRegister: UINT,
+        pConstantData: *const INT,
+        Vector4iCount: UINT,
+    ) -> HRESULT,
+    fn GetVertexShaderConstantI(
+        StartRegister: UINT,
+        pConstantData: *mut INT,
+        Vector4iCount: UINT,
+    ) -> HRESULT,
+    fn SetVertexShaderConstantB(
+        StartRegister: UINT,
+        pConstantData: *const BOOL,
+        BoolCount: UINT,
+    ) -> HRESULT,
+    fn GetVertexShaderConstantB(
+        StartRegister: UINT,
+        pConstantData: *mut BOOL,
+        BoolCount: UINT,
+    ) -> HRESULT,
+    fn SetStreamSource(
+        StreamNumber: UINT,
+        pStreamData: *mut IDirect3DVertexBuffer9,
+        OffsetInBytes: UINT,
+        Stride: UINT,
+    ) -> HRESULT,
+    fn GetStreamSource(
+        StreamNumber: UINT,
+        ppStreamData: *mut *mut IDirect3DVertexBuffer9,
+        pOffsetInBytes: *mut UINT,
+        pStride: *mut UINT,
+    ) -> HRESULT,
+    fn SetStreamSourceFreq(
+        StreamNumber: UINT,
+        Setting: UINT,
+    ) -> HRESULT,
+    fn GetStreamSourceFreq(
+        StreamNumber: UINT,
+        pSetting: *mut UINT,
+    ) -> HRESULT,
+    fn SetIndices(
+        pIndexData: *mut IDirect3DIndexBuffer9,
+    ) -> HRESULT,
+    fn GetIndices(
+        ppIndexData: *mut *mut IDirect3DIndexBuffer9,
+    ) -> HRESULT,
+    fn CreatePixelShader(
+        pFunction: *const DWORD,
+        ppShader: *mut *mut IDirect3DPixelShader9,
+    ) -> HRESULT,
+    fn SetPixelShader(
+        pShader: *mut IDirect3DPixelShader9,
+    ) -> HRESULT,
+    fn GetPixelShader(
+        ppShader: *mut *mut IDirect3DPixelShader9,
+    ) -> HRESULT,
+    fn SetPixelShaderConstantF(
+        StartRegister: UINT,
+        pConstantData: *const FLOAT,
+        Vector4fCount: UINT,
+    ) -> HRESULT,
+    fn GetPixelShaderConstantF(
+        StartRegister: UINT,
+        pConstantData: *mut FLOAT,
+        Vector4fCount: UINT,
+    ) -> HRESULT,
+    fn SetPixelShaderConstantI(
+        StartRegister: UINT,
+        pConstantData: *const INT,
+        Vector4iCount: UINT,
+    ) -> HRESULT,
+    fn GetPixelShaderConstantI(
+        StartRegister: UINT,
+        pConstantData: *mut INT,
+        Vector4iCount: UINT,
+    ) -> HRESULT,
+    fn SetPixelShaderConstantB(
+        StartRegister: UINT,
+        pConstantData: *const BOOL,
+        BoolCount: UINT,
+    ) -> HRESULT,
+    fn GetPixelShaderConstantB(
+        StartRegister: UINT,
+        pConstantData: *mut BOOL,
+        BoolCount: UINT,
+    ) -> HRESULT,
+    fn DrawRectPatch(
+        Handle: UINT,
+        pNumSegs: *const FLOAT,
+        pRectPatchInfo: *const D3DRECTPATCH_INFO,
+    ) -> HRESULT,
+    fn DrawTriPatch(
+        Handle: UINT,
+        pNumSegs: *const FLOAT,
+        pTriPatchInfo: *const D3DTRIPATCH_INFO,
+    ) -> HRESULT,
+    fn DeletePatch(
+        Handle: UINT,
+    ) -> HRESULT,
+    fn CreateQuery(
+        Type: D3DQUERYTYPE,
+        ppQuery: *mut *mut IDirect3DQuery9,
+    ) -> HRESULT,
+}}
+pub type LPDIRECT3DDEVICE9 = *mut IDirect3DDevice9;
+pub type PDIRECT3DDEVICE9 = *mut IDirect3DDevice9;
+RIDL!{#[uuid(0xb07c4fe5, 0x310d, 0x4ba8, 0xa2, 0x3c, 0x4f, 0xf, 0x20, 0x6f, 0x21, 0x8b)]
+interface IDirect3DStateBlock9(IDirect3DStateBlock9Vtbl): IUnknown(IUnknownVtbl) {
+    fn GetDevice(
+        ppDevice: *mut *mut IDirect3DDevice9,
+    ) -> HRESULT,
+    fn Capture() -> HRESULT,
+    fn Apply() -> HRESULT,
+}}
+pub type LPDIRECT3DSTATEBLOCK9 = *mut IDirect3DStateBlock9;
+pub type PDIRECT3DSTATEBLOCK9 = *mut IDirect3DStateBlock9;
+RIDL!{#[uuid(0x794950f2, 0xadfc, 0x458a, 0x90, 0x5e, 0x10, 0xa1, 0xb, 0xb, 0x50, 0x3b)]
+interface IDirect3DSwapChain9(IDirect3DSwapChain9Vtbl): IUnknown(IUnknownVtbl) {
+    fn Present(
+        pSourceRect: *const RECT,
+        pDestRect: *const RECT,
+        hDestWindowOverride: HWND,
+        pDirtyRegion: *const RGNDATA,
+        dwFlags: DWORD,
+    ) -> HRESULT,
+    fn GetFrontBufferData(
+        pDestSurface: *mut IDirect3DSurface9,
+    ) -> HRESULT,
+    fn GetBackBuffer(
+        iBackBuffer: UINT,
+        Type: D3DBACKBUFFER_TYPE,
+        ppBackBuffer: *mut *mut IDirect3DSurface9,
+    ) -> HRESULT,
+    fn GetRasterStatus(
+        pRasterStatus: *mut D3DRASTER_STATUS,
+    ) -> HRESULT,
+    fn GetDisplayMode(
+        pMode: *mut D3DDISPLAYMODE,
+    ) -> HRESULT,
+    fn GetDevice(
+        ppDevice: *mut *mut IDirect3DDevice9,
+    ) -> HRESULT,
+    fn GetPresentParameters(
+        pPresentationParameters: *mut D3DPRESENT_PARAMETERS,
+    ) -> HRESULT,
+}}
+pub type LPDIRECT3DSWAPCHAIN9 = *mut IDirect3DSwapChain9;
+pub type PDIRECT3DSWAPCHAIN9 = *mut IDirect3DSwapChain9;
+RIDL!{#[uuid(0x5eec05d, 0x8f7d, 0x4362, 0xb9, 0x99, 0xd1, 0xba, 0xf3, 0x57, 0xc7, 0x4)]
+interface IDirect3DResource9(IDirect3DResource9Vtbl): IUnknown(IUnknownVtbl) {
+    fn GetDevice(
+        ppDevice: *mut *mut IDirect3DDevice9,
+    ) -> HRESULT,
+    fn SetPrivateData(
+        refguid: *const GUID,
+        pData: *const VOID,
+        SizeOfData: DWORD,
+        Flags: DWORD,
+    ) -> HRESULT,
+    fn GetPrivateData(
+        refguid: *const GUID,
+        pData: *mut VOID,
+        pSizeOfData: *mut DWORD,
+    ) -> HRESULT,
+    fn FreePrivateData(
+        refguid: *const GUID,
+    ) -> HRESULT,
+    fn SetPriority(
+        PriorityNew: DWORD,
+    ) -> DWORD,
+    fn GetPriority() -> DWORD,
+    fn PreLoad() -> (),
+    fn GetType() -> D3DRESOURCETYPE,
+}}
+pub type LPDIRECT3DRESOURCE9 = *mut IDirect3DResource9;
+pub type PDIRECT3DRESOURCE9 = *mut IDirect3DResource9;
+RIDL!{#[uuid(0xdd13c59c, 0x36fa, 0x4098, 0xa8, 0xfb, 0xc7, 0xed, 0x39, 0xdc, 0x85, 0x46)]
+interface IDirect3DVertexDeclaration9(IDirect3DVertexDeclaration9Vtbl): IUnknown(IUnknownVtbl) {
+    fn GetDevice(
+        ppDevice: *mut *mut IDirect3DDevice9,
+    ) -> HRESULT,
+    fn GetDeclaration(
+        pElement: *mut D3DVERTEXELEMENT9,
+        pNumElements: *mut UINT,
+    ) -> HRESULT,
+}}
+pub type LPDIRECT3DVERTEXDECLARATION9 = *mut IDirect3DVertexDeclaration9;
+pub type PDIRECT3DVERTEXDECLARATION9 = *mut IDirect3DVertexDeclaration9;
+RIDL!{#[uuid(0xefc5557e, 0x6265, 0x4613, 0x8a, 0x94, 0x43, 0x85, 0x78, 0x89, 0xeb, 0x36)]
+interface IDirect3DVertexShader9(IDirect3DVertexShader9Vtbl): IUnknown(IUnknownVtbl) {
+    fn GetDevice(
+        ppDevice: *mut *mut IDirect3DDevice9,
+    ) -> HRESULT,
+    fn GetFunction(
+        arg1: *mut VOID,
+        pSizeOfData: *mut UINT,
+    ) -> HRESULT,
+}}
+pub type LPDIRECT3DVERTEXSHADER9 = *mut IDirect3DVertexShader9;
+pub type PDIRECT3DVERTEXSHADER9 = *mut IDirect3DVertexShader9;
+RIDL!{#[uuid(0x6d3bdbdc, 0x5b02, 0x4415, 0xb8, 0x52, 0xce, 0x5e, 0x8b, 0xcc, 0xb2, 0x89)]
+interface IDirect3DPixelShader9(IDirect3DPixelShader9Vtbl): IUnknown(IUnknownVtbl) {
+    fn GetDevice(
+        ppDevice: *mut *mut IDirect3DDevice9,
+    ) -> HRESULT,
+    fn GetFunction(
+        arg1: *mut VOID,
+        pSizeOfData: *mut UINT,
+    ) -> HRESULT,
+}}
+pub type LPDIRECT3DPIXELSHADER9 = *mut IDirect3DPixelShader9;
+pub type PDIRECT3DPIXELSHADER9 = *mut IDirect3DPixelShader9;
+RIDL!{#[uuid(0x580ca87e, 0x1d3c, 0x4d54, 0x99, 0x1d, 0xb7, 0xd3, 0xe3, 0xc2, 0x98, 0xce)]
+interface IDirect3DBaseTexture9(IDirect3DBaseTexture9Vtbl):
+    IDirect3DResource9(IDirect3DResource9Vtbl) {
+    fn SetLOD(
+        LODNew: DWORD,
+    ) -> DWORD,
+    fn GetLOD() -> DWORD,
+    fn GetLevelCount() -> DWORD,
+    fn SetAutoGenFilterType(
+        FilterType: D3DTEXTUREFILTERTYPE,
+    ) -> HRESULT,
+    fn GetAutoGenFilterType() -> D3DTEXTUREFILTERTYPE,
+    fn GenerateMipSubLevels() -> (),
+}}
+pub type LPDIRECT3DBASETEXTURE9 = *mut IDirect3DBaseTexture9;
+pub type PDIRECT3DBASETEXTURE9 = *mut IDirect3DBaseTexture9;
+RIDL!{#[uuid(0x85c31227, 0x3de5, 0x4f00, 0x9b, 0x3a, 0xf1, 0x1a, 0xc3, 0x8c, 0x18, 0xb5)]
+interface IDirect3DTexture9(IDirect3DTexture9Vtbl):
+    IDirect3DBaseTexture9(IDirect3DBaseTexture9Vtbl) {
+    fn GetLevelDesc(
+        Level: UINT,
+        pDesc: *mut D3DSURFACE_DESC,
+    ) -> HRESULT,
+    fn GetSurfaceLevel(
+        Level: UINT,
+        ppSurfaceLevel: *mut *mut IDirect3DSurface9,
+    ) -> HRESULT,
+    fn LockRect(
+        Level: UINT,
+        pLockedRect: *mut D3DLOCKED_RECT,
+        pRect: *const RECT,
+        Flags: DWORD,
+    ) -> HRESULT,
+    fn UnlockRect(
+        Level: UINT,
+    ) -> HRESULT,
+    fn AddDirtyRect(
+        pDirtyRect: *const RECT,
+    ) -> HRESULT,
+}}
+pub type LPDIRECT3DTEXTURE9 = *mut IDirect3DTexture9;
+pub type PDIRECT3DTEXTURE9 = *mut IDirect3DTexture9;
+RIDL!{#[uuid(0x2518526c, 0xe789, 0x4111, 0xa7, 0xb9, 0x47, 0xef, 0x32, 0x8d, 0x13, 0xe6)]
+interface IDirect3DVolumeTexture9(IDirect3DVolumeTexture9Vtbl):
+    IDirect3DBaseTexture9(IDirect3DBaseTexture9Vtbl) {
+    fn GetLevelDesc(
+        Level: UINT,
+        pDesc: *mut D3DVOLUME_DESC,
+    ) -> HRESULT,
+    fn GetVolumeLevel(
+        Level: UINT,
+        ppVolumeLevel: *mut *mut IDirect3DVolume9,
+    ) -> HRESULT,
+    fn LockBox(
+        Level: UINT,
+        pLockedVolume: *mut D3DLOCKED_BOX,
+        pBox: *const D3DBOX,
+        Flags: DWORD,
+    ) -> HRESULT,
+    fn UnlockBox(
+        Level: UINT,
+    ) -> HRESULT,
+    fn AddDirtyBox(
+        pDirtyBox: *const D3DBOX,
+    ) -> HRESULT,
+}}
+pub type LPDIRECT3DVOLUMETEXTURE9 = *mut IDirect3DVolumeTexture9;
+pub type PDIRECT3DVOLUMETEXTURE9 = *mut IDirect3DVolumeTexture9;
+RIDL!{#[uuid(0xfff32f81, 0xd953, 0x473a, 0x92, 0x23, 0x93, 0xd6, 0x52, 0xab, 0xa9, 0x3f)]
+interface IDirect3DCubeTexture9(IDirect3DCubeTexture9Vtbl):
+    IDirect3DBaseTexture9(IDirect3DBaseTexture9Vtbl) {
+    fn GetLevelDesc(
+        Level: UINT,
+        pDesc: *mut D3DSURFACE_DESC,
+    ) -> HRESULT,
+    fn GetCubeMapSurface(
+        FaceType: D3DCUBEMAP_FACES,
+        Level: UINT,
+        ppCubeMapSurface: *mut *mut IDirect3DSurface9,
+    ) -> HRESULT,
+    fn LockRect(
+        FaceType: D3DCUBEMAP_FACES,
+        Level: UINT,
+        pLockedRect: *mut D3DLOCKED_RECT,
+        pRect: *const RECT,
+        Flags: DWORD,
+    ) -> HRESULT,
+    fn UnlockRect(
+        FaceType: D3DCUBEMAP_FACES,
+        Level: UINT,
+    ) -> HRESULT,
+    fn AddDirtyRect(
+        FaceType: D3DCUBEMAP_FACES,
+        pDirtyRect: *const RECT,
+    ) -> HRESULT,
+}}
+pub type LPDIRECT3DCUBETEXTURE9 = *mut IDirect3DCubeTexture9;
+pub type PDIRECT3DCUBETEXTURE9 = *mut IDirect3DCubeTexture9;
+RIDL!{#[uuid(0xb64bb1b5, 0xfd70, 0x4df6, 0xbf, 0x91, 0x19, 0xd0, 0xa1, 0x24, 0x55, 0xe3)]
+interface IDirect3DVertexBuffer9(IDirect3DVertexBuffer9Vtbl):
+    IDirect3DResource9(IDirect3DResource9Vtbl) {
+    fn Lock(
+        OffsetToLock: UINT,
+        SizeToLock: UINT,
+        ppbData: *mut *mut VOID,
+        Flags: DWORD,
+    ) -> HRESULT,
+    fn Unlock() -> HRESULT,
+    fn GetDesc(
+        pDesc: *mut D3DVERTEXBUFFER_DESC,
+    ) -> HRESULT,
+}}
+pub type LPDIRECT3DVERTEXBUFFER9 = *mut IDirect3DVertexBuffer9;
+pub type PDIRECT3DVERTEXBUFFER9 = *mut IDirect3DVertexBuffer9;
+RIDL!{#[uuid(0x7c9dd65e, 0xd3f7, 0x4529, 0xac, 0xee, 0x78, 0x58, 0x30, 0xac, 0xde, 0x35)]
+interface IDirect3DIndexBuffer9(IDirect3DIndexBuffer9Vtbl):
+    IDirect3DResource9(IDirect3DResource9Vtbl) {
+    fn Lock(
+        OffsetToLock: UINT,
+        SizeToLock: UINT,
+        ppbData: *mut *mut VOID,
+        Flags: DWORD,
+    ) -> HRESULT,
+    fn Unlock() -> HRESULT,
+    fn GetDesc(
+        pDesc: *mut D3DINDEXBUFFER_DESC,
+    ) -> HRESULT,
+}}
+pub type LPDIRECT3DINDEXBUFFER9 = *mut IDirect3DIndexBuffer9;
+pub type PDIRECT3DINDEXBUFFER9 = *mut IDirect3DIndexBuffer9;
+RIDL!{#[uuid(0xcfbaf3a, 0x9ff6, 0x429a, 0x99, 0xb3, 0xa2, 0x79, 0x6a, 0xf8, 0xb8, 0x9b)]
+interface IDirect3DSurface9(IDirect3DSurface9Vtbl): IDirect3DResource9(IDirect3DResource9Vtbl) {
+    fn GetContainer(
+        riid: *const IID,
+        ppContainer: *mut *mut VOID,
+    ) -> HRESULT,
+    fn GetDesc(
+        pDesc: *mut D3DSURFACE_DESC,
+    ) -> HRESULT,
+    fn LockRect(
+        pLockedRect: *mut D3DLOCKED_RECT,
+        pRect: *const RECT,
+        Flags: DWORD,
+    ) -> HRESULT,
+    fn UnlockRect() -> HRESULT,
+    fn GetDC(
+        phdc: *mut HDC,
+    ) -> HRESULT,
+    fn ReleaseDC(
+        hdc: HDC,
+    ) -> HRESULT,
+}}
+pub type LPDIRECT3DSURFACE9 = *mut IDirect3DSurface9;
+pub type PDIRECT3DSURFACE9 = *mut IDirect3DSurface9;
+RIDL!{#[uuid(0x24f416e6, 0x1f67, 0x4aa7, 0xb8, 0x8e, 0xd3, 0x3f, 0x6f, 0x31, 0x28, 0xa1)]
+interface IDirect3DVolume9(IDirect3DVolume9Vtbl): IUnknown(IUnknownVtbl) {
+    fn GetDevice(
+        ppDevice: *mut *mut IDirect3DDevice9,
+    ) -> HRESULT,
+    fn SetPrivateData(
+        refguid: *const GUID,
+        pData: *const VOID,
+        SizeOfData: DWORD,
+        Flags: DWORD,
+    ) -> HRESULT,
+    fn GetPrivateData(
+        refguid: *const GUID,
+        pData: *mut VOID,
+        pSizeOfData: *mut DWORD,
+    ) -> HRESULT,
+    fn FreePrivateData(
+        refguid: *const GUID,
+    ) -> HRESULT,
+    fn GetContainer(
+        riid: *const IID,
+        ppContainer: *mut *mut VOID,
+    ) -> HRESULT,
+    fn GetDesc(
+        pDesc: *mut D3DVOLUME_DESC,
+    ) -> HRESULT,
+    fn LockBox(
+        pLockedVolume: *mut D3DLOCKED_BOX,
+        pBox: *const D3DBOX,
+        Flags: DWORD,
+    ) -> HRESULT,
+    fn UnlockBox() -> HRESULT,
+}}
+pub type LPDIRECT3DVOLUME9 = *mut IDirect3DVolume9;
+pub type PDIRECT3DVOLUME9 = *mut IDirect3DVolume9;
+RIDL!{#[uuid(0xd9771460, 0xa695, 0x4f26, 0xbb, 0xd3, 0x27, 0xb8, 0x40, 0xb5, 0x41, 0xcc)]
+interface IDirect3DQuery9(IDirect3DQuery9Vtbl): IUnknown(IUnknownVtbl) {
+    fn GetDevice(
+        ppDevice: *mut *mut IDirect3DDevice9,
+    ) -> HRESULT,
+    fn GetType() -> D3DRESOURCETYPE,
+    fn GetDataSize() -> DWORD,
+    fn Issue(
+        dwIssueFlags: DWORD,
+    ) -> HRESULT,
+    fn GetData(
+        pData: *mut VOID,
+        dwSize: DWORD,
+        dwGetDataFlags: DWORD,
+    ) -> HRESULT,
+}}
+pub type LPDIRECT3DQUERY9 = *mut IDirect3DQuery9;
+pub type PDIRECT3DQUERY9 = *mut IDirect3DQuery9;
+pub const D3DCREATE_FPU_PRESERVE: DWORD = 0x2;
+pub const D3DCREATE_MULTITHREADED: DWORD = 0x4;
+pub const D3DCREATE_PUREDEVICE: DWORD = 0x10;
+pub const D3DCREATE_SOFTWARE_VERTEXPROCESSING: DWORD = 0x20;
+pub const D3DCREATE_HARDWARE_VERTEXPROCESSING: DWORD = 0x40;
+pub const D3DCREATE_MIXED_VERTEXPROCESSING: DWORD = 0x80;
+pub const D3DCREATE_DISABLE_DRIVER_MANAGEMENT: DWORD = 0x100;
+pub const D3DCREATE_ADAPTERGROUP_DEVICE: DWORD = 0x200;
+pub const D3DCREATE_DISABLE_DRIVER_MANAGEMENT_EX: DWORD = 0x400;
+pub const D3DCREATE_NOWINDOWCHANGES: DWORD = 0x800;
+pub const D3DCREATE_DISABLE_PSGP_THREADING: DWORD = 0x2000;
+pub const D3DCREATE_ENABLE_PRESENTSTATS: DWORD = 0x4000;
+pub const D3DCREATE_DISABLE_PRESENTSTATS: DWORD = 0x8000;
+pub const D3DCREATE_SCREENSAVER: DWORD = 0x10000000;
+pub const D3DADAPTER_DEFAULT: DWORD = 0;
+extern "system" {
+    pub fn Direct3DCreate9Ex(
+        SDKVersion: UINT,
+        arg1: *mut *mut IDirect3D9Ex,
+    ) -> HRESULT;
+}
+RIDL!{#[uuid(0x02177241, 0x69fc, 0x400c, 0x8f, 0xf1, 0x93, 0xa4, 0x4d, 0xf6, 0x86, 0x1d)]
+interface IDirect3D9Ex(IDirect3D9ExVtbl): IDirect3D9(IDirect3D9Vtbl) {
+    fn GetAdapterModeCountEx(
+        Adapter: UINT,
+        pFilter: *const D3DDISPLAYMODEFILTER,
+    ) -> UINT,
+    fn EnumAdapterModesEx(
+        Adapter: UINT,
+        pFilter: *const D3DDISPLAYMODEFILTER,
+        Mode: UINT,
+        pMode: *mut D3DDISPLAYMODEEX,
+    ) -> HRESULT,
+    fn GetAdapterDisplayModeEx(
+        Adapter: UINT,
+        pMode: *mut D3DDISPLAYMODEEX,
+        pRotation: *mut D3DDISPLAYROTATION,
+    ) -> HRESULT,
+    fn CreateDeviceEx(
+        Adapter: UINT,
+        DeviceType: D3DDEVTYPE,
+        hFocusWindow: HWND,
+        BehaviorFlags: DWORD,
+        pPresentationParameters: *mut D3DPRESENT_PARAMETERS,
+        pFullscreenDisplayMode: *mut D3DDISPLAYMODEEX,
+        ppReturnedDeviceInterface: *mut *mut IDirect3DDevice9Ex,
+    ) -> HRESULT,
+    fn GetAdapterLUID(
+        Adapter: UINT,
+        pLUID: *mut LUID,
+    ) -> HRESULT,
+}}
+pub type LPDIRECT3D9EX = *mut IDirect3D9Ex;
+pub type PDIRECT3D9EX = *mut IDirect3D9Ex;
+RIDL!{#[uuid(0xb18b10ce, 0x2649, 0x405a, 0x87, 0xf, 0x95, 0xf7, 0x77, 0xd4, 0x31, 0x3a)]
+interface IDirect3DDevice9Ex(IDirect3DDevice9ExVtbl): IDirect3DDevice9(IDirect3DDevice9Vtbl) {
+    fn SetConvolutionMonoKernel(
+        width: UINT,
+        height: UINT,
+        rows: *mut FLOAT,
+        columns: *mut FLOAT,
+    ) -> HRESULT,
+    fn ComposeRects(
+        pSrc: *mut IDirect3DSurface9,
+        pDst: *mut IDirect3DSurface9,
+        pSrcRectDescs: *mut IDirect3DVertexBuffer9,
+        NumRects: UINT,
+        pDstRectDescs: *mut IDirect3DVertexBuffer9,
+        Operation: D3DCOMPOSERECTSOP,
+        Xoffset: INT,
+        Yoffset: INT,
+    ) -> HRESULT,
+    fn PresentEx(
+        pSourceRect: *const RECT,
+        pDestRect: *const RECT,
+        hDestWindowOverride: HWND,
+        pDirtyRegion: *const RGNDATA,
+        dwFlags: DWORD,
+    ) -> HRESULT,
+    fn GetGPUThreadPriority(
+        pPriority: *mut INT,
+    ) -> HRESULT,
+    fn SetGPUThreadPriority(
+        Priority: INT,
+    ) -> HRESULT,
+    fn WaitForVBlank(
+        iSwapChain: UINT,
+    ) -> HRESULT,
+    fn CheckResourceResidency(
+        pResourceArray: *mut *mut IDirect3DResource9,
+        NumResources: UINT32,
+    ) -> HRESULT,
+    fn SetMaximumFrameLatency(
+        MaxLatency: UINT,
+    ) -> HRESULT,
+    fn GetMaximumFrameLatency(
+        pMaxLatency: *mut UINT,
+    ) -> HRESULT,
+    fn CheckDeviceState(
+        hDestinationWindow: HWND,
+    ) -> HRESULT,
+    fn CreateRenderTargetEx(
+        Width: UINT,
+        Height: UINT,
+        Format: D3DFORMAT,
+        MultiSample: D3DMULTISAMPLE_TYPE,
+        MultisampleQuality: DWORD,
+        Lockable: BOOL,
+        ppSurface: *mut *mut IDirect3DSurface9,
+        pSharedHandle: *mut HANDLE,
+        Usage: DWORD,
+    ) -> HRESULT,
+    fn CreateOffscreenPlainSurfaceEx(
+        Width: UINT,
+        Height: UINT,
+        Format: D3DFORMAT,
+        Pool: D3DPOOL,
+        ppSurface: *mut *mut IDirect3DSurface9,
+        pSharedHandle: *mut HANDLE,
+        Usage: DWORD,
+    ) -> HRESULT,
+    fn CreateDepthStencilSurfaceEx(
+        Width: UINT,
+        Height: UINT,
+        Format: D3DFORMAT,
+        MultiSample: D3DMULTISAMPLE_TYPE,
+        MultisampleQuality: DWORD,
+        Discard: BOOL,
+        ppSurface: *mut *mut IDirect3DSurface9,
+        pSharedHandle: *mut HANDLE,
+        Usage: DWORD,
+    ) -> HRESULT,
+    fn ResetEx(
+        pPresentationParameters: *mut D3DPRESENT_PARAMETERS,
+        pFullscreenDisplayMode: *mut D3DDISPLAYMODEEX,
+    ) -> HRESULT,
+    fn GetDisplayModeEx(
+        iSwapChain: UINT,
+        pMode: *mut D3DDISPLAYMODEEX,
+        pRotation: *mut D3DDISPLAYROTATION,
+    ) -> HRESULT,
+}}
+pub type LPDIRECT3DDEVICE9EX = *mut IDirect3DDevice9Ex;
+pub type PDIRECT3DDEVICE9EX = *mut IDirect3DDevice9Ex;
+RIDL!{#[uuid(0x91886caf, 0x1c3d, 0x4d2e, 0xa0, 0xab, 0x3e, 0x4c, 0x7d, 0x8d, 0x33, 0x3)]
+interface IDirect3DSwapChain9Ex(IDirect3DSwapChain9ExVtbl):
+    IDirect3DSwapChain9(IDirect3DSwapChain9Vtbl) {
+    fn GetLastPresentCount(
+        pLastPresentCount: *mut UINT,
+    ) -> HRESULT,
+    fn GetPresentStats(
+        pPresentationStatistics: *mut D3DPRESENTSTATS,
+    ) -> HRESULT,
+    fn GetDisplayModeEx(
+        pMode: *mut D3DDISPLAYMODEEX,
+        pRotation: *mut D3DDISPLAYROTATION,
+    ) -> HRESULT,
+}}
+pub type LPDIRECT3DSWAPCHAIN9EX = *mut IDirect3DSwapChain9Ex;
+pub type PDIRECT3DSWAPCHAIN9EX = *mut IDirect3DSwapChain9Ex;
+RIDL!{#[uuid(0x187aeb13, 0xaaf5, 0x4c59, 0x87, 0x6d, 0xe0, 0x59, 0x8, 0x8c, 0xd, 0xf8)]
+interface IDirect3D9ExOverlayExtension(IDirect3D9ExOverlayExtensionVtbl): IUnknown(IUnknownVtbl) {
+    fn CheckDeviceOverlayType(
+        Adapter: UINT,
+        DevType: D3DDEVTYPE,
+        OverlayWidth: UINT,
+        OverlayHeight: UINT,
+        OverlayFormat: D3DFORMAT,
+        pDisplayMode: *mut D3DDISPLAYMODEEX,
+        DisplayRotation: D3DDISPLAYROTATION,
+        pOverlayCaps: *mut D3DOVERLAYCAPS,
+    ) -> HRESULT,
+}}
+pub type LPDIRECT3D9EXOVERLAYEXTENSION = *mut IDirect3D9ExOverlayExtension;
+pub type PDIRECT3D9EXOVERLAYEXTENSION = *mut IDirect3D9ExOverlayExtension;
+RIDL!{#[uuid(0x26dc4561, 0xa1ee, 0x4ae7, 0x96, 0xda, 0x11, 0x8a, 0x36, 0xc0, 0xec, 0x95)]
+interface IDirect3DDevice9Video(IDirect3DDevice9VideoVtbl): IUnknown(IUnknownVtbl) {
+    fn GetContentProtectionCaps(
+        pCryptoType: *const GUID,
+        pDecodeProfile: *const GUID,
+        pCaps: *mut D3DCONTENTPROTECTIONCAPS,
+    ) -> HRESULT,
+    fn CreateAuthenticatedChannel(
+        ChannelType: D3DAUTHENTICATEDCHANNELTYPE,
+        ppAuthenticatedChannel: *mut *mut IDirect3DAuthenticatedChannel9,
+        pChannelHandle: *mut HANDLE,
+    ) -> HRESULT,
+    fn CreateCryptoSession(
+        pCryptoType: *const GUID,
+        pDecodeProfile: *const GUID,
+        ppCryptoSession: *mut *mut IDirect3DCryptoSession9,
+        pCryptoHandle: *mut HANDLE,
+    ) -> HRESULT,
+}}
+pub type LPDIRECT3DDEVICE9VIDEO = *mut IDirect3DDevice9Video;
+pub type PDIRECT3DDEVICE9VIDEO = *mut IDirect3DDevice9Video;
+RIDL!{#[uuid(0xff24beee, 0xda21, 0x4beb, 0x98, 0xb5, 0xd2, 0xf8, 0x99, 0xf9, 0x8a, 0xf9)]
+interface IDirect3DAuthenticatedChannel9(IDirect3DAuthenticatedChannel9Vtbl):
+    IUnknown(IUnknownVtbl) {
+    fn GetCertificateSize(
+        pCertificateSize: *mut UINT,
+    ) -> HRESULT,
+    fn GetCertificate(
+        CertifacteSize: UINT,
+        ppCertificate: *mut BYTE,
+    ) -> HRESULT,
+    fn NegotiateKeyExchange(
+        DataSize: UINT,
+        pData: *mut VOID,
+    ) -> HRESULT,
+    fn Query(
+        InputSize: UINT,
+        pInput: *const VOID,
+        OutputSize: UINT,
+        pOutput: *mut VOID,
+    ) -> HRESULT,
+    fn Configure(
+        InputSize: UINT,
+        pInput: *const VOID,
+        pOutput: *mut D3DAUTHENTICATEDCHANNEL_CONFIGURE_OUTPUT,
+    ) -> HRESULT,
+}}
+pub type LPDIRECT3DAUTHENTICATEDCHANNEL9 = *mut IDirect3DAuthenticatedChannel9;
+pub type PDIRECT3DAUTHENTICATEDCHANNEL9 = *mut IDirect3DAuthenticatedChannel9;
+RIDL!{#[uuid(0xfa0ab799, 0x7a9c, 0x48ca, 0x8c, 0x5b, 0x23, 0x7e, 0x71, 0xa5, 0x44, 0x34)]
+interface IDirect3DCryptoSession9(IDirect3DCryptoSession9Vtbl): IUnknown(IUnknownVtbl) {
+    fn GetCertificateSize(
+        pCertificateSize: *mut UINT,
+    ) -> HRESULT,
+    fn GetCertificate(
+        CertifacteSize: UINT,
+        ppCertificate: *mut BYTE,
+    ) -> HRESULT,
+    fn NegotiateKeyExchange(
+        DataSize: UINT,
+        pData: *mut VOID,
+    ) -> HRESULT,
+    fn EncryptionBlt(
+        pSrcSurface: *mut IDirect3DSurface9,
+        pDstSurface: *mut IDirect3DSurface9,
+        DstSurfaceSize: UINT,
+        pIV: *mut VOID,
+    ) -> HRESULT,
+    fn DecryptionBlt(
+        pSrcSurface: *mut IDirect3DSurface9,
+        pDstSurface: *mut IDirect3DSurface9,
+        SrcSurfaceSize: UINT,
+        pEncryptedBlockInfo: *mut D3DENCRYPTED_BLOCK_INFO,
+        pContentKey: *mut VOID,
+        pIV: *mut VOID,
+    ) -> HRESULT,
+    fn GetSurfacePitch(
+        pSrcSurface: *mut IDirect3DSurface9,
+        pSurfacePitch: *mut UINT,
+    ) -> HRESULT,
+    fn StartSessionKeyRefresh(
+        pRandomNumber: *mut VOID,
+        RandomNumberSize: UINT,
+    ) -> HRESULT,
+    fn FinishSessionKeyRefresh() -> HRESULT,
+    fn GetEncryptionBltKey(
+        pReadbackKey: *mut VOID,
+        KeySize: UINT,
+    ) -> HRESULT,
+}}
+pub type LPDIRECT3DCRYPTOSESSION9 = *mut IDirect3DCryptoSession9;
+pub type PDIRECT3DCRYPTOSESSION9 = *mut IDirect3DCryptoSession9;