1 // Licensed under the Apache License, Version 2.0
2 // <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
3 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
4 // All files in the project carrying such notice may not be copied, modified, or distributed
5 // except according to those terms.
6 //! Direct3D include file
7 use shared::basetsd::UINT32;
8 use shared::d3d9caps::{D3DCAPS9, D3DCONTENTPROTECTIONCAPS, D3DOVERLAYCAPS};
9 use shared::d3d9types::{
10     D3DADAPTER_IDENTIFIER9, D3DAUTHENTICATEDCHANNELTYPE, D3DAUTHENTICATEDCHANNEL_CONFIGURE_OUTPUT,
11     D3DBACKBUFFER_TYPE, D3DBOX, D3DCLIPSTATUS9, D3DCOLOR, D3DCOMPOSERECTSOP, D3DCUBEMAP_FACES,
12     D3DDEVICE_CREATION_PARAMETERS, D3DDEVTYPE, D3DDISPLAYMODE, D3DDISPLAYMODEEX,
13     D3DDISPLAYMODEFILTER, D3DDISPLAYROTATION, D3DENCRYPTED_BLOCK_INFO, D3DFORMAT, D3DGAMMARAMP,
14     D3DINDEXBUFFER_DESC, D3DLIGHT9, D3DLOCKED_BOX, D3DLOCKED_RECT, D3DMATERIAL9, D3DMATRIX,
15     D3DMULTISAMPLE_TYPE, D3DPOOL, D3DPRESENTSTATS, D3DPRESENT_PARAMETERS, D3DPRIMITIVETYPE,
16     D3DQUERYTYPE, D3DRASTER_STATUS, D3DRECT, D3DRECTPATCH_INFO, D3DRENDERSTATETYPE,
17     D3DRESOURCETYPE, D3DSAMPLERSTATETYPE, D3DSTATEBLOCKTYPE, D3DSURFACE_DESC, D3DTEXTUREFILTERTYPE,
18     D3DTEXTURESTAGESTATETYPE, D3DTRANSFORMSTATETYPE, D3DTRIPATCH_INFO, D3DVERTEXBUFFER_DESC,
19     D3DVERTEXELEMENT9, D3DVIEWPORT9, D3DVOLUME_DESC,
20 };
21 use shared::guiddef::{GUID, IID};
22 use shared::minwindef::{BOOL, BYTE, DWORD, FLOAT, INT, UINT};
23 use shared::windef::{HDC, HMONITOR, HWND, POINT, RECT};
24 use um::unknwnbase::{IUnknown, IUnknownVtbl};
25 use um::wingdi::{PALETTEENTRY, RGNDATA};
26 use um::winnt::{HANDLE, HRESULT, LPCWSTR, LUID, VOID};
27 pub const D3D_SDK_VERSION: DWORD = 32;
28 pub const D3D9b_SDK_VERSION: DWORD = 31;
29 DEFINE_GUID!{IID_IDirect3D9,
30     0x81bdcbca, 0x64d4, 0x426d, 0xae, 0x8d, 0xad, 0x01, 0x47, 0xf4, 0x27, 0x5c}
31 DEFINE_GUID!{IID_IDirect3DDevice9,
32     0xd0223b96, 0xbf7a, 0x43fd, 0x92, 0xbd, 0xa4, 0x3b, 0x0d, 0x82, 0xb9, 0xeb}
33 DEFINE_GUID!{IID_IDirect3DResource9,
34     0x05eec05d, 0x8f7d, 0x4362, 0xb9, 0x99, 0xd1, 0xba, 0xf3, 0x57, 0xc7, 0x04}
35 DEFINE_GUID!{IID_IDirect3DBaseTexture9,
36     0x580ca87e, 0x1d3c, 0x4d54, 0x99, 0x1d, 0xb7, 0xd3, 0xe3, 0xc2, 0x98, 0xce}
37 DEFINE_GUID!{IID_IDirect3DTexture9,
38     0x85c31227, 0x3de5, 0x4f00, 0x9b, 0x3a, 0xf1, 0x1a, 0xc3, 0x8c, 0x18, 0xb5}
39 DEFINE_GUID!{IID_IDirect3DCubeTexture9,
40     0xfff32f81, 0xd953, 0x473a, 0x92, 0x23, 0x93, 0xd6, 0x52, 0xab, 0xa9, 0x3f}
41 DEFINE_GUID!{IID_IDirect3DVolumeTexture9,
42     0x2518526c, 0xe789, 0x4111, 0xa7, 0xb9, 0x47, 0xef, 0x32, 0x8d, 0x13, 0xe6}
43 DEFINE_GUID!{IID_IDirect3DVertexBuffer9,
44     0xb64bb1b5, 0xfd70, 0x4df6, 0xbf, 0x91, 0x19, 0xd0, 0xa1, 0x24, 0x55, 0xe3}
45 DEFINE_GUID!{IID_IDirect3DIndexBuffer9,
46     0x7c9dd65e, 0xd3f7, 0x4529, 0xac, 0xee, 0x78, 0x58, 0x30, 0xac, 0xde, 0x35}
47 DEFINE_GUID!{IID_IDirect3DSurface9,
48     0x0cfbaf3a, 0x9ff6, 0x429a, 0x99, 0xb3, 0xa2, 0x79, 0x6a, 0xf8, 0xb8, 0x9b}
49 DEFINE_GUID!{IID_IDirect3DVolume9,
50     0x24f416e6, 0x1f67, 0x4aa7, 0xb8, 0x8e, 0xd3, 0x3f, 0x6f, 0x31, 0x28, 0xa1}
51 DEFINE_GUID!{IID_IDirect3DSwapChain9,
52     0x794950f2, 0xadfc, 0x458a, 0x90, 0x5e, 0x10, 0xa1, 0x0b, 0x0b, 0x50, 0x3b}
53 DEFINE_GUID!{IID_IDirect3DVertexDeclaration9,
54     0xdd13c59c, 0x36fa, 0x4098, 0xa8, 0xfb, 0xc7, 0xed, 0x39, 0xdc, 0x85, 0x46}
55 DEFINE_GUID!{IID_IDirect3DVertexShader9,
56     0xefc5557e, 0x6265, 0x4613, 0x8a, 0x94, 0x43, 0x85, 0x78, 0x89, 0xeb, 0x36}
57 DEFINE_GUID!{IID_IDirect3DPixelShader9,
58     0x6d3bdbdc, 0x5b02, 0x4415, 0xb8, 0x52, 0xce, 0x5e, 0x8b, 0xcc, 0xb2, 0x89}
59 DEFINE_GUID!{IID_IDirect3DStateBlock9,
60     0xb07c4fe5, 0x310d, 0x4ba8, 0xa2, 0x3c, 0x4f, 0x0f, 0x20, 0x6f, 0x21, 0x8b}
61 DEFINE_GUID!{IID_IDirect3DQuery9,
62     0xd9771460, 0xa695, 0x4f26, 0xbb, 0xd3, 0x27, 0xb8, 0x40, 0xb5, 0x41, 0xcc}
63 DEFINE_GUID!{IID_HelperName,
64     0xe4a36723, 0xfdfe, 0x4b22, 0xb1, 0x46, 0x3c, 0x04, 0xc0, 0x7f, 0x4c, 0xc8}
65 DEFINE_GUID!{IID_IDirect3D9Ex,
66     0x02177241, 0x69fc, 0x400c, 0x8f, 0xf1, 0x93, 0xa4, 0x4d, 0xf6, 0x86, 0x1d}
67 DEFINE_GUID!{IID_IDirect3DDevice9Ex,
68     0xb18b10ce, 0x2649, 0x405a, 0x87, 0x0f, 0x95, 0xf7, 0x77, 0xd4, 0x31, 0x3a}
69 DEFINE_GUID!{IID_IDirect3DSwapChain9Ex,
70     0x91886caf, 0x1c3d, 0x4d2e, 0xa0, 0xab, 0x3e, 0x4c, 0x7d, 0x8d, 0x33, 0x03}
71 DEFINE_GUID!{IID_IDirect3D9ExOverlayExtension,
72     0x187aeb13, 0xaaf5, 0x4c59, 0x87, 0x6d, 0xe0, 0x59, 0x08, 0x8c, 0x0d, 0xf8}
73 DEFINE_GUID!{IID_IDirect3DDevice9Video,
74     0x26dc4561, 0xa1ee, 0x4ae7, 0x96, 0xda, 0x11, 0x8a, 0x36, 0xc0, 0xec, 0x95}
75 DEFINE_GUID!{IID_IDirect3DAuthenticatedChannel9,
76     0xff24beee, 0xda21, 0x4beb, 0x98, 0xb5, 0xd2, 0xf8, 0x99, 0xf9, 0x8a, 0xf9}
77 DEFINE_GUID!{IID_IDirect3DCryptoSession9,
78     0xfa0ab799, 0x7a9c, 0x48ca, 0x8c, 0x5b, 0x23, 0x7e, 0x71, 0xa5, 0x44, 0x34}
79 extern "system" {
Direct3DCreate9( SDKVersion: UINT, ) -> *mut IDirect3D980     pub fn Direct3DCreate9(
81         SDKVersion: UINT,
82     ) -> *mut IDirect3D9;
D3DPERF_BeginEvent( col: D3DCOLOR, wszName: LPCWSTR, ) -> INT83     pub fn D3DPERF_BeginEvent(
84         col: D3DCOLOR,
85         wszName: LPCWSTR,
86     ) -> INT;
D3DPERF_EndEvent() -> INT87     pub fn D3DPERF_EndEvent() -> INT;
D3DPERF_SetMarker( col: D3DCOLOR, wszName: LPCWSTR, ) -> ()88     pub fn D3DPERF_SetMarker(
89         col: D3DCOLOR,
90         wszName: LPCWSTR,
91     ) -> ();
D3DPERF_SetRegion( col: D3DCOLOR, wszName: LPCWSTR, ) -> ()92     pub fn D3DPERF_SetRegion(
93         col: D3DCOLOR,
94         wszName: LPCWSTR,
95     ) -> ();
D3DPERF_QueryRepeatFrame() -> BOOL96     pub fn D3DPERF_QueryRepeatFrame() -> BOOL;
D3DPERF_SetOptions( dwOptions: DWORD, ) -> ()97     pub fn D3DPERF_SetOptions(
98         dwOptions: DWORD,
99     ) -> ();
D3DPERF_GetStatus() -> DWORD100     pub fn D3DPERF_GetStatus() -> DWORD;
101 }
102 RIDL!{#[uuid(0x81bdcbca, 0x64d4, 0x426d, 0xae, 0x8d, 0xad, 0x1, 0x47, 0xf4, 0x27, 0x5c)]
103 interface IDirect3D9(IDirect3D9Vtbl): IUnknown(IUnknownVtbl) {
104     fn RegisterSoftwareDevice(
105         pInitializeFunction: *mut VOID,
106     ) -> HRESULT,
107     fn GetAdapterCount() -> UINT,
108     fn GetAdapterIdentifier(
109         Adapter: UINT,
110         Flags: DWORD,
111         pIdentifier: *mut D3DADAPTER_IDENTIFIER9,
112     ) -> HRESULT,
113     fn GetAdapterModeCount(
114         Adapter: UINT,
115         Format: D3DFORMAT,
116     ) -> UINT,
117     fn EnumAdapterModes(
118         Adapter: UINT,
119         Format: D3DFORMAT,
120         Mode: UINT,
121         pMode: *mut D3DDISPLAYMODE,
122     ) -> HRESULT,
123     fn GetAdapterDisplayMode(
124         Adapter: UINT,
125         pMode: *mut D3DDISPLAYMODE,
126     ) -> HRESULT,
127     fn CheckDeviceType(
128         Adapter: UINT,
129         DevType: D3DDEVTYPE,
130         AdapterFormat: D3DFORMAT,
131         BackBufferFormat: D3DFORMAT,
132         bWindowed: BOOL,
133     ) -> HRESULT,
134     fn CheckDeviceFormat(
135         Adapter: UINT,
136         DeviceType: D3DDEVTYPE,
137         AdapterFormat: D3DFORMAT,
138         Usage: DWORD,
139         RType: D3DRESOURCETYPE,
140         CheckFormat: D3DFORMAT,
141     ) -> HRESULT,
142     fn CheckDeviceMultiSampleType(
143         Adapter: UINT,
144         DeviceType: D3DDEVTYPE,
145         SurfaceFormat: D3DFORMAT,
146         Windowed: BOOL,
147         MultiSampleType: D3DMULTISAMPLE_TYPE,
148         pQualityLevels: *mut DWORD,
149     ) -> HRESULT,
150     fn CheckDepthStencilMatch(
151         Adapter: UINT,
152         DeviceType: D3DDEVTYPE,
153         AdapterFormat: D3DFORMAT,
154         RenderTargetFormat: D3DFORMAT,
155         DepthStencilFormat: D3DFORMAT,
156     ) -> HRESULT,
157     fn CheckDeviceFormatConversion(
158         Adapter: UINT,
159         DeviceType: D3DDEVTYPE,
160         SourceFormat: D3DFORMAT,
161         TargetFormat: D3DFORMAT,
162     ) -> HRESULT,
163     fn GetDeviceCaps(
164         Adapter: UINT,
165         DeviceType: D3DDEVTYPE,
166         pCaps: *mut D3DCAPS9,
167     ) -> HRESULT,
168     fn GetAdapterMonitor(
169         Adapter: UINT,
170     ) -> HMONITOR,
171     fn CreateDevice(
172         Adapter: UINT,
173         DeviceType: D3DDEVTYPE,
174         hFocusWindow: HWND,
175         BehaviorFlags: DWORD,
176         pPresentationParameters: *mut D3DPRESENT_PARAMETERS,
177         ppReturnedDeviceInterface: *mut *mut IDirect3DDevice9,
178     ) -> HRESULT,
179 }}
180 pub type LPDIRECT3D9 = *mut IDirect3D9;
181 pub type PDIRECT3D9 = *mut IDirect3D9;
182 RIDL!{#[uuid(0xd0223b96, 0xbf7a, 0x43fd, 0x92, 0xbd, 0xa4, 0x3b, 0xd, 0x82, 0xb9, 0xeb)]
183 interface IDirect3DDevice9(IDirect3DDevice9Vtbl): IUnknown(IUnknownVtbl) {
184     fn TestCooperativeLevel() -> HRESULT,
185     fn GetAvailableTextureMem() -> UINT,
186     fn EvictManagedResources() -> HRESULT,
187     fn GetDirect3D(
188         ppD3D9: *mut *mut IDirect3D9,
189     ) -> HRESULT,
190     fn GetDeviceCaps(
191         pCaps: *mut D3DCAPS9,
192     ) -> HRESULT,
193     fn GetDisplayMode(
194         iSwapChain: UINT,
195         pMode: *mut D3DDISPLAYMODE,
196     ) -> HRESULT,
197     fn GetCreationParameters(
198         pParameters: *mut D3DDEVICE_CREATION_PARAMETERS,
199     ) -> HRESULT,
200     fn SetCursorProperties(
201         XHotSpot: UINT,
202         YHotSpot: UINT,
203         pCursorBitmap: *mut IDirect3DSurface9,
204     ) -> HRESULT,
205     fn SetCursorPosition(
206         X: INT,
207         Y: INT,
208         Flags: DWORD,
209     ) -> (),
210     fn ShowCursor(
211         bShow: BOOL,
212     ) -> BOOL,
213     fn CreateAdditionalSwapChain(
214         pPresentationParameters: *mut D3DPRESENT_PARAMETERS,
215         pSwapChain: *mut *mut IDirect3DSwapChain9,
216     ) -> HRESULT,
217     fn GetSwapChain(
218         iSwapChain: UINT,
219         pSwapChain: *mut *mut IDirect3DSwapChain9,
220     ) -> HRESULT,
221     fn GetNumberOfSwapChains() -> UINT,
222     fn Reset(
223         pPresentationParameters: *mut D3DPRESENT_PARAMETERS,
224     ) -> HRESULT,
225     fn Present(
226         pSourceRect: *const RECT,
227         pDestRect: *const RECT,
228         hDestWindowOverride: HWND,
229         pDirtyRegion: *const RGNDATA,
230     ) -> HRESULT,
231     fn GetBackBuffer(
232         iSwapChain: UINT,
233         iBackBuffer: UINT,
234         Type: D3DBACKBUFFER_TYPE,
235         ppBackBuffer: *mut *mut IDirect3DSurface9,
236     ) -> HRESULT,
237     fn GetRasterStatus(
238         iSwapChain: UINT,
239         pRasterStatus: *mut D3DRASTER_STATUS,
240     ) -> HRESULT,
241     fn SetDialogBoxMode(
242         bEnableDialogs: BOOL,
243     ) -> HRESULT,
244     fn SetGammaRamp(
245         iSwapChain: UINT,
246         Flags: DWORD,
247         pRamp: *const D3DGAMMARAMP,
248     ) -> (),
249     fn GetGammaRamp(
250         iSwapChain: UINT,
251         pRamp: *mut D3DGAMMARAMP,
252     ) -> (),
253     fn CreateTexture(
254         Width: UINT,
255         Height: UINT,
256         Levels: UINT,
257         Usage: DWORD,
258         Format: D3DFORMAT,
259         Pool: D3DPOOL,
260         ppTexture: *mut *mut IDirect3DTexture9,
261         pSharedHandle: *mut HANDLE,
262     ) -> HRESULT,
263     fn CreateVolumeTexture(
264         Width: UINT,
265         Height: UINT,
266         Depth: UINT,
267         Levels: UINT,
268         Usage: DWORD,
269         Format: D3DFORMAT,
270         Pool: D3DPOOL,
271         ppVolumeTexture: *mut *mut IDirect3DVolumeTexture9,
272         pSharedHandle: *mut HANDLE,
273     ) -> HRESULT,
274     fn CreateCubeTexture(
275         EdgeLength: UINT,
276         Levels: UINT,
277         Usage: DWORD,
278         Format: D3DFORMAT,
279         Pool: D3DPOOL,
280         ppCubeTexture: *mut *mut IDirect3DCubeTexture9,
281         pSharedHandle: *mut HANDLE,
282     ) -> HRESULT,
283     fn CreateVertexBuffer(
284         Length: UINT,
285         Usage: DWORD,
286         FVF: DWORD,
287         Pool: D3DPOOL,
288         ppVertexBuffer: *mut *mut IDirect3DVertexBuffer9,
289         pSharedHandle: *mut HANDLE,
290     ) -> HRESULT,
291     fn CreateIndexBuffer(
292         Length: UINT,
293         Usage: DWORD,
294         Format: D3DFORMAT,
295         Pool: D3DPOOL,
296         ppIndexBuffer: *mut *mut IDirect3DIndexBuffer9,
297         pSharedHandle: *mut HANDLE,
298     ) -> HRESULT,
299     fn CreateRenderTarget(
300         Width: UINT,
301         Height: UINT,
302         Format: D3DFORMAT,
303         MultiSample: D3DMULTISAMPLE_TYPE,
304         MultisampleQuality: DWORD,
305         Lockable: BOOL,
306         ppSurface: *mut *mut IDirect3DSurface9,
307         pSharedHandle: *mut HANDLE,
308     ) -> HRESULT,
309     fn CreateDepthStencilSurface(
310         Width: UINT,
311         Height: UINT,
312         Format: D3DFORMAT,
313         MultiSample: D3DMULTISAMPLE_TYPE,
314         MultisampleQuality: DWORD,
315         Discard: BOOL,
316         ppSurface: *mut *mut IDirect3DSurface9,
317         pSharedHandle: *mut HANDLE,
318     ) -> HRESULT,
319     fn UpdateSurface(
320         pSourceSurface: *mut IDirect3DSurface9,
321         pSourceRect: *const RECT,
322         pDestinationSurface: *mut IDirect3DSurface9,
323         pDestPoint: *const POINT,
324     ) -> HRESULT,
325     fn UpdateTexture(
326         pSourceTexture: *mut IDirect3DBaseTexture9,
327         pDestinationTexture: *mut IDirect3DBaseTexture9,
328     ) -> HRESULT,
329     fn GetRenderTargetData(
330         pRenderTarget: *mut IDirect3DSurface9,
331         pDestSurface: *mut IDirect3DSurface9,
332     ) -> HRESULT,
333     fn GetFrontBufferData(
334         iSwapChain: UINT,
335         pDestSurface: *mut IDirect3DSurface9,
336     ) -> HRESULT,
337     fn StretchRect(
338         pSourceSurface: *mut IDirect3DSurface9,
339         pSourceRect: *const RECT,
340         pDestSurface: *mut IDirect3DSurface9,
341         pDestRect: *const RECT,
342         Filter: D3DTEXTUREFILTERTYPE,
343     ) -> HRESULT,
344     fn ColorFill(
345         pSurface: *mut IDirect3DSurface9,
346         pRect: *const RECT,
347         color: D3DCOLOR,
348     ) -> HRESULT,
349     fn CreateOffscreenPlainSurface(
350         Width: UINT,
351         Height: UINT,
352         Format: D3DFORMAT,
353         Pool: D3DPOOL,
354         ppSurface: *mut *mut IDirect3DSurface9,
355         pSharedHandle: *mut HANDLE,
356     ) -> HRESULT,
357     fn SetRenderTarget(
358         RenderTargetIndex: DWORD,
359         pRenderTarget: *mut IDirect3DSurface9,
360     ) -> HRESULT,
361     fn GetRenderTarget(
362         RenderTargetIndex: DWORD,
363         ppRenderTarget: *mut *mut IDirect3DSurface9,
364     ) -> HRESULT,
365     fn SetDepthStencilSurface(
366         pNewZStencil: *mut IDirect3DSurface9,
367     ) -> HRESULT,
368     fn GetDepthStencilSurface(
369         ppZStencilSurface: *mut *mut IDirect3DSurface9,
370     ) -> HRESULT,
371     fn BeginScene() -> HRESULT,
372     fn EndScene() -> HRESULT,
373     fn Clear(
374         Count: DWORD,
375         pRects: *const D3DRECT,
376         Flags: DWORD,
377         Color: D3DCOLOR,
378         Z: FLOAT,
379         Stencil: DWORD,
380     ) -> HRESULT,
381     fn SetTransform(
382         State: D3DTRANSFORMSTATETYPE,
383         pMatrix: *const D3DMATRIX,
384     ) -> HRESULT,
385     fn GetTransform(
386         State: D3DTRANSFORMSTATETYPE,
387         pMatrix: *mut D3DMATRIX,
388     ) -> HRESULT,
389     fn MultiplyTransform(
390         arg1: D3DTRANSFORMSTATETYPE,
391         arg2: *const D3DMATRIX,
392     ) -> HRESULT,
393     fn SetViewport(
394         pViewport: *const D3DVIEWPORT9,
395     ) -> HRESULT,
396     fn GetViewport(
397         pViewport: *mut D3DVIEWPORT9,
398     ) -> HRESULT,
399     fn SetMaterial(
400         pMaterial: *const D3DMATERIAL9,
401     ) -> HRESULT,
402     fn GetMaterial(
403         pMaterial: *mut D3DMATERIAL9,
404     ) -> HRESULT,
405     fn SetLight(
406         Index: DWORD,
407         arg1: *const D3DLIGHT9,
408     ) -> HRESULT,
409     fn GetLight(
410         Index: DWORD,
411         arg1: *mut D3DLIGHT9,
412     ) -> HRESULT,
413     fn LightEnable(
414         Index: DWORD,
415         Enable: BOOL,
416     ) -> HRESULT,
417     fn GetLightEnable(
418         Index: DWORD,
419         pEnable: *mut BOOL,
420     ) -> HRESULT,
421     fn SetClipPlane(
422         Index: DWORD,
423         pPlane: *const FLOAT,
424     ) -> HRESULT,
425     fn GetClipPlane(
426         Index: DWORD,
427         pPlane: *mut FLOAT,
428     ) -> HRESULT,
429     fn SetRenderState(
430         State: D3DRENDERSTATETYPE,
431         Value: DWORD,
432     ) -> HRESULT,
433     fn GetRenderState(
434         State: D3DRENDERSTATETYPE,
435         pValue: *mut DWORD,
436     ) -> HRESULT,
437     fn CreateStateBlock(
438         Type: D3DSTATEBLOCKTYPE,
439         ppSB: *mut *mut IDirect3DStateBlock9,
440     ) -> HRESULT,
441     fn BeginStateBlock() -> HRESULT,
442     fn EndStateBlock(
443         ppSB: *mut *mut IDirect3DStateBlock9,
444     ) -> HRESULT,
445     fn SetClipStatus(
446         pClipStatus: *const D3DCLIPSTATUS9,
447     ) -> HRESULT,
448     fn GetClipStatus(
449         pClipStatus: *mut D3DCLIPSTATUS9,
450     ) -> HRESULT,
451     fn GetTexture(
452         Stage: DWORD,
453         ppTexture: *mut *mut IDirect3DBaseTexture9,
454     ) -> HRESULT,
455     fn SetTexture(
456         Stage: DWORD,
457         pTexture: *mut IDirect3DBaseTexture9,
458     ) -> HRESULT,
459     fn GetTextureStageState(
460         Stage: DWORD,
461         Type: D3DTEXTURESTAGESTATETYPE,
462         pValue: *mut DWORD,
463     ) -> HRESULT,
464     fn SetTextureStageState(
465         Stage: DWORD,
466         Type: D3DTEXTURESTAGESTATETYPE,
467         Value: DWORD,
468     ) -> HRESULT,
469     fn GetSamplerState(
470         Sampler: DWORD,
471         Type: D3DSAMPLERSTATETYPE,
472         pValue: *mut DWORD,
473     ) -> HRESULT,
474     fn SetSamplerState(
475         Sampler: DWORD,
476         Type: D3DSAMPLERSTATETYPE,
477         Value: DWORD,
478     ) -> HRESULT,
479     fn ValidateDevice(
480         pNumPasses: *mut DWORD,
481     ) -> HRESULT,
482     fn SetPaletteEntries(
483         PaletteNumber: UINT,
484         pEntries: *const PALETTEENTRY,
485     ) -> HRESULT,
486     fn GetPaletteEntries(
487         PaletteNumber: UINT,
488         pEntries: *mut PALETTEENTRY,
489     ) -> HRESULT,
490     fn SetCurrentTexturePalette(
491         PaletteNumber: UINT,
492     ) -> HRESULT,
493     fn GetCurrentTexturePalette(
494         PaletteNumber: *mut UINT,
495     ) -> HRESULT,
496     fn SetScissorRect(
497         pRect: *const RECT,
498     ) -> HRESULT,
499     fn GetScissorRect(
500         pRect: *mut RECT,
501     ) -> HRESULT,
502     fn SetSoftwareVertexProcessing(
503         bSoftware: BOOL,
504     ) -> HRESULT,
505     fn GetSoftwareVertexProcessing() -> BOOL,
506     fn SetNPatchMode(
507         nSegments: FLOAT,
508     ) -> HRESULT,
509     fn GetNPatchMode() -> FLOAT,
510     fn DrawPrimitive(
511         PrimitiveType: D3DPRIMITIVETYPE,
512         StartVertex: UINT,
513         PrimitiveCount: UINT,
514     ) -> HRESULT,
515     fn DrawIndexedPrimitive(
516         arg1: D3DPRIMITIVETYPE,
517         BaseVertexIndex: INT,
518         MinVertexIndex: UINT,
519         NumVertices: UINT,
520         startIndex: UINT,
521         primCount: UINT,
522     ) -> HRESULT,
523     fn DrawPrimitiveUP(
524         PrimitiveType: D3DPRIMITIVETYPE,
525         PrimitiveCount: UINT,
526         pVertexStreamZeroData: *const VOID,
527         VertexStreamZeroStride: UINT,
528     ) -> HRESULT,
529     fn DrawIndexedPrimitiveUP(
530         PrimitiveType: D3DPRIMITIVETYPE,
531         MinVertexIndex: UINT,
532         NumVertices: UINT,
533         PrimitiveCount: UINT,
534         pIndexData: *const VOID,
535         IndexDataFormat: D3DFORMAT,
536         pVertexStreamZeroData: *const VOID,
537         VertexStreamZeroStride: UINT,
538     ) -> HRESULT,
539     fn ProcessVertices(
540         SrcStartIndex: UINT,
541         DestIndex: UINT,
542         VertexCount: UINT,
543         pDestBuffer: *mut IDirect3DVertexBuffer9,
544         pVertexDecl: *mut IDirect3DVertexDeclaration9,
545         Flags: DWORD,
546     ) -> HRESULT,
547     fn CreateVertexDeclaration(
548         pVertexElements: *const D3DVERTEXELEMENT9,
549         ppDecl: *mut *mut IDirect3DVertexDeclaration9,
550     ) -> HRESULT,
551     fn SetVertexDeclaration(
552         pDecl: *mut IDirect3DVertexDeclaration9,
553     ) -> HRESULT,
554     fn GetVertexDeclaration(
555         ppDecl: *mut *mut IDirect3DVertexDeclaration9,
556     ) -> HRESULT,
557     fn SetFVF(
558         FVF: DWORD,
559     ) -> HRESULT,
560     fn GetFVF(
561         pFVF: *mut DWORD,
562     ) -> HRESULT,
563     fn CreateVertexShader(
564         pFunction: *const DWORD,
565         ppShader: *mut *mut IDirect3DVertexShader9,
566     ) -> HRESULT,
567     fn SetVertexShader(
568         pShader: *mut IDirect3DVertexShader9,
569     ) -> HRESULT,
570     fn GetVertexShader(
571         ppShader: *mut *mut IDirect3DVertexShader9,
572     ) -> HRESULT,
573     fn SetVertexShaderConstantF(
574         StartRegister: UINT,
575         pConstantData: *const FLOAT,
576         Vector4fCount: UINT,
577     ) -> HRESULT,
578     fn GetVertexShaderConstantF(
579         StartRegister: UINT,
580         pConstantData: *mut FLOAT,
581         Vector4fCount: UINT,
582     ) -> HRESULT,
583     fn SetVertexShaderConstantI(
584         StartRegister: UINT,
585         pConstantData: *const INT,
586         Vector4iCount: UINT,
587     ) -> HRESULT,
588     fn GetVertexShaderConstantI(
589         StartRegister: UINT,
590         pConstantData: *mut INT,
591         Vector4iCount: UINT,
592     ) -> HRESULT,
593     fn SetVertexShaderConstantB(
594         StartRegister: UINT,
595         pConstantData: *const BOOL,
596         BoolCount: UINT,
597     ) -> HRESULT,
598     fn GetVertexShaderConstantB(
599         StartRegister: UINT,
600         pConstantData: *mut BOOL,
601         BoolCount: UINT,
602     ) -> HRESULT,
603     fn SetStreamSource(
604         StreamNumber: UINT,
605         pStreamData: *mut IDirect3DVertexBuffer9,
606         OffsetInBytes: UINT,
607         Stride: UINT,
608     ) -> HRESULT,
609     fn GetStreamSource(
610         StreamNumber: UINT,
611         ppStreamData: *mut *mut IDirect3DVertexBuffer9,
612         pOffsetInBytes: *mut UINT,
613         pStride: *mut UINT,
614     ) -> HRESULT,
615     fn SetStreamSourceFreq(
616         StreamNumber: UINT,
617         Setting: UINT,
618     ) -> HRESULT,
619     fn GetStreamSourceFreq(
620         StreamNumber: UINT,
621         pSetting: *mut UINT,
622     ) -> HRESULT,
623     fn SetIndices(
624         pIndexData: *mut IDirect3DIndexBuffer9,
625     ) -> HRESULT,
626     fn GetIndices(
627         ppIndexData: *mut *mut IDirect3DIndexBuffer9,
628     ) -> HRESULT,
629     fn CreatePixelShader(
630         pFunction: *const DWORD,
631         ppShader: *mut *mut IDirect3DPixelShader9,
632     ) -> HRESULT,
633     fn SetPixelShader(
634         pShader: *mut IDirect3DPixelShader9,
635     ) -> HRESULT,
636     fn GetPixelShader(
637         ppShader: *mut *mut IDirect3DPixelShader9,
638     ) -> HRESULT,
639     fn SetPixelShaderConstantF(
640         StartRegister: UINT,
641         pConstantData: *const FLOAT,
642         Vector4fCount: UINT,
643     ) -> HRESULT,
644     fn GetPixelShaderConstantF(
645         StartRegister: UINT,
646         pConstantData: *mut FLOAT,
647         Vector4fCount: UINT,
648     ) -> HRESULT,
649     fn SetPixelShaderConstantI(
650         StartRegister: UINT,
651         pConstantData: *const INT,
652         Vector4iCount: UINT,
653     ) -> HRESULT,
654     fn GetPixelShaderConstantI(
655         StartRegister: UINT,
656         pConstantData: *mut INT,
657         Vector4iCount: UINT,
658     ) -> HRESULT,
659     fn SetPixelShaderConstantB(
660         StartRegister: UINT,
661         pConstantData: *const BOOL,
662         BoolCount: UINT,
663     ) -> HRESULT,
664     fn GetPixelShaderConstantB(
665         StartRegister: UINT,
666         pConstantData: *mut BOOL,
667         BoolCount: UINT,
668     ) -> HRESULT,
669     fn DrawRectPatch(
670         Handle: UINT,
671         pNumSegs: *const FLOAT,
672         pRectPatchInfo: *const D3DRECTPATCH_INFO,
673     ) -> HRESULT,
674     fn DrawTriPatch(
675         Handle: UINT,
676         pNumSegs: *const FLOAT,
677         pTriPatchInfo: *const D3DTRIPATCH_INFO,
678     ) -> HRESULT,
679     fn DeletePatch(
680         Handle: UINT,
681     ) -> HRESULT,
682     fn CreateQuery(
683         Type: D3DQUERYTYPE,
684         ppQuery: *mut *mut IDirect3DQuery9,
685     ) -> HRESULT,
686 }}
687 pub type LPDIRECT3DDEVICE9 = *mut IDirect3DDevice9;
688 pub type PDIRECT3DDEVICE9 = *mut IDirect3DDevice9;
689 RIDL!{#[uuid(0xb07c4fe5, 0x310d, 0x4ba8, 0xa2, 0x3c, 0x4f, 0xf, 0x20, 0x6f, 0x21, 0x8b)]
690 interface IDirect3DStateBlock9(IDirect3DStateBlock9Vtbl): IUnknown(IUnknownVtbl) {
691     fn GetDevice(
692         ppDevice: *mut *mut IDirect3DDevice9,
693     ) -> HRESULT,
694     fn Capture() -> HRESULT,
695     fn Apply() -> HRESULT,
696 }}
697 pub type LPDIRECT3DSTATEBLOCK9 = *mut IDirect3DStateBlock9;
698 pub type PDIRECT3DSTATEBLOCK9 = *mut IDirect3DStateBlock9;
699 RIDL!{#[uuid(0x794950f2, 0xadfc, 0x458a, 0x90, 0x5e, 0x10, 0xa1, 0xb, 0xb, 0x50, 0x3b)]
700 interface IDirect3DSwapChain9(IDirect3DSwapChain9Vtbl): IUnknown(IUnknownVtbl) {
701     fn Present(
702         pSourceRect: *const RECT,
703         pDestRect: *const RECT,
704         hDestWindowOverride: HWND,
705         pDirtyRegion: *const RGNDATA,
706         dwFlags: DWORD,
707     ) -> HRESULT,
708     fn GetFrontBufferData(
709         pDestSurface: *mut IDirect3DSurface9,
710     ) -> HRESULT,
711     fn GetBackBuffer(
712         iBackBuffer: UINT,
713         Type: D3DBACKBUFFER_TYPE,
714         ppBackBuffer: *mut *mut IDirect3DSurface9,
715     ) -> HRESULT,
716     fn GetRasterStatus(
717         pRasterStatus: *mut D3DRASTER_STATUS,
718     ) -> HRESULT,
719     fn GetDisplayMode(
720         pMode: *mut D3DDISPLAYMODE,
721     ) -> HRESULT,
722     fn GetDevice(
723         ppDevice: *mut *mut IDirect3DDevice9,
724     ) -> HRESULT,
725     fn GetPresentParameters(
726         pPresentationParameters: *mut D3DPRESENT_PARAMETERS,
727     ) -> HRESULT,
728 }}
729 pub type LPDIRECT3DSWAPCHAIN9 = *mut IDirect3DSwapChain9;
730 pub type PDIRECT3DSWAPCHAIN9 = *mut IDirect3DSwapChain9;
731 RIDL!{#[uuid(0x5eec05d, 0x8f7d, 0x4362, 0xb9, 0x99, 0xd1, 0xba, 0xf3, 0x57, 0xc7, 0x4)]
732 interface IDirect3DResource9(IDirect3DResource9Vtbl): IUnknown(IUnknownVtbl) {
733     fn GetDevice(
734         ppDevice: *mut *mut IDirect3DDevice9,
735     ) -> HRESULT,
736     fn SetPrivateData(
737         refguid: *const GUID,
738         pData: *const VOID,
739         SizeOfData: DWORD,
740         Flags: DWORD,
741     ) -> HRESULT,
742     fn GetPrivateData(
743         refguid: *const GUID,
744         pData: *mut VOID,
745         pSizeOfData: *mut DWORD,
746     ) -> HRESULT,
747     fn FreePrivateData(
748         refguid: *const GUID,
749     ) -> HRESULT,
750     fn SetPriority(
751         PriorityNew: DWORD,
752     ) -> DWORD,
753     fn GetPriority() -> DWORD,
754     fn PreLoad() -> (),
755     fn GetType() -> D3DRESOURCETYPE,
756 }}
757 pub type LPDIRECT3DRESOURCE9 = *mut IDirect3DResource9;
758 pub type PDIRECT3DRESOURCE9 = *mut IDirect3DResource9;
759 RIDL!{#[uuid(0xdd13c59c, 0x36fa, 0x4098, 0xa8, 0xfb, 0xc7, 0xed, 0x39, 0xdc, 0x85, 0x46)]
760 interface IDirect3DVertexDeclaration9(IDirect3DVertexDeclaration9Vtbl): IUnknown(IUnknownVtbl) {
761     fn GetDevice(
762         ppDevice: *mut *mut IDirect3DDevice9,
763     ) -> HRESULT,
764     fn GetDeclaration(
765         pElement: *mut D3DVERTEXELEMENT9,
766         pNumElements: *mut UINT,
767     ) -> HRESULT,
768 }}
769 pub type LPDIRECT3DVERTEXDECLARATION9 = *mut IDirect3DVertexDeclaration9;
770 pub type PDIRECT3DVERTEXDECLARATION9 = *mut IDirect3DVertexDeclaration9;
771 RIDL!{#[uuid(0xefc5557e, 0x6265, 0x4613, 0x8a, 0x94, 0x43, 0x85, 0x78, 0x89, 0xeb, 0x36)]
772 interface IDirect3DVertexShader9(IDirect3DVertexShader9Vtbl): IUnknown(IUnknownVtbl) {
773     fn GetDevice(
774         ppDevice: *mut *mut IDirect3DDevice9,
775     ) -> HRESULT,
776     fn GetFunction(
777         arg1: *mut VOID,
778         pSizeOfData: *mut UINT,
779     ) -> HRESULT,
780 }}
781 pub type LPDIRECT3DVERTEXSHADER9 = *mut IDirect3DVertexShader9;
782 pub type PDIRECT3DVERTEXSHADER9 = *mut IDirect3DVertexShader9;
783 RIDL!{#[uuid(0x6d3bdbdc, 0x5b02, 0x4415, 0xb8, 0x52, 0xce, 0x5e, 0x8b, 0xcc, 0xb2, 0x89)]
784 interface IDirect3DPixelShader9(IDirect3DPixelShader9Vtbl): IUnknown(IUnknownVtbl) {
785     fn GetDevice(
786         ppDevice: *mut *mut IDirect3DDevice9,
787     ) -> HRESULT,
788     fn GetFunction(
789         arg1: *mut VOID,
790         pSizeOfData: *mut UINT,
791     ) -> HRESULT,
792 }}
793 pub type LPDIRECT3DPIXELSHADER9 = *mut IDirect3DPixelShader9;
794 pub type PDIRECT3DPIXELSHADER9 = *mut IDirect3DPixelShader9;
795 RIDL!{#[uuid(0x580ca87e, 0x1d3c, 0x4d54, 0x99, 0x1d, 0xb7, 0xd3, 0xe3, 0xc2, 0x98, 0xce)]
796 interface IDirect3DBaseTexture9(IDirect3DBaseTexture9Vtbl):
797     IDirect3DResource9(IDirect3DResource9Vtbl) {
798     fn SetLOD(
799         LODNew: DWORD,
800     ) -> DWORD,
801     fn GetLOD() -> DWORD,
802     fn GetLevelCount() -> DWORD,
803     fn SetAutoGenFilterType(
804         FilterType: D3DTEXTUREFILTERTYPE,
805     ) -> HRESULT,
806     fn GetAutoGenFilterType() -> D3DTEXTUREFILTERTYPE,
807     fn GenerateMipSubLevels() -> (),
808 }}
809 pub type LPDIRECT3DBASETEXTURE9 = *mut IDirect3DBaseTexture9;
810 pub type PDIRECT3DBASETEXTURE9 = *mut IDirect3DBaseTexture9;
811 RIDL!{#[uuid(0x85c31227, 0x3de5, 0x4f00, 0x9b, 0x3a, 0xf1, 0x1a, 0xc3, 0x8c, 0x18, 0xb5)]
812 interface IDirect3DTexture9(IDirect3DTexture9Vtbl):
813     IDirect3DBaseTexture9(IDirect3DBaseTexture9Vtbl) {
814     fn GetLevelDesc(
815         Level: UINT,
816         pDesc: *mut D3DSURFACE_DESC,
817     ) -> HRESULT,
818     fn GetSurfaceLevel(
819         Level: UINT,
820         ppSurfaceLevel: *mut *mut IDirect3DSurface9,
821     ) -> HRESULT,
822     fn LockRect(
823         Level: UINT,
824         pLockedRect: *mut D3DLOCKED_RECT,
825         pRect: *const RECT,
826         Flags: DWORD,
827     ) -> HRESULT,
828     fn UnlockRect(
829         Level: UINT,
830     ) -> HRESULT,
831     fn AddDirtyRect(
832         pDirtyRect: *const RECT,
833     ) -> HRESULT,
834 }}
835 pub type LPDIRECT3DTEXTURE9 = *mut IDirect3DTexture9;
836 pub type PDIRECT3DTEXTURE9 = *mut IDirect3DTexture9;
837 RIDL!{#[uuid(0x2518526c, 0xe789, 0x4111, 0xa7, 0xb9, 0x47, 0xef, 0x32, 0x8d, 0x13, 0xe6)]
838 interface IDirect3DVolumeTexture9(IDirect3DVolumeTexture9Vtbl):
839     IDirect3DBaseTexture9(IDirect3DBaseTexture9Vtbl) {
840     fn GetLevelDesc(
841         Level: UINT,
842         pDesc: *mut D3DVOLUME_DESC,
843     ) -> HRESULT,
844     fn GetVolumeLevel(
845         Level: UINT,
846         ppVolumeLevel: *mut *mut IDirect3DVolume9,
847     ) -> HRESULT,
848     fn LockBox(
849         Level: UINT,
850         pLockedVolume: *mut D3DLOCKED_BOX,
851         pBox: *const D3DBOX,
852         Flags: DWORD,
853     ) -> HRESULT,
854     fn UnlockBox(
855         Level: UINT,
856     ) -> HRESULT,
857     fn AddDirtyBox(
858         pDirtyBox: *const D3DBOX,
859     ) -> HRESULT,
860 }}
861 pub type LPDIRECT3DVOLUMETEXTURE9 = *mut IDirect3DVolumeTexture9;
862 pub type PDIRECT3DVOLUMETEXTURE9 = *mut IDirect3DVolumeTexture9;
863 RIDL!{#[uuid(0xfff32f81, 0xd953, 0x473a, 0x92, 0x23, 0x93, 0xd6, 0x52, 0xab, 0xa9, 0x3f)]
864 interface IDirect3DCubeTexture9(IDirect3DCubeTexture9Vtbl):
865     IDirect3DBaseTexture9(IDirect3DBaseTexture9Vtbl) {
866     fn GetLevelDesc(
867         Level: UINT,
868         pDesc: *mut D3DSURFACE_DESC,
869     ) -> HRESULT,
870     fn GetCubeMapSurface(
871         FaceType: D3DCUBEMAP_FACES,
872         Level: UINT,
873         ppCubeMapSurface: *mut *mut IDirect3DSurface9,
874     ) -> HRESULT,
875     fn LockRect(
876         FaceType: D3DCUBEMAP_FACES,
877         Level: UINT,
878         pLockedRect: *mut D3DLOCKED_RECT,
879         pRect: *const RECT,
880         Flags: DWORD,
881     ) -> HRESULT,
882     fn UnlockRect(
883         FaceType: D3DCUBEMAP_FACES,
884         Level: UINT,
885     ) -> HRESULT,
886     fn AddDirtyRect(
887         FaceType: D3DCUBEMAP_FACES,
888         pDirtyRect: *const RECT,
889     ) -> HRESULT,
890 }}
891 pub type LPDIRECT3DCUBETEXTURE9 = *mut IDirect3DCubeTexture9;
892 pub type PDIRECT3DCUBETEXTURE9 = *mut IDirect3DCubeTexture9;
893 RIDL!{#[uuid(0xb64bb1b5, 0xfd70, 0x4df6, 0xbf, 0x91, 0x19, 0xd0, 0xa1, 0x24, 0x55, 0xe3)]
894 interface IDirect3DVertexBuffer9(IDirect3DVertexBuffer9Vtbl):
895     IDirect3DResource9(IDirect3DResource9Vtbl) {
896     fn Lock(
897         OffsetToLock: UINT,
898         SizeToLock: UINT,
899         ppbData: *mut *mut VOID,
900         Flags: DWORD,
901     ) -> HRESULT,
902     fn Unlock() -> HRESULT,
903     fn GetDesc(
904         pDesc: *mut D3DVERTEXBUFFER_DESC,
905     ) -> HRESULT,
906 }}
907 pub type LPDIRECT3DVERTEXBUFFER9 = *mut IDirect3DVertexBuffer9;
908 pub type PDIRECT3DVERTEXBUFFER9 = *mut IDirect3DVertexBuffer9;
909 RIDL!{#[uuid(0x7c9dd65e, 0xd3f7, 0x4529, 0xac, 0xee, 0x78, 0x58, 0x30, 0xac, 0xde, 0x35)]
910 interface IDirect3DIndexBuffer9(IDirect3DIndexBuffer9Vtbl):
911     IDirect3DResource9(IDirect3DResource9Vtbl) {
912     fn Lock(
913         OffsetToLock: UINT,
914         SizeToLock: UINT,
915         ppbData: *mut *mut VOID,
916         Flags: DWORD,
917     ) -> HRESULT,
918     fn Unlock() -> HRESULT,
919     fn GetDesc(
920         pDesc: *mut D3DINDEXBUFFER_DESC,
921     ) -> HRESULT,
922 }}
923 pub type LPDIRECT3DINDEXBUFFER9 = *mut IDirect3DIndexBuffer9;
924 pub type PDIRECT3DINDEXBUFFER9 = *mut IDirect3DIndexBuffer9;
925 RIDL!{#[uuid(0xcfbaf3a, 0x9ff6, 0x429a, 0x99, 0xb3, 0xa2, 0x79, 0x6a, 0xf8, 0xb8, 0x9b)]
926 interface IDirect3DSurface9(IDirect3DSurface9Vtbl): IDirect3DResource9(IDirect3DResource9Vtbl) {
927     fn GetContainer(
928         riid: *const IID,
929         ppContainer: *mut *mut VOID,
930     ) -> HRESULT,
931     fn GetDesc(
932         pDesc: *mut D3DSURFACE_DESC,
933     ) -> HRESULT,
934     fn LockRect(
935         pLockedRect: *mut D3DLOCKED_RECT,
936         pRect: *const RECT,
937         Flags: DWORD,
938     ) -> HRESULT,
939     fn UnlockRect() -> HRESULT,
940     fn GetDC(
941         phdc: *mut HDC,
942     ) -> HRESULT,
943     fn ReleaseDC(
944         hdc: HDC,
945     ) -> HRESULT,
946 }}
947 pub type LPDIRECT3DSURFACE9 = *mut IDirect3DSurface9;
948 pub type PDIRECT3DSURFACE9 = *mut IDirect3DSurface9;
949 RIDL!{#[uuid(0x24f416e6, 0x1f67, 0x4aa7, 0xb8, 0x8e, 0xd3, 0x3f, 0x6f, 0x31, 0x28, 0xa1)]
950 interface IDirect3DVolume9(IDirect3DVolume9Vtbl): IUnknown(IUnknownVtbl) {
951     fn GetDevice(
952         ppDevice: *mut *mut IDirect3DDevice9,
953     ) -> HRESULT,
954     fn SetPrivateData(
955         refguid: *const GUID,
956         pData: *const VOID,
957         SizeOfData: DWORD,
958         Flags: DWORD,
959     ) -> HRESULT,
960     fn GetPrivateData(
961         refguid: *const GUID,
962         pData: *mut VOID,
963         pSizeOfData: *mut DWORD,
964     ) -> HRESULT,
965     fn FreePrivateData(
966         refguid: *const GUID,
967     ) -> HRESULT,
968     fn GetContainer(
969         riid: *const IID,
970         ppContainer: *mut *mut VOID,
971     ) -> HRESULT,
972     fn GetDesc(
973         pDesc: *mut D3DVOLUME_DESC,
974     ) -> HRESULT,
975     fn LockBox(
976         pLockedVolume: *mut D3DLOCKED_BOX,
977         pBox: *const D3DBOX,
978         Flags: DWORD,
979     ) -> HRESULT,
980     fn UnlockBox() -> HRESULT,
981 }}
982 pub type LPDIRECT3DVOLUME9 = *mut IDirect3DVolume9;
983 pub type PDIRECT3DVOLUME9 = *mut IDirect3DVolume9;
984 RIDL!{#[uuid(0xd9771460, 0xa695, 0x4f26, 0xbb, 0xd3, 0x27, 0xb8, 0x40, 0xb5, 0x41, 0xcc)]
985 interface IDirect3DQuery9(IDirect3DQuery9Vtbl): IUnknown(IUnknownVtbl) {
986     fn GetDevice(
987         ppDevice: *mut *mut IDirect3DDevice9,
988     ) -> HRESULT,
989     fn GetType() -> D3DRESOURCETYPE,
990     fn GetDataSize() -> DWORD,
991     fn Issue(
992         dwIssueFlags: DWORD,
993     ) -> HRESULT,
994     fn GetData(
995         pData: *mut VOID,
996         dwSize: DWORD,
997         dwGetDataFlags: DWORD,
998     ) -> HRESULT,
999 }}
1000 pub type LPDIRECT3DQUERY9 = *mut IDirect3DQuery9;
1001 pub type PDIRECT3DQUERY9 = *mut IDirect3DQuery9;
1002 pub const D3DCREATE_FPU_PRESERVE: DWORD = 0x2;
1003 pub const D3DCREATE_MULTITHREADED: DWORD = 0x4;
1004 pub const D3DCREATE_PUREDEVICE: DWORD = 0x10;
1005 pub const D3DCREATE_SOFTWARE_VERTEXPROCESSING: DWORD = 0x20;
1006 pub const D3DCREATE_HARDWARE_VERTEXPROCESSING: DWORD = 0x40;
1007 pub const D3DCREATE_MIXED_VERTEXPROCESSING: DWORD = 0x80;
1008 pub const D3DCREATE_DISABLE_DRIVER_MANAGEMENT: DWORD = 0x100;
1009 pub const D3DCREATE_ADAPTERGROUP_DEVICE: DWORD = 0x200;
1010 pub const D3DCREATE_DISABLE_DRIVER_MANAGEMENT_EX: DWORD = 0x400;
1011 pub const D3DCREATE_NOWINDOWCHANGES: DWORD = 0x800;
1012 pub const D3DCREATE_DISABLE_PSGP_THREADING: DWORD = 0x2000;
1013 pub const D3DCREATE_ENABLE_PRESENTSTATS: DWORD = 0x4000;
1014 pub const D3DCREATE_DISABLE_PRESENTSTATS: DWORD = 0x8000;
1015 pub const D3DCREATE_SCREENSAVER: DWORD = 0x10000000;
1016 pub const D3DADAPTER_DEFAULT: DWORD = 0;
1017 extern "system" {
Direct3DCreate9Ex( SDKVersion: UINT, arg1: *mut *mut IDirect3D9Ex, ) -> HRESULT1018     pub fn Direct3DCreate9Ex(
1019         SDKVersion: UINT,
1020         arg1: *mut *mut IDirect3D9Ex,
1021     ) -> HRESULT;
1022 }
1023 RIDL!{#[uuid(0x02177241, 0x69fc, 0x400c, 0x8f, 0xf1, 0x93, 0xa4, 0x4d, 0xf6, 0x86, 0x1d)]
1024 interface IDirect3D9Ex(IDirect3D9ExVtbl): IDirect3D9(IDirect3D9Vtbl) {
1025     fn GetAdapterModeCountEx(
1026         Adapter: UINT,
1027         pFilter: *const D3DDISPLAYMODEFILTER,
1028     ) -> UINT,
1029     fn EnumAdapterModesEx(
1030         Adapter: UINT,
1031         pFilter: *const D3DDISPLAYMODEFILTER,
1032         Mode: UINT,
1033         pMode: *mut D3DDISPLAYMODEEX,
1034     ) -> HRESULT,
1035     fn GetAdapterDisplayModeEx(
1036         Adapter: UINT,
1037         pMode: *mut D3DDISPLAYMODEEX,
1038         pRotation: *mut D3DDISPLAYROTATION,
1039     ) -> HRESULT,
1040     fn CreateDeviceEx(
1041         Adapter: UINT,
1042         DeviceType: D3DDEVTYPE,
1043         hFocusWindow: HWND,
1044         BehaviorFlags: DWORD,
1045         pPresentationParameters: *mut D3DPRESENT_PARAMETERS,
1046         pFullscreenDisplayMode: *mut D3DDISPLAYMODEEX,
1047         ppReturnedDeviceInterface: *mut *mut IDirect3DDevice9Ex,
1048     ) -> HRESULT,
1049     fn GetAdapterLUID(
1050         Adapter: UINT,
1051         pLUID: *mut LUID,
1052     ) -> HRESULT,
1053 }}
1054 pub type LPDIRECT3D9EX = *mut IDirect3D9Ex;
1055 pub type PDIRECT3D9EX = *mut IDirect3D9Ex;
1056 RIDL!{#[uuid(0xb18b10ce, 0x2649, 0x405a, 0x87, 0xf, 0x95, 0xf7, 0x77, 0xd4, 0x31, 0x3a)]
1057 interface IDirect3DDevice9Ex(IDirect3DDevice9ExVtbl): IDirect3DDevice9(IDirect3DDevice9Vtbl) {
1058     fn SetConvolutionMonoKernel(
1059         width: UINT,
1060         height: UINT,
1061         rows: *mut FLOAT,
1062         columns: *mut FLOAT,
1063     ) -> HRESULT,
1064     fn ComposeRects(
1065         pSrc: *mut IDirect3DSurface9,
1066         pDst: *mut IDirect3DSurface9,
1067         pSrcRectDescs: *mut IDirect3DVertexBuffer9,
1068         NumRects: UINT,
1069         pDstRectDescs: *mut IDirect3DVertexBuffer9,
1070         Operation: D3DCOMPOSERECTSOP,
1071         Xoffset: INT,
1072         Yoffset: INT,
1073     ) -> HRESULT,
1074     fn PresentEx(
1075         pSourceRect: *const RECT,
1076         pDestRect: *const RECT,
1077         hDestWindowOverride: HWND,
1078         pDirtyRegion: *const RGNDATA,
1079         dwFlags: DWORD,
1080     ) -> HRESULT,
1081     fn GetGPUThreadPriority(
1082         pPriority: *mut INT,
1083     ) -> HRESULT,
1084     fn SetGPUThreadPriority(
1085         Priority: INT,
1086     ) -> HRESULT,
1087     fn WaitForVBlank(
1088         iSwapChain: UINT,
1089     ) -> HRESULT,
1090     fn CheckResourceResidency(
1091         pResourceArray: *mut *mut IDirect3DResource9,
1092         NumResources: UINT32,
1093     ) -> HRESULT,
1094     fn SetMaximumFrameLatency(
1095         MaxLatency: UINT,
1096     ) -> HRESULT,
1097     fn GetMaximumFrameLatency(
1098         pMaxLatency: *mut UINT,
1099     ) -> HRESULT,
1100     fn CheckDeviceState(
1101         hDestinationWindow: HWND,
1102     ) -> HRESULT,
1103     fn CreateRenderTargetEx(
1104         Width: UINT,
1105         Height: UINT,
1106         Format: D3DFORMAT,
1107         MultiSample: D3DMULTISAMPLE_TYPE,
1108         MultisampleQuality: DWORD,
1109         Lockable: BOOL,
1110         ppSurface: *mut *mut IDirect3DSurface9,
1111         pSharedHandle: *mut HANDLE,
1112         Usage: DWORD,
1113     ) -> HRESULT,
1114     fn CreateOffscreenPlainSurfaceEx(
1115         Width: UINT,
1116         Height: UINT,
1117         Format: D3DFORMAT,
1118         Pool: D3DPOOL,
1119         ppSurface: *mut *mut IDirect3DSurface9,
1120         pSharedHandle: *mut HANDLE,
1121         Usage: DWORD,
1122     ) -> HRESULT,
1123     fn CreateDepthStencilSurfaceEx(
1124         Width: UINT,
1125         Height: UINT,
1126         Format: D3DFORMAT,
1127         MultiSample: D3DMULTISAMPLE_TYPE,
1128         MultisampleQuality: DWORD,
1129         Discard: BOOL,
1130         ppSurface: *mut *mut IDirect3DSurface9,
1131         pSharedHandle: *mut HANDLE,
1132         Usage: DWORD,
1133     ) -> HRESULT,
1134     fn ResetEx(
1135         pPresentationParameters: *mut D3DPRESENT_PARAMETERS,
1136         pFullscreenDisplayMode: *mut D3DDISPLAYMODEEX,
1137     ) -> HRESULT,
1138     fn GetDisplayModeEx(
1139         iSwapChain: UINT,
1140         pMode: *mut D3DDISPLAYMODEEX,
1141         pRotation: *mut D3DDISPLAYROTATION,
1142     ) -> HRESULT,
1143 }}
1144 pub type LPDIRECT3DDEVICE9EX = *mut IDirect3DDevice9Ex;
1145 pub type PDIRECT3DDEVICE9EX = *mut IDirect3DDevice9Ex;
1146 RIDL!{#[uuid(0x91886caf, 0x1c3d, 0x4d2e, 0xa0, 0xab, 0x3e, 0x4c, 0x7d, 0x8d, 0x33, 0x3)]
1147 interface IDirect3DSwapChain9Ex(IDirect3DSwapChain9ExVtbl):
1148     IDirect3DSwapChain9(IDirect3DSwapChain9Vtbl) {
1149     fn GetLastPresentCount(
1150         pLastPresentCount: *mut UINT,
1151     ) -> HRESULT,
1152     fn GetPresentStats(
1153         pPresentationStatistics: *mut D3DPRESENTSTATS,
1154     ) -> HRESULT,
1155     fn GetDisplayModeEx(
1156         pMode: *mut D3DDISPLAYMODEEX,
1157         pRotation: *mut D3DDISPLAYROTATION,
1158     ) -> HRESULT,
1159 }}
1160 pub type LPDIRECT3DSWAPCHAIN9EX = *mut IDirect3DSwapChain9Ex;
1161 pub type PDIRECT3DSWAPCHAIN9EX = *mut IDirect3DSwapChain9Ex;
1162 RIDL!{#[uuid(0x187aeb13, 0xaaf5, 0x4c59, 0x87, 0x6d, 0xe0, 0x59, 0x8, 0x8c, 0xd, 0xf8)]
1163 interface IDirect3D9ExOverlayExtension(IDirect3D9ExOverlayExtensionVtbl): IUnknown(IUnknownVtbl) {
1164     fn CheckDeviceOverlayType(
1165         Adapter: UINT,
1166         DevType: D3DDEVTYPE,
1167         OverlayWidth: UINT,
1168         OverlayHeight: UINT,
1169         OverlayFormat: D3DFORMAT,
1170         pDisplayMode: *mut D3DDISPLAYMODEEX,
1171         DisplayRotation: D3DDISPLAYROTATION,
1172         pOverlayCaps: *mut D3DOVERLAYCAPS,
1173     ) -> HRESULT,
1174 }}
1175 pub type LPDIRECT3D9EXOVERLAYEXTENSION = *mut IDirect3D9ExOverlayExtension;
1176 pub type PDIRECT3D9EXOVERLAYEXTENSION = *mut IDirect3D9ExOverlayExtension;
1177 RIDL!{#[uuid(0x26dc4561, 0xa1ee, 0x4ae7, 0x96, 0xda, 0x11, 0x8a, 0x36, 0xc0, 0xec, 0x95)]
1178 interface IDirect3DDevice9Video(IDirect3DDevice9VideoVtbl): IUnknown(IUnknownVtbl) {
1179     fn GetContentProtectionCaps(
1180         pCryptoType: *const GUID,
1181         pDecodeProfile: *const GUID,
1182         pCaps: *mut D3DCONTENTPROTECTIONCAPS,
1183     ) -> HRESULT,
1184     fn CreateAuthenticatedChannel(
1185         ChannelType: D3DAUTHENTICATEDCHANNELTYPE,
1186         ppAuthenticatedChannel: *mut *mut IDirect3DAuthenticatedChannel9,
1187         pChannelHandle: *mut HANDLE,
1188     ) -> HRESULT,
1189     fn CreateCryptoSession(
1190         pCryptoType: *const GUID,
1191         pDecodeProfile: *const GUID,
1192         ppCryptoSession: *mut *mut IDirect3DCryptoSession9,
1193         pCryptoHandle: *mut HANDLE,
1194     ) -> HRESULT,
1195 }}
1196 pub type LPDIRECT3DDEVICE9VIDEO = *mut IDirect3DDevice9Video;
1197 pub type PDIRECT3DDEVICE9VIDEO = *mut IDirect3DDevice9Video;
1198 RIDL!{#[uuid(0xff24beee, 0xda21, 0x4beb, 0x98, 0xb5, 0xd2, 0xf8, 0x99, 0xf9, 0x8a, 0xf9)]
1199 interface IDirect3DAuthenticatedChannel9(IDirect3DAuthenticatedChannel9Vtbl):
1200     IUnknown(IUnknownVtbl) {
1201     fn GetCertificateSize(
1202         pCertificateSize: *mut UINT,
1203     ) -> HRESULT,
1204     fn GetCertificate(
1205         CertifacteSize: UINT,
1206         ppCertificate: *mut BYTE,
1207     ) -> HRESULT,
1208     fn NegotiateKeyExchange(
1209         DataSize: UINT,
1210         pData: *mut VOID,
1211     ) -> HRESULT,
1212     fn Query(
1213         InputSize: UINT,
1214         pInput: *const VOID,
1215         OutputSize: UINT,
1216         pOutput: *mut VOID,
1217     ) -> HRESULT,
1218     fn Configure(
1219         InputSize: UINT,
1220         pInput: *const VOID,
1221         pOutput: *mut D3DAUTHENTICATEDCHANNEL_CONFIGURE_OUTPUT,
1222     ) -> HRESULT,
1223 }}
1224 pub type LPDIRECT3DAUTHENTICATEDCHANNEL9 = *mut IDirect3DAuthenticatedChannel9;
1225 pub type PDIRECT3DAUTHENTICATEDCHANNEL9 = *mut IDirect3DAuthenticatedChannel9;
1226 RIDL!{#[uuid(0xfa0ab799, 0x7a9c, 0x48ca, 0x8c, 0x5b, 0x23, 0x7e, 0x71, 0xa5, 0x44, 0x34)]
1227 interface IDirect3DCryptoSession9(IDirect3DCryptoSession9Vtbl): IUnknown(IUnknownVtbl) {
1228     fn GetCertificateSize(
1229         pCertificateSize: *mut UINT,
1230     ) -> HRESULT,
1231     fn GetCertificate(
1232         CertifacteSize: UINT,
1233         ppCertificate: *mut BYTE,
1234     ) -> HRESULT,
1235     fn NegotiateKeyExchange(
1236         DataSize: UINT,
1237         pData: *mut VOID,
1238     ) -> HRESULT,
1239     fn EncryptionBlt(
1240         pSrcSurface: *mut IDirect3DSurface9,
1241         pDstSurface: *mut IDirect3DSurface9,
1242         DstSurfaceSize: UINT,
1243         pIV: *mut VOID,
1244     ) -> HRESULT,
1245     fn DecryptionBlt(
1246         pSrcSurface: *mut IDirect3DSurface9,
1247         pDstSurface: *mut IDirect3DSurface9,
1248         SrcSurfaceSize: UINT,
1249         pEncryptedBlockInfo: *mut D3DENCRYPTED_BLOCK_INFO,
1250         pContentKey: *mut VOID,
1251         pIV: *mut VOID,
1252     ) -> HRESULT,
1253     fn GetSurfacePitch(
1254         pSrcSurface: *mut IDirect3DSurface9,
1255         pSurfacePitch: *mut UINT,
1256     ) -> HRESULT,
1257     fn StartSessionKeyRefresh(
1258         pRandomNumber: *mut VOID,
1259         RandomNumberSize: UINT,
1260     ) -> HRESULT,
1261     fn FinishSessionKeyRefresh() -> HRESULT,
1262     fn GetEncryptionBltKey(
1263         pReadbackKey: *mut VOID,
1264         KeySize: UINT,
1265     ) -> HRESULT,
1266 }}
1267 pub type LPDIRECT3DCRYPTOSESSION9 = *mut IDirect3DCryptoSession9;
1268 pub type PDIRECT3DCRYPTOSESSION9 = *mut IDirect3DCryptoSession9;
1269