| // Copyright © 2015, Corey Richardson |
| // Licensed under the MIT License <LICENSE.md> |
| //! Direct3D include file |
| pub const D3D_SDK_VERSION: ::DWORD = 32; |
| pub const D3D9b_SDK_VERSION: ::DWORD = 31; |
| RIDL!( |
| interface IDirect3D9(IDirect3D9Vtbl): IUnknown(IUnknownVtbl) { |
| fn RegisterSoftwareDevice(&mut self, pInitializeFunction: *mut ::VOID) -> ::HRESULT, |
| fn GetAdapterCount(&mut self) -> ::UINT, |
| fn GetAdapterIdentifier( |
| &mut self, Adapter: ::UINT, Flags: ::DWORD, pIdentifier: *mut ::D3DADAPTER_IDENTIFIER9 |
| ) -> ::HRESULT, |
| fn GetAdapterModeCount(&mut self, Adapter: ::UINT, Format: ::D3DFORMAT) -> ::UINT, |
| fn EnumAdapterModes( |
| &mut self, Adapter: ::UINT, Format: ::D3DFORMAT, Mode: ::UINT, pMode: *mut ::D3DDISPLAYMODE |
| ) -> ::HRESULT, |
| fn GetAdapterDisplayMode( |
| &mut self, Adapter: ::UINT, pMode: *mut ::D3DDISPLAYMODE |
| ) -> ::HRESULT, |
| fn CheckDeviceType( |
| &mut self, Adapter: ::UINT, DevType: ::D3DDEVTYPE, AdapterFormat: ::D3DFORMAT, |
| BackBufferFormat: ::D3DFORMAT, bWindowed: ::BOOL |
| ) -> ::HRESULT, |
| fn CheckDeviceFormat( |
| &mut self, Adapter: ::UINT, DeviceType: ::D3DDEVTYPE, AdapterFormat: ::D3DFORMAT, |
| Usage: ::DWORD, RType: ::D3DRESOURCETYPE, CheckFormat: ::D3DFORMAT |
| ) -> ::HRESULT, |
| fn CheckDeviceMultiSampleType( |
| &mut self, Adapter: ::UINT, DeviceType: ::D3DDEVTYPE, SurfaceFormat: ::D3DFORMAT, |
| Windowed: ::BOOL, MultiSampleType: ::D3DMULTISAMPLE_TYPE, pQualityLevels: *mut ::DWORD |
| ) -> ::HRESULT, |
| fn CheckDepthStencilMatch( |
| &mut self, Adapter: ::UINT, DeviceType: ::D3DDEVTYPE, AdapterFormat: ::D3DFORMAT, |
| RenderTargetFormat: ::D3DFORMAT, DepthStencilFormat: ::D3DFORMAT |
| ) -> ::HRESULT, |
| fn CheckDeviceFormatConversion( |
| &mut self, Adapter: ::UINT, DeviceType: ::D3DDEVTYPE, SourceFormat: ::D3DFORMAT, |
| TargetFormat: ::D3DFORMAT |
| ) -> ::HRESULT, |
| fn GetDeviceCaps( |
| &mut self, Adapter: ::UINT, DeviceType: ::D3DDEVTYPE, pCaps: *mut ::D3DCAPS9 |
| ) -> ::HRESULT, |
| fn GetAdapterMonitor(&mut self, Adapter: ::UINT) -> ::HMONITOR, |
| fn CreateDevice( |
| &mut self, 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!( |
| interface IDirect3DDevice9(IDirect3DDevice9Vtbl): IUnknown(IUnknownVtbl) { |
| fn TestCooperativeLevel(&mut self) -> ::HRESULT, |
| fn GetAvailableTextureMem(&mut self) -> ::UINT, |
| fn EvictManagedResources(&mut self) -> ::HRESULT, |
| fn GetDirect3D(&mut self, ppD3D9: *mut *mut IDirect3D9) -> ::HRESULT, |
| fn GetDeviceCaps(&mut self, pCaps: *mut ::D3DCAPS9) -> ::HRESULT, |
| fn GetDisplayMode(&mut self, iSwapChain: ::UINT, pMode: *mut ::D3DDISPLAYMODE) -> ::HRESULT, |
| fn GetCreationParameters( |
| &mut self, pParameters: *mut ::D3DDEVICE_CREATION_PARAMETERS |
| ) -> ::HRESULT, |
| fn SetCursorProperties( |
| &mut self, XHotSpot: ::UINT, YHotSpot: ::UINT, pCursorBitmap: *mut IDirect3DSurface9 |
| ) -> ::HRESULT, |
| fn SetCursorPosition(&mut self, X: ::INT, Y: ::INT, Flags: ::DWORD) -> (), |
| fn ShowCursor(&mut self, bShow: ::BOOL) -> ::BOOL, |
| fn CreateAdditionalSwapChain( |
| &mut self, pPresentationParameters: *mut ::D3DPRESENT_PARAMETERS, |
| pSwapChain: *mut *mut IDirect3DSwapChain9 |
| ) -> ::HRESULT, |
| fn GetSwapChain( |
| &mut self, iSwapChain: ::UINT, pSwapChain: *mut *mut IDirect3DSwapChain9 |
| ) -> ::HRESULT, |
| fn GetNumberOfSwapChains(&mut self) -> ::UINT, |
| fn Reset(&mut self, pPresentationParameters: *mut ::D3DPRESENT_PARAMETERS) -> ::HRESULT, |
| fn Present( |
| &mut self, pSourceRect: *const ::RECT, pDestRect: *const ::RECT, |
| hDestWindowOverride: ::HWND, pDirtyRegion: *const ::RGNDATA |
| ) -> ::HRESULT, |
| fn GetBackBuffer( |
| &mut self, iSwapChain: ::UINT, iBackBuffer: ::UINT, Type: ::D3DBACKBUFFER_TYPE, |
| ppBackBuffer: *mut *mut IDirect3DSurface9 |
| ) -> ::HRESULT, |
| fn GetRasterStatus( |
| &mut self, iSwapChain: ::UINT, pRasterStatus: *mut ::D3DRASTER_STATUS |
| ) -> ::HRESULT, |
| fn SetDialogBoxMode(&mut self, bEnableDialogs: ::BOOL) -> ::HRESULT, |
| fn SetGammaRamp( |
| &mut self, iSwapChain: ::UINT, Flags: ::DWORD, pRamp: *const ::D3DGAMMARAMP |
| ) -> (), |
| fn GetGammaRamp(&mut self, iSwapChain: ::UINT, pRamp: *mut ::D3DGAMMARAMP) -> (), |
| fn CreateTexture( |
| &mut self, Width: ::UINT, Height: ::UINT, Levels: ::UINT, Usage: ::DWORD, |
| Format: ::D3DFORMAT, Pool: ::D3DPOOL, ppTexture: *mut *mut IDirect3DTexture9, |
| pSharedHandle: *mut ::HANDLE |
| ) -> ::HRESULT, |
| fn CreateVolumeTexture( |
| &mut self, Width: ::UINT, Height: ::UINT, Depth: ::UINT, Levels: ::UINT, Usage: ::DWORD, |
| Format: ::D3DFORMAT, Pool: ::D3DPOOL, ppVolumeTexture: *mut *mut IDirect3DVolumeTexture9, |
| pSharedHandle: *mut ::HANDLE |
| ) -> ::HRESULT, |
| fn CreateCubeTexture( |
| &mut self, EdgeLength: ::UINT, Levels: ::UINT, Usage: ::DWORD, Format: ::D3DFORMAT, |
| Pool: ::D3DPOOL, ppCubeTexture: *mut *mut IDirect3DCubeTexture9, |
| pSharedHandle: *mut ::HANDLE |
| ) -> ::HRESULT, |
| fn CreateVertexBuffer( |
| &mut self, Length: ::UINT, Usage: ::DWORD, FVF: ::DWORD, Pool: ::D3DPOOL, |
| ppVertexBuffer: *mut *mut IDirect3DVertexBuffer9, pSharedHandle: *mut ::HANDLE |
| ) -> ::HRESULT, |
| fn CreateIndexBuffer( |
| &mut self, Length: ::UINT, Usage: ::DWORD, Format: ::D3DFORMAT, Pool: ::D3DPOOL, |
| ppIndexBuffer: *mut *mut IDirect3DIndexBuffer9, pSharedHandle: *mut ::HANDLE |
| ) -> ::HRESULT, |
| fn CreateRenderTarget( |
| &mut self, Width: ::UINT, Height: ::UINT, Format: ::D3DFORMAT, |
| MultiSample: ::D3DMULTISAMPLE_TYPE, MultisampleQuality: ::DWORD, Lockable: ::BOOL, |
| ppSurface: *mut *mut IDirect3DSurface9, pSharedHandle: *mut ::HANDLE |
| ) -> ::HRESULT, |
| fn CreateDepthStencilSurface( |
| &mut self, Width: ::UINT, Height: ::UINT, Format: ::D3DFORMAT, |
| MultiSample: ::D3DMULTISAMPLE_TYPE, MultisampleQuality: ::DWORD, Discard: ::BOOL, |
| ppSurface: *mut *mut IDirect3DSurface9, pSharedHandle: *mut ::HANDLE |
| ) -> ::HRESULT, |
| fn UpdateSurface( |
| &mut self, pSourceSurface: *mut IDirect3DSurface9, pSourceRect: *const ::RECT, |
| pDestinationSurface: *mut IDirect3DSurface9, pDestPoint: *const ::POINT |
| ) -> ::HRESULT, |
| fn UpdateTexture( |
| &mut self, pSourceTexture: *mut IDirect3DBaseTexture9, |
| pDestinationTexture: *mut IDirect3DBaseTexture9 |
| ) -> ::HRESULT, |
| fn GetRenderTargetData( |
| &mut self, pRenderTarget: *mut IDirect3DSurface9, pDestSurface: *mut IDirect3DSurface9 |
| ) -> ::HRESULT, |
| fn GetFrontBufferData( |
| &mut self, iSwapChain: ::UINT, pDestSurface: *mut IDirect3DSurface9 |
| ) -> ::HRESULT, |
| fn StretchRect( |
| &mut self, pSourceSurface: *mut IDirect3DSurface9, pSourceRect: *const ::RECT, |
| pDestSurface: *mut IDirect3DSurface9, pDestRect: *const ::RECT, |
| Filter: ::D3DTEXTUREFILTERTYPE |
| ) -> ::HRESULT, |
| fn ColorFill( |
| &mut self, pSurface: *mut IDirect3DSurface9, pRect: *const ::RECT, color: ::D3DCOLOR |
| ) -> ::HRESULT, |
| fn CreateOffscreenPlainSurface( |
| &mut self, Width: ::UINT, Height: ::UINT, Format: ::D3DFORMAT, Pool: ::D3DPOOL, |
| ppSurface: *mut *mut IDirect3DSurface9, pSharedHandle: *mut ::HANDLE |
| ) -> ::HRESULT, |
| fn SetRenderTarget( |
| &mut self, RenderTargetIndex: ::DWORD, pRenderTarget: *mut IDirect3DSurface9 |
| ) -> ::HRESULT, |
| fn GetRenderTarget( |
| &mut self, RenderTargetIndex: ::DWORD, ppRenderTarget: *mut *mut IDirect3DSurface9 |
| ) -> ::HRESULT, |
| fn SetDepthStencilSurface(&mut self, pNewZStencil: *mut IDirect3DSurface9) -> ::HRESULT, |
| fn GetDepthStencilSurface( |
| &mut self, ppZStencilSurface: *mut *mut IDirect3DSurface9 |
| ) -> ::HRESULT, |
| fn BeginScene(&mut self) -> ::HRESULT, |
| fn EndScene(&mut self) -> ::HRESULT, |
| fn Clear( |
| &mut self, Count: ::DWORD, pRects: *const ::D3DRECT, Flags: ::DWORD, Color: ::D3DCOLOR, |
| Z: ::FLOAT, Stencil: ::DWORD |
| ) -> ::HRESULT, |
| fn SetTransform( |
| &mut self, State: ::D3DTRANSFORMSTATETYPE, pMatrix: *const ::D3DMATRIX |
| ) -> ::HRESULT, |
| fn GetTransform( |
| &mut self, State: ::D3DTRANSFORMSTATETYPE, pMatrix: *mut ::D3DMATRIX |
| ) -> ::HRESULT, |
| fn MultiplyTransform( |
| &mut self, arg1: ::D3DTRANSFORMSTATETYPE, arg2: *const ::D3DMATRIX |
| ) -> ::HRESULT, |
| fn SetViewport(&mut self, pViewport: *const ::D3DVIEWPORT9) -> ::HRESULT, |
| fn GetViewport(&mut self, pViewport: *mut ::D3DVIEWPORT9) -> ::HRESULT, |
| fn SetMaterial(&mut self, pMaterial: *const ::D3DMATERIAL9) -> ::HRESULT, |
| fn GetMaterial(&mut self, pMaterial: *mut ::D3DMATERIAL9) -> ::HRESULT, |
| fn SetLight(&mut self, Index: ::DWORD, arg1: *const ::D3DLIGHT9) -> ::HRESULT, |
| fn GetLight(&mut self, Index: ::DWORD, arg1: *mut ::D3DLIGHT9) -> ::HRESULT, |
| fn LightEnable(&mut self, Index: ::DWORD, Enable: ::BOOL) -> ::HRESULT, |
| fn GetLightEnable(&mut self, Index: ::DWORD, pEnable: *mut ::BOOL) -> ::HRESULT, |
| fn SetClipPlane(&mut self, Index: ::DWORD, pPlane: *const ::FLOAT) -> ::HRESULT, |
| fn GetClipPlane(&mut self, Index: ::DWORD, pPlane: *mut ::FLOAT) -> ::HRESULT, |
| fn SetRenderState(&mut self, State: ::D3DRENDERSTATETYPE, Value: ::DWORD) -> ::HRESULT, |
| fn GetRenderState(&mut self, State: ::D3DRENDERSTATETYPE, pValue: *mut ::DWORD) -> ::HRESULT, |
| fn CreateStateBlock( |
| &mut self, Type: ::D3DSTATEBLOCKTYPE, ppSB: *mut *mut IDirect3DStateBlock9 |
| ) -> ::HRESULT, |
| fn BeginStateBlock(&mut self) -> ::HRESULT, |
| fn EndStateBlock(&mut self, ppSB: *mut *mut IDirect3DStateBlock9) -> ::HRESULT, |
| fn SetClipStatus(&mut self, pClipStatus: *const ::D3DCLIPSTATUS9) -> ::HRESULT, |
| fn GetClipStatus(&mut self, pClipStatus: *mut ::D3DCLIPSTATUS9) -> ::HRESULT, |
| fn GetTexture( |
| &mut self, Stage: ::DWORD, ppTexture: *mut *mut IDirect3DBaseTexture9 |
| ) -> ::HRESULT, |
| fn SetTexture(&mut self, Stage: ::DWORD, pTexture: *mut IDirect3DBaseTexture9) -> ::HRESULT, |
| fn GetTextureStageState( |
| &mut self, Stage: ::DWORD, Type: ::D3DTEXTURESTAGESTATETYPE, pValue: *mut ::DWORD |
| ) -> ::HRESULT, |
| fn SetTextureStageState( |
| &mut self, Stage: ::DWORD, Type: ::D3DTEXTURESTAGESTATETYPE, Value: ::DWORD |
| ) -> ::HRESULT, |
| fn GetSamplerState( |
| &mut self, Sampler: ::DWORD, Type: ::D3DSAMPLERSTATETYPE, pValue: *mut ::DWORD |
| ) -> ::HRESULT, |
| fn SetSamplerState( |
| &mut self, Sampler: ::DWORD, Type: ::D3DSAMPLERSTATETYPE, Value: ::DWORD |
| ) -> ::HRESULT, |
| fn ValidateDevice(&mut self, pNumPasses: *mut ::DWORD) -> ::HRESULT, |
| fn SetPaletteEntries( |
| &mut self, PaletteNumber: ::UINT, pEntries: *const ::PALETTEENTRY |
| ) -> ::HRESULT, |
| fn GetPaletteEntries( |
| &mut self, PaletteNumber: ::UINT, pEntries: *mut ::PALETTEENTRY |
| ) -> ::HRESULT, |
| fn SetCurrentTexturePalette(&mut self, PaletteNumber: ::UINT) -> ::HRESULT, |
| fn GetCurrentTexturePalette(&mut self, PaletteNumber: *mut ::UINT) -> ::HRESULT, |
| fn SetScissorRect(&mut self, pRect: *const ::RECT) -> ::HRESULT, |
| fn GetScissorRect(&mut self, pRect: *mut ::RECT) -> ::HRESULT, |
| fn SetSoftwareVertexProcessing(&mut self, bSoftware: ::BOOL) -> ::HRESULT, |
| fn GetSoftwareVertexProcessing(&mut self) -> ::BOOL, |
| fn SetNPatchMode(&mut self, nSegments: ::FLOAT) -> ::HRESULT, |
| fn GetNPatchMode(&mut self) -> ::FLOAT, |
| fn DrawPrimitive( |
| &mut self, PrimitiveType: ::D3DPRIMITIVETYPE, StartVertex: ::UINT, PrimitiveCount: ::UINT |
| ) -> ::HRESULT, |
| fn DrawIndexedPrimitive( |
| &mut self, arg1: ::D3DPRIMITIVETYPE, BaseVertexIndex: ::INT, MinVertexIndex: ::UINT, |
| NumVertices: ::UINT, startIndex: ::UINT, primCount: ::UINT |
| ) -> ::HRESULT, |
| fn DrawPrimitiveUP( |
| &mut self, PrimitiveType: ::D3DPRIMITIVETYPE, PrimitiveCount: ::UINT, |
| pVertexStreamZeroData: *const ::VOID, VertexStreamZeroStride: ::UINT |
| ) -> ::HRESULT, |
| fn DrawIndexedPrimitiveUP( |
| &mut self, PrimitiveType: ::D3DPRIMITIVETYPE, MinVertexIndex: ::UINT, NumVertices: ::UINT, |
| PrimitiveCount: ::UINT, pIndexData: *const ::VOID, IndexDataFormat: ::D3DFORMAT, |
| pVertexStreamZeroData: *const ::VOID, VertexStreamZeroStride: ::UINT |
| ) -> ::HRESULT, |
| fn ProcessVertices( |
| &mut self, SrcStartIndex: ::UINT, DestIndex: ::UINT, VertexCount: ::UINT, |
| pDestBuffer: *mut IDirect3DVertexBuffer9, pVertexDecl: *mut IDirect3DVertexDeclaration9, |
| Flags: ::DWORD |
| ) -> ::HRESULT, |
| fn CreateVertexDeclaration( |
| &mut self, pVertexElements: *const ::D3DVERTEXELEMENT9, |
| ppDecl: *mut *mut IDirect3DVertexDeclaration9 |
| ) -> ::HRESULT, |
| fn SetVertexDeclaration(&mut self, pDecl: *mut IDirect3DVertexDeclaration9) -> ::HRESULT, |
| fn GetVertexDeclaration(&mut self, ppDecl: *mut *mut IDirect3DVertexDeclaration9) -> ::HRESULT, |
| fn SetFVF(&mut self, FVF: ::DWORD) -> ::HRESULT, |
| fn GetFVF(&mut self, pFVF: *mut ::DWORD) -> ::HRESULT, |
| fn CreateVertexShader( |
| &mut self, pFunction: *const ::DWORD, ppShader: *mut *mut IDirect3DVertexShader9 |
| ) -> ::HRESULT, |
| fn SetVertexShader(&mut self, pShader: *mut IDirect3DVertexShader9) -> ::HRESULT, |
| fn GetVertexShader(&mut self, ppShader: *mut *mut IDirect3DVertexShader9) -> ::HRESULT, |
| fn SetVertexShaderConstantF( |
| &mut self, StartRegister: ::UINT, pConstantData: *const ::FLOAT, Vector4fCount: ::UINT |
| ) -> ::HRESULT, |
| fn GetVertexShaderConstantF( |
| &mut self, StartRegister: ::UINT, pConstantData: *mut ::FLOAT, Vector4fCount: ::UINT |
| ) -> ::HRESULT, |
| fn SetVertexShaderConstantI( |
| &mut self, StartRegister: ::UINT, pConstantData: *const ::INT, Vector4iCount: ::UINT |
| ) -> ::HRESULT, |
| fn GetVertexShaderConstantI( |
| &mut self, StartRegister: ::UINT, pConstantData: *mut ::INT, Vector4iCount: ::UINT |
| ) -> ::HRESULT, |
| fn SetVertexShaderConstantB( |
| &mut self, StartRegister: ::UINT, pConstantData: *const ::BOOL, BoolCount: ::UINT |
| ) -> ::HRESULT, |
| fn GetVertexShaderConstantB( |
| &mut self, StartRegister: ::UINT, pConstantData: *mut ::BOOL, BoolCount: ::UINT |
| ) -> ::HRESULT, |
| fn SetStreamSource( |
| &mut self, StreamNumber: ::UINT, pStreamData: *mut IDirect3DVertexBuffer9, |
| OffsetInBytes: ::UINT, Stride: ::UINT |
| ) -> ::HRESULT, |
| fn GetStreamSource( |
| &mut self, StreamNumber: ::UINT, ppStreamData: *mut *mut IDirect3DVertexBuffer9, |
| pOffsetInBytes: *mut ::UINT, pStride: *mut ::UINT |
| ) -> ::HRESULT, |
| fn SetStreamSourceFreq(&mut self, StreamNumber: ::UINT, Setting: ::UINT) -> ::HRESULT, |
| fn GetStreamSourceFreq(&mut self, StreamNumber: ::UINT, pSetting: *mut ::UINT) -> ::HRESULT, |
| fn SetIndices(&mut self, pIndexData: *mut IDirect3DIndexBuffer9) -> ::HRESULT, |
| fn GetIndices(&mut self, ppIndexData: *mut *mut IDirect3DIndexBuffer9) -> ::HRESULT, |
| fn CreatePixelShader( |
| &mut self, pFunction: *const ::DWORD, ppShader: *mut *mut IDirect3DPixelShader9 |
| ) -> ::HRESULT, |
| fn SetPixelShader(&mut self, pShader: *mut IDirect3DPixelShader9) -> ::HRESULT, |
| fn GetPixelShader(&mut self, ppShader: *mut *mut IDirect3DPixelShader9) -> ::HRESULT, |
| fn SetPixelShaderConstantF( |
| &mut self, StartRegister: ::UINT, pConstantData: *const ::FLOAT, Vector4fCount: ::UINT |
| ) -> ::HRESULT, |
| fn GetPixelShaderConstantF( |
| &mut self, StartRegister: ::UINT, pConstantData: *mut ::FLOAT, Vector4fCount: ::UINT |
| ) -> ::HRESULT, |
| fn SetPixelShaderConstantI( |
| &mut self, StartRegister: ::UINT, pConstantData: *const ::INT, Vector4iCount: ::UINT |
| ) -> ::HRESULT, |
| fn GetPixelShaderConstantI( |
| &mut self, StartRegister: ::UINT, pConstantData: *mut ::INT, Vector4iCount: ::UINT |
| ) -> ::HRESULT, |
| fn SetPixelShaderConstantB( |
| &mut self, StartRegister: ::UINT, pConstantData: *const ::BOOL, BoolCount: ::UINT |
| ) -> ::HRESULT, |
| fn GetPixelShaderConstantB( |
| &mut self, StartRegister: ::UINT, pConstantData: *mut ::BOOL, BoolCount: ::UINT |
| ) -> ::HRESULT, |
| fn DrawRectPatch( |
| &mut self, Handle: ::UINT, pNumSegs: *const ::FLOAT, |
| pRectPatchInfo: *const ::D3DRECTPATCH_INFO |
| ) -> ::HRESULT, |
| fn DrawTriPatch( |
| &mut self, Handle: ::UINT, pNumSegs: *const ::FLOAT, |
| pTriPatchInfo: *const ::D3DTRIPATCH_INFO |
| ) -> ::HRESULT, |
| fn DeletePatch(&mut self, Handle: ::UINT) -> ::HRESULT, |
| fn CreateQuery( |
| &mut self, Type: ::D3DQUERYTYPE, ppQuery: *mut *mut IDirect3DQuery9 |
| ) -> ::HRESULT |
| } |
| ); |
| pub type LPDIRECT3DDEVICE9 = *mut IDirect3DDevice9; |
| pub type PDIRECT3DDEVICE9 = *mut IDirect3DDevice9; |
| RIDL!( |
| interface IDirect3DStateBlock9(IDirect3DStateBlock9Vtbl): IUnknown(IUnknownVtbl) { |
| fn GetDevice(&mut self, ppDevice: *mut *mut IDirect3DDevice9) -> ::HRESULT, |
| fn Capture(&mut self) -> ::HRESULT, |
| fn Apply(&mut self) -> ::HRESULT |
| } |
| ); |
| pub type LPDIRECT3DSTATEBLOCK9 = *mut IDirect3DStateBlock9; |
| pub type PDIRECT3DSTATEBLOCK9 = *mut IDirect3DStateBlock9; |
| RIDL!( |
| interface IDirect3DSwapChain9(IDirect3DSwapChain9Vtbl): IUnknown(IUnknownVtbl) { |
| fn Present( |
| &mut self, pSourceRect: *const ::RECT, pDestRect: *const ::RECT, |
| hDestWindowOverride: ::HWND, pDirtyRegion: *const ::RGNDATA, dwFlags: ::DWORD |
| ) -> ::HRESULT, |
| fn GetFrontBufferData(&mut self, pDestSurface: *mut IDirect3DSurface9) -> ::HRESULT, |
| fn GetBackBuffer( |
| &mut self, iBackBuffer: ::UINT, Type: ::D3DBACKBUFFER_TYPE, |
| ppBackBuffer: *mut *mut IDirect3DSurface9 |
| ) -> ::HRESULT, |
| fn GetRasterStatus(&mut self, pRasterStatus: *mut ::D3DRASTER_STATUS) -> ::HRESULT, |
| fn GetDisplayMode(&mut self, pMode: *mut ::D3DDISPLAYMODE) -> ::HRESULT, |
| fn GetDevice(&mut self, ppDevice: *mut *mut IDirect3DDevice9) -> ::HRESULT, |
| fn GetPresentParameters( |
| &mut self, pPresentationParameters: *mut ::D3DPRESENT_PARAMETERS |
| ) -> ::HRESULT |
| } |
| ); |
| pub type LPDIRECT3DSWAPCHAIN9 = *mut IDirect3DSwapChain9; |
| pub type PDIRECT3DSWAPCHAIN9 = *mut IDirect3DSwapChain9; |
| RIDL!( |
| interface IDirect3DResource9(IDirect3DResource9Vtbl): IUnknown(IUnknownVtbl) { |
| fn GetDevice(&mut self, ppDevice: *mut *mut IDirect3DDevice9) -> ::HRESULT, |
| fn SetPrivateData( |
| &mut self, refguid: *const ::GUID, pData: *const ::VOID, SizeOfData: ::DWORD, |
| Flags: ::DWORD |
| ) -> ::HRESULT, |
| fn GetPrivateData( |
| &mut self, refguid: *const ::GUID, pData: *mut ::VOID, pSizeOfData: *mut ::DWORD |
| ) -> ::HRESULT, |
| fn FreePrivateData(&mut self, refguid: *const ::GUID) -> ::HRESULT, |
| fn SetPriority(&mut self, PriorityNew: ::DWORD) -> ::DWORD, |
| fn GetPriority(&mut self) -> ::DWORD, |
| fn PreLoad(&mut self) -> (), |
| fn GetType(&mut self) -> ::D3DRESOURCETYPE |
| } |
| ); |
| pub type LPDIRECT3DRESOURCE9 = *mut IDirect3DResource9; |
| pub type PDIRECT3DRESOURCE9 = *mut IDirect3DResource9; |
| RIDL!( |
| interface IDirect3DVertexDeclaration9(IDirect3DVertexDeclaration9Vtbl): IUnknown(IUnknownVtbl) { |
| fn GetDevice(&mut self, ppDevice: *mut *mut IDirect3DDevice9) -> ::HRESULT, |
| fn GetDeclaration( |
| &mut self, pElement: *mut ::D3DVERTEXELEMENT9, pNumElements: *mut ::UINT |
| ) -> ::HRESULT |
| } |
| ); |
| pub type LPDIRECT3DVERTEXDECLARATION9 = *mut IDirect3DVertexDeclaration9; |
| pub type PDIRECT3DVERTEXDECLARATION9 = *mut IDirect3DVertexDeclaration9; |
| RIDL!( |
| interface IDirect3DVertexShader9(IDirect3DVertexShader9Vtbl): IUnknown(IUnknownVtbl) { |
| fn GetDevice(&mut self, ppDevice: *mut *mut IDirect3DDevice9) -> ::HRESULT, |
| fn GetFunction(&mut self, arg1: *mut ::VOID, pSizeOfData: *mut ::UINT) -> ::HRESULT |
| } |
| ); |
| pub type LPDIRECT3DVERTEXSHADER9 = *mut IDirect3DVertexShader9; |
| pub type PDIRECT3DVERTEXSHADER9 = *mut IDirect3DVertexShader9; |
| RIDL!( |
| interface IDirect3DPixelShader9(IDirect3DPixelShader9Vtbl): IUnknown(IUnknownVtbl) { |
| fn GetDevice(&mut self, ppDevice: *mut *mut IDirect3DDevice9) -> ::HRESULT, |
| fn GetFunction(&mut self, arg1: *mut ::VOID, pSizeOfData: *mut ::UINT) -> ::HRESULT |
| } |
| ); |
| pub type LPDIRECT3DPIXELSHADER9 = *mut IDirect3DPixelShader9; |
| pub type PDIRECT3DPIXELSHADER9 = *mut IDirect3DPixelShader9; |
| RIDL!( |
| interface IDirect3DBaseTexture9(IDirect3DBaseTexture9Vtbl): IDirect3DResource9(IDirect3DResource9Vtbl) { |
| fn SetLOD(&mut self, LODNew: ::DWORD) -> ::DWORD, |
| fn GetLOD(&mut self) -> ::DWORD, |
| fn GetLevelCount(&mut self) -> ::DWORD, |
| fn SetAutoGenFilterType(&mut self, FilterType: ::D3DTEXTUREFILTERTYPE) -> ::HRESULT, |
| fn GetAutoGenFilterType(&mut self) -> ::D3DTEXTUREFILTERTYPE, |
| fn GenerateMipSubLevels(&mut self) -> () |
| } |
| ); |
| pub type LPDIRECT3DBASETEXTURE9 = *mut IDirect3DBaseTexture9; |
| pub type PDIRECT3DBASETEXTURE9 = *mut IDirect3DBaseTexture9; |
| RIDL!( |
| interface IDirect3DTexture9(IDirect3DTexture9Vtbl): IDirect3DBaseTexture9(IDirect3DBaseTexture9Vtbl) { |
| fn GetLevelDesc(&mut self, Level: ::UINT, pDesc: *mut ::D3DSURFACE_DESC) -> ::HRESULT, |
| fn GetSurfaceLevel( |
| &mut self, Level: ::UINT, ppSurfaceLevel: *mut *mut IDirect3DSurface9 |
| ) -> ::HRESULT, |
| fn LockRect( |
| &mut self, Level: ::UINT, pLockedRect: *mut ::D3DLOCKED_RECT, pRect: *const ::RECT, |
| Flags: ::DWORD |
| ) -> ::HRESULT, |
| fn UnlockRect(&mut self, Level: ::UINT) -> ::HRESULT, |
| fn AddDirtyRect(&mut self, pDirtyRect: *const ::RECT) -> ::HRESULT |
| } |
| ); |
| pub type LPDIRECT3DTEXTURE9 = *mut IDirect3DTexture9; |
| pub type PDIRECT3DTEXTURE9 = *mut IDirect3DTexture9; |
| RIDL!( |
| interface IDirect3DVolumeTexture9(IDirect3DVolumeTexture9Vtbl): IDirect3DBaseTexture9(IDirect3DBaseTexture9Vtbl) { |
| fn GetLevelDesc(&mut self, Level: ::UINT, pDesc: *mut ::D3DVOLUME_DESC) -> ::HRESULT, |
| fn GetVolumeLevel( |
| &mut self, Level: ::UINT, ppVolumeLevel: *mut *mut IDirect3DVolume9 |
| ) -> ::HRESULT, |
| fn LockBox( |
| &mut self, Level: ::UINT, pLockedVolume: *mut ::D3DLOCKED_BOX, pBox: *const ::D3DBOX, |
| Flags: ::DWORD |
| ) -> ::HRESULT, |
| fn UnlockBox(&mut self, Level: ::UINT) -> ::HRESULT, |
| fn AddDirtyBox(&mut self, pDirtyBox: *const ::D3DBOX) -> ::HRESULT |
| } |
| ); |
| pub type LPDIRECT3DVOLUMETEXTURE9 = *mut IDirect3DVolumeTexture9; |
| pub type PDIRECT3DVOLUMETEXTURE9 = *mut IDirect3DVolumeTexture9; |
| RIDL!( |
| interface IDirect3DCubeTexture9(IDirect3DCubeTexture9Vtbl): IDirect3DBaseTexture9(IDirect3DBaseTexture9Vtbl) { |
| fn GetLevelDesc(&mut self, Level: ::UINT, pDesc: *mut ::D3DSURFACE_DESC) -> ::HRESULT, |
| fn GetCubeMapSurface( |
| &mut self, FaceType: ::D3DCUBEMAP_FACES, Level: ::UINT, |
| ppCubeMapSurface: *mut *mut IDirect3DSurface9 |
| ) -> ::HRESULT, |
| fn LockRect( |
| &mut self, FaceType: ::D3DCUBEMAP_FACES, Level: ::UINT, pLockedRect: *mut ::D3DLOCKED_RECT, |
| pRect: *const ::RECT, Flags: ::DWORD |
| ) -> ::HRESULT, |
| fn UnlockRect(&mut self, FaceType: ::D3DCUBEMAP_FACES, Level: ::UINT) -> ::HRESULT, |
| fn AddDirtyRect( |
| &mut self, FaceType: ::D3DCUBEMAP_FACES, pDirtyRect: *const ::RECT |
| ) -> ::HRESULT |
| } |
| ); |
| pub type LPDIRECT3DCUBETEXTURE9 = *mut IDirect3DCubeTexture9; |
| pub type PDIRECT3DCUBETEXTURE9 = *mut IDirect3DCubeTexture9; |
| RIDL!( |
| interface IDirect3DVertexBuffer9(IDirect3DVertexBuffer9Vtbl): IDirect3DResource9(IDirect3DResource9Vtbl) { |
| fn Lock( |
| &mut self, OffsetToLock: ::UINT, SizeToLock: ::UINT, ppbData: *mut *mut ::VOID, |
| Flags: ::DWORD |
| ) -> ::HRESULT, |
| fn Unlock(&mut self) -> ::HRESULT, |
| fn GetDesc(&mut self, pDesc: *mut ::D3DVERTEXBUFFER_DESC) -> ::HRESULT |
| } |
| ); |
| pub type LPDIRECT3DVERTEXBUFFER9 = *mut IDirect3DVertexBuffer9; |
| pub type PDIRECT3DVERTEXBUFFER9 = *mut IDirect3DVertexBuffer9; |
| RIDL!( |
| interface IDirect3DIndexBuffer9(IDirect3DIndexBuffer9Vtbl): IDirect3DResource9(IDirect3DResource9Vtbl) { |
| fn Lock( |
| &mut self, OffsetToLock: ::UINT, SizeToLock: ::UINT, ppbData: *mut *mut ::VOID, |
| Flags: ::DWORD |
| ) -> ::HRESULT, |
| fn Unlock(&mut self) -> ::HRESULT, |
| fn GetDesc(&mut self, pDesc: *mut ::D3DINDEXBUFFER_DESC) -> ::HRESULT |
| } |
| ); |
| pub type LPDIRECT3DINDEXBUFFER9 = *mut IDirect3DIndexBuffer9; |
| pub type PDIRECT3DINDEXBUFFER9 = *mut IDirect3DIndexBuffer9; |
| RIDL!( |
| interface IDirect3DSurface9(IDirect3DSurface9Vtbl): IDirect3DResource9(IDirect3DResource9Vtbl) { |
| fn GetContainer(&mut self, riid: *const ::IID, ppContainer: *mut *mut ::VOID) -> ::HRESULT, |
| fn GetDesc(&mut self, pDesc: *mut ::D3DSURFACE_DESC) -> ::HRESULT, |
| fn LockRect( |
| &mut self, pLockedRect: *mut ::D3DLOCKED_RECT, pRect: *const ::RECT, Flags: ::DWORD |
| ) -> ::HRESULT, |
| fn UnlockRect(&mut self) -> ::HRESULT, |
| fn GetDC(&mut self, phdc: *mut ::HDC) -> ::HRESULT, |
| fn ReleaseDC(&mut self, hdc: ::HDC) -> ::HRESULT |
| } |
| ); |
| pub type LPDIRECT3DSURFACE9 = *mut IDirect3DSurface9; |
| pub type PDIRECT3DSURFACE9 = *mut IDirect3DSurface9; |
| RIDL!( |
| interface IDirect3DVolume9(IDirect3DVolume9Vtbl): IUnknown(IUnknownVtbl) { |
| fn GetDevice(&mut self, ppDevice: *mut *mut IDirect3DDevice9) -> ::HRESULT, |
| fn SetPrivateData( |
| &mut self, refguid: *const ::GUID, pData: *const ::VOID, SizeOfData: ::DWORD, |
| Flags: ::DWORD |
| ) -> ::HRESULT, |
| fn GetPrivateData( |
| &mut self, refguid: *const ::GUID, pData: *mut ::VOID, pSizeOfData: *mut ::DWORD |
| ) -> ::HRESULT, |
| fn FreePrivateData(&mut self, refguid: *const ::GUID) -> ::HRESULT, |
| fn GetContainer(&mut self, riid: *const ::IID, ppContainer: *mut *mut ::VOID) -> ::HRESULT, |
| fn GetDesc(&mut self, pDesc: *mut ::D3DVOLUME_DESC) -> ::HRESULT, |
| fn LockBox( |
| &mut self, pLockedVolume: *mut ::D3DLOCKED_BOX, pBox: *const ::D3DBOX, Flags: ::DWORD |
| ) -> ::HRESULT, |
| fn UnlockBox(&mut self) -> ::HRESULT |
| } |
| ); |
| pub type LPDIRECT3DVOLUME9 = *mut IDirect3DVolume9; |
| pub type PDIRECT3DVOLUME9 = *mut IDirect3DVolume9; |
| RIDL!( |
| interface IDirect3DQuery9(IDirect3DQuery9Vtbl): IUnknown(IUnknownVtbl) { |
| fn GetDevice(&mut self, ppDevice: *mut *mut IDirect3DDevice9) -> ::HRESULT, |
| fn GetType(&mut self) -> ::D3DRESOURCETYPE, |
| fn GetDataSize(&mut self) -> ::DWORD, |
| fn Issue(&mut self, dwIssueFlags: ::DWORD) -> ::HRESULT, |
| fn GetData( |
| &mut self, 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; |
| RIDL!( |
| interface IDirect3D9Ex(IDirect3D9ExVtbl): IDirect3D9(IDirect3D9Vtbl) { |
| fn GetAdapterModeCountEx( |
| &mut self, Adapter: ::UINT, pFilter: *const ::D3DDISPLAYMODEFILTER |
| ) -> ::UINT, |
| fn EnumAdapterModesEx( |
| &mut self, Adapter: ::UINT, pFilter: *const ::D3DDISPLAYMODEFILTER, Mode: ::UINT, |
| pMode: *mut ::D3DDISPLAYMODEEX |
| ) -> ::HRESULT, |
| fn GetAdapterDisplayModeEx( |
| &mut self, Adapter: ::UINT, pMode: *mut ::D3DDISPLAYMODEEX, |
| pRotation: *mut ::D3DDISPLAYROTATION |
| ) -> ::HRESULT, |
| fn CreateDeviceEx( |
| &mut self, Adapter: ::UINT, DeviceType: ::D3DDEVTYPE, hFocusWindow: ::HWND, |
| BehaviorFlags: ::DWORD, pPresentationParameters: *mut ::D3DPRESENT_PARAMETERS, |
| pFullscreenDisplayMode: *mut ::D3DDISPLAYMODEEX, |
| ppReturnedDeviceInterface: *mut *mut IDirect3DDevice9Ex |
| ) -> ::HRESULT, |
| fn GetAdapterLUID(&mut self, Adapter: ::UINT, pLUID: *mut ::LUID) -> ::HRESULT |
| } |
| ); |
| pub type LPDIRECT3D9EX = *mut IDirect3D9Ex; |
| pub type PDIRECT3D9EX = *mut IDirect3D9Ex; |
| RIDL!( |
| interface IDirect3DDevice9Ex(IDirect3DDevice9ExVtbl): IDirect3DDevice9(IDirect3DDevice9Vtbl) { |
| fn SetConvolutionMonoKernel( |
| &mut self, width: ::UINT, height: ::UINT, rows: *mut ::FLOAT, columns: *mut ::FLOAT |
| ) -> ::HRESULT, |
| fn ComposeRects( |
| &mut self, pSrc: *mut IDirect3DSurface9, pDst: *mut IDirect3DSurface9, |
| pSrcRectDescs: *mut IDirect3DVertexBuffer9, NumRects: ::UINT, |
| pDstRectDescs: *mut IDirect3DVertexBuffer9, Operation: ::D3DCOMPOSERECTSOP, Xoffset: ::INT, |
| Yoffset: ::INT |
| ) -> ::HRESULT, |
| fn PresentEx( |
| &mut self, pSourceRect: *const ::RECT, pDestRect: *const ::RECT, |
| hDestWindowOverride: ::HWND, pDirtyRegion: *const ::RGNDATA, dwFlags: ::DWORD |
| ) -> ::HRESULT, |
| fn GetGPUThreadPriority(&mut self, pPriority: *mut ::INT) -> ::HRESULT, |
| fn SetGPUThreadPriority(&mut self, Priority: ::INT) -> ::HRESULT, |
| fn WaitForVBlank(&mut self, iSwapChain: ::UINT) -> ::HRESULT, |
| fn CheckResourceResidency( |
| &mut self, pResourceArray: *mut *mut IDirect3DResource9, NumResources: ::UINT32 |
| ) -> ::HRESULT, |
| fn SetMaximumFrameLatency(&mut self, MaxLatency: ::UINT) -> ::HRESULT, |
| fn GetMaximumFrameLatency(&mut self, pMaxLatency: *mut ::UINT) -> ::HRESULT, |
| fn CheckDeviceState(&mut self, hDestinationWindow: ::HWND) -> ::HRESULT, |
| fn CreateRenderTargetEx( |
| &mut self, 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( |
| &mut self, Width: ::UINT, Height: ::UINT, Format: ::D3DFORMAT, Pool: ::D3DPOOL, |
| ppSurface: *mut *mut IDirect3DSurface9, pSharedHandle: *mut ::HANDLE, Usage: ::DWORD |
| ) -> ::HRESULT, |
| fn CreateDepthStencilSurfaceEx( |
| &mut self, 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( |
| &mut self, pPresentationParameters: *mut ::D3DPRESENT_PARAMETERS, |
| pFullscreenDisplayMode: *mut ::D3DDISPLAYMODEEX |
| ) -> ::HRESULT, |
| fn GetDisplayModeEx( |
| &mut self, iSwapChain: ::UINT, pMode: *mut ::D3DDISPLAYMODEEX, |
| pRotation: *mut ::D3DDISPLAYROTATION |
| ) -> ::HRESULT |
| } |
| ); |
| pub type LPDIRECT3DDEVICE9EX = *mut IDirect3DDevice9Ex; |
| pub type PDIRECT3DDEVICE9EX = *mut IDirect3DDevice9Ex; |
| RIDL!( |
| interface IDirect3DSwapChain9Ex(IDirect3DSwapChain9ExVtbl): IDirect3DSwapChain9(IDirect3DSwapChain9Vtbl) { |
| fn GetLastPresentCount(&mut self, pLastPresentCount: *mut ::UINT) -> ::HRESULT, |
| fn GetPresentStats(&mut self, pPresentationStatistics: *mut ::D3DPRESENTSTATS) -> ::HRESULT, |
| fn GetDisplayModeEx( |
| &mut self, pMode: *mut ::D3DDISPLAYMODEEX, pRotation: *mut ::D3DDISPLAYROTATION |
| ) -> ::HRESULT |
| } |
| ); |
| pub type LPDIRECT3DSWAPCHAIN9EX = *mut IDirect3DSwapChain9Ex; |
| pub type PDIRECT3DSWAPCHAIN9EX = *mut IDirect3DSwapChain9Ex; |
| RIDL!( |
| interface IDirect3D9ExOverlayExtension(IDirect3D9ExOverlayExtensionVtbl): IUnknown(IUnknownVtbl) { |
| fn CheckDeviceOverlayType( |
| &mut self, 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!( |
| interface IDirect3DDevice9Video(IDirect3DDevice9VideoVtbl): IUnknown(IUnknownVtbl) { |
| fn GetContentProtectionCaps( |
| &mut self, pCryptoType: *const ::GUID, pDecodeProfile: *const ::GUID, |
| pCaps: *mut ::D3DCONTENTPROTECTIONCAPS |
| ) -> ::HRESULT, |
| fn CreateAuthenticatedChannel( |
| &mut self, ChannelType: ::D3DAUTHENTICATEDCHANNELTYPE, |
| ppAuthenticatedChannel: *mut *mut IDirect3DAuthenticatedChannel9, |
| pChannelHandle: *mut ::HANDLE |
| ) -> ::HRESULT, |
| fn CreateCryptoSession( |
| &mut self, 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!( |
| interface IDirect3DAuthenticatedChannel9(IDirect3DAuthenticatedChannel9Vtbl): IUnknown(IUnknownVtbl) { |
| fn GetCertificateSize(&mut self, pCertificateSize: *mut ::UINT) -> ::HRESULT, |
| fn GetCertificate(&mut self, CertifacteSize: ::UINT, ppCertificate: *mut ::BYTE) -> ::HRESULT, |
| fn NegotiateKeyExchange(&mut self, DataSize: ::UINT, pData: *mut ::VOID) -> ::HRESULT, |
| fn Query( |
| &mut self, InputSize: ::UINT, pInput: *const ::VOID, OutputSize: ::UINT, |
| pOutput: *mut ::VOID |
| ) -> ::HRESULT, |
| fn Configure( |
| &mut self, InputSize: ::UINT, pInput: *const ::VOID, |
| pOutput: *mut ::D3DAUTHENTICATEDCHANNEL_CONFIGURE_OUTPUT |
| ) -> ::HRESULT |
| } |
| ); |
| pub type LPDIRECT3DAUTHENTICATEDCHANNEL9 = *mut IDirect3DAuthenticatedChannel9; |
| pub type PDIRECT3DAUTHENTICATEDCHANNEL9 = *mut IDirect3DAuthenticatedChannel9; |
| RIDL!( |
| interface IDirect3DCryptoSession9(IDirect3DCryptoSession9Vtbl): IUnknown(IUnknownVtbl) { |
| fn GetCertificateSize(&mut self, pCertificateSize: *mut ::UINT) -> ::HRESULT, |
| fn GetCertificate(&mut self, CertifacteSize: ::UINT, ppCertificate: *mut ::BYTE) -> ::HRESULT, |
| fn NegotiateKeyExchange(&mut self, DataSize: ::UINT, pData: *mut ::VOID) -> ::HRESULT, |
| fn EncryptionBlt( |
| &mut self, pSrcSurface: *mut IDirect3DSurface9, pDstSurface: *mut IDirect3DSurface9, |
| DstSurfaceSize: ::UINT, pIV: *mut ::VOID |
| ) -> ::HRESULT, |
| fn DecryptionBlt( |
| &mut self, pSrcSurface: *mut IDirect3DSurface9, pDstSurface: *mut IDirect3DSurface9, |
| SrcSurfaceSize: ::UINT, pEncryptedBlockInfo: *mut ::D3DENCRYPTED_BLOCK_INFO, |
| pContentKey: *mut ::VOID, pIV: *mut ::VOID |
| ) -> ::HRESULT, |
| fn GetSurfacePitch( |
| &mut self, pSrcSurface: *mut IDirect3DSurface9, pSurfacePitch: *mut ::UINT |
| ) -> ::HRESULT, |
| fn StartSessionKeyRefresh( |
| &mut self, pRandomNumber: *mut ::VOID, RandomNumberSize: ::UINT |
| ) -> ::HRESULT, |
| fn FinishSessionKeyRefresh(&mut self) -> ::HRESULT, |
| fn GetEncryptionBltKey(&mut self, pReadbackKey: *mut ::VOID, KeySize: ::UINT) -> ::HRESULT |
| } |
| ); |
| pub type LPDIRECT3DCRYPTOSESSION9 = *mut IDirect3DCryptoSession9; |
| pub type PDIRECT3DCRYPTOSESSION9 = *mut IDirect3DCryptoSession9; |
