| // 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; |
