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 use ctypes::c_int;
7 use shared::basetsd::UINT64;
8 use shared::minwindef::{BOOL, BYTE, INT, LPVOID, UINT};
9 use um::d3dcommon::{
10     D3D_CBUFFER_TYPE, D3D_FEATURE_LEVEL, D3D_INTERPOLATION_MODE, D3D_MIN_PRECISION, D3D_NAME,
11     D3D_PARAMETER_FLAGS, D3D_PRIMITIVE, D3D_PRIMITIVE_TOPOLOGY, D3D_REGISTER_COMPONENT_TYPE,
12     D3D_RESOURCE_RETURN_TYPE, D3D_SHADER_INPUT_TYPE, D3D_SHADER_VARIABLE_CLASS,
13     D3D_SHADER_VARIABLE_TYPE, D3D_SRV_DIMENSION, D3D_TESSELLATOR_DOMAIN,
14     D3D_TESSELLATOR_OUTPUT_PRIMITIVE, D3D_TESSELLATOR_PARTITIONING, ID3DBlob,
15 };
16 use um::unknwnbase::{IUnknown, IUnknownVtbl};
17 use um::winnt::{HRESULT, LPCSTR};
18 ENUM!{enum D3D11_SHADER_VERSION_TYPE {
19     D3D11_SHVER_PIXEL_SHADER = 0,
20     D3D11_SHVER_VERTEX_SHADER = 1,
21     D3D11_SHVER_GEOMETRY_SHADER = 2,
22     D3D11_SHVER_HULL_SHADER = 3,
23     D3D11_SHVER_DOMAIN_SHADER = 4,
24     D3D11_SHVER_COMPUTE_SHADER = 5,
25     D3D11_SHVER_RESERVED0 = 0xFFF0,
26 }}
27 pub const D3D_RETURN_PARAMETER_INDEX: c_int = -1;
28 pub type D3D11_RESOURCE_RETURN_TYPE = D3D_RESOURCE_RETURN_TYPE;
29 pub type D3D11_CBUFFER_TYPE = D3D_CBUFFER_TYPE;
30 STRUCT!{struct D3D11_SIGNATURE_PARAMETER_DESC {
31     SemanticName: LPCSTR,
32     SemanticIndex: UINT,
33     Register: UINT,
34     SystemValueType: D3D_NAME,
35     ComponentType: D3D_REGISTER_COMPONENT_TYPE,
36     Mask: BYTE,
37     ReadWriteMask: BYTE,
38     Stream: UINT,
39     MinPrecision: D3D_MIN_PRECISION,
40 }}
41 STRUCT!{struct D3D11_SHADER_BUFFER_DESC {
42     Name: LPCSTR,
43     Type: D3D_CBUFFER_TYPE,
44     Variables: UINT,
45     Size: UINT,
46     uFlags: UINT,
47 }}
48 STRUCT!{struct D3D11_SHADER_VARIABLE_DESC {
49     Name: LPCSTR,
50     StartOffset: UINT,
51     Size: UINT,
52     uFlags: UINT,
53     DefaultValue: LPVOID,
54     StartTexture: UINT,
55     TextureSize: UINT,
56     StartSampler: UINT,
57     SamplerSize: UINT,
58 }}
59 STRUCT!{struct D3D11_SHADER_TYPE_DESC {
60     Class: D3D_SHADER_VARIABLE_CLASS,
61     Type: D3D_SHADER_VARIABLE_TYPE,
62     Rows: UINT,
63     Columns: UINT,
64     Elements: UINT,
65     Members: UINT,
66     Offset: UINT,
67     Name: LPCSTR,
68 }}
69 pub type D3D11_TESSELLATOR_DOMAIN = D3D_TESSELLATOR_DOMAIN;
70 pub type D3D11_TESSELLATOR_PARTITIONING = D3D_TESSELLATOR_PARTITIONING;
71 pub type D3D11_TESSELLATOR_OUTPUT_PRIMITIVE = D3D_TESSELLATOR_OUTPUT_PRIMITIVE;
72 STRUCT!{struct D3D11_SHADER_DESC {
73     Version: UINT,
74     Creator: LPCSTR,
75     Flags: UINT,
76     ConstantBuffers: UINT,
77     BoundResources: UINT,
78     InputParameters: UINT,
79     OutputParameters: UINT,
80     InstructionCount: UINT,
81     TempRegisterCount: UINT,
82     TempArrayCount: UINT,
83     DefCount: UINT,
84     DclCount: UINT,
85     TextureNormalInstructions: UINT,
86     TextureLoadInstructions: UINT,
87     TextureCompInstructions: UINT,
88     TextureBiasInstructions: UINT,
89     TextureGradientInstructions: UINT,
90     FloatInstructionCount: UINT,
91     IntInstructionCount: UINT,
92     UintInstructionCount: UINT,
93     StaticFlowControlCount: UINT,
94     DynamicFlowControlCount: UINT,
95     MacroInstructionCount: UINT,
96     ArrayInstructionCount: UINT,
97     CutInstructionCount: UINT,
98     EmitInstructionCount: UINT,
99     GSOutputTopology: D3D_PRIMITIVE_TOPOLOGY,
100     GSMaxOutputVertexCount: UINT,
101     InputPrimitive: D3D_PRIMITIVE,
102     PatchConstantParameters: UINT,
103     cGSInstanceCount: UINT,
104     cControlPoints: UINT,
105     HSOutputPrimitive: D3D_TESSELLATOR_OUTPUT_PRIMITIVE,
106     HSPartitioning: D3D_TESSELLATOR_PARTITIONING,
107     TessellatorDomain: D3D_TESSELLATOR_DOMAIN,
108     cBarrierInstructions: UINT,
109     cInterlockedInstructions: UINT,
110     cTextureStoreInstructions: UINT,
111 }}
112 STRUCT!{struct D3D11_SHADER_INPUT_BIND_DESC {
113     Name: LPCSTR,
114     Type: D3D_SHADER_INPUT_TYPE,
115     BindPoint: UINT,
116     BindCount: UINT,
117     uFlags: UINT,
118     ReturnType: D3D_RESOURCE_RETURN_TYPE,
119     Dimension: D3D_SRV_DIMENSION,
120     NumSamples: UINT,
121 }}
122 pub const D3D_SHADER_REQUIRES_DOUBLES: UINT64 = 0x00000001;
123 pub const D3D_SHADER_REQUIRES_EARLY_DEPTH_STENCIL: UINT64 = 0x00000002;
124 pub const D3D_SHADER_REQUIRES_UAVS_AT_EVERY_STAGE: UINT64 = 0x00000004;
125 pub const D3D_SHADER_REQUIRES_64_UAVS: UINT64 = 0x00000008;
126 pub const D3D_SHADER_REQUIRES_MINIMUM_PRECISION: UINT64 = 0x00000010;
127 pub const D3D_SHADER_REQUIRES_11_1_DOUBLE_EXTENSIONS: UINT64 = 0x00000020;
128 pub const D3D_SHADER_REQUIRES_11_1_SHADER_EXTENSIONS: UINT64 = 0x00000040;
129 pub const D3D_SHADER_REQUIRES_LEVEL_9_COMPARISON_FILTERING: UINT64 = 0x00000080;
130 pub const D3D_SHADER_REQUIRES_TILED_RESOURCES: UINT64 = 0x00000100;
131 STRUCT!{struct D3D11_LIBRARY_DESC {
132     Creator: LPCSTR,
133     Flags: UINT,
134     FunctionCount: UINT,
135 }}
136 STRUCT!{struct D3D11_FUNCTION_DESC {
137     Version: UINT,
138     Creator: LPCSTR,
139     Flags: UINT,
140     ConstantBuffers: UINT,
141     BoundResources: UINT,
142     InstructionCount: UINT,
143     TempRegisterCount: UINT,
144     TempArrayCount: UINT,
145     DefCount: UINT,
146     DclCount: UINT,
147     TextureNormalInstructions: UINT,
148     TextureLoadInstructions: UINT,
149     TextureCompInstructions: UINT,
150     TextureBiasInstructions: UINT,
151     TextureGradientInstructions: UINT,
152     FloatInstructionCount: UINT,
153     IntInstructionCount: UINT,
154     UintInstructionCount: UINT,
155     StaticFlowControlCount: UINT,
156     DynamicFlowControlCount: UINT,
157     MacroInstructionCount: UINT,
158     ArrayInstructionCount: UINT,
159     MovInstructionCount: UINT,
160     MovcInstructionCount: UINT,
161     ConversionInstructionCount: UINT,
162     BitwiseInstructionCount: UINT,
163     MinFeatureLevel: D3D_FEATURE_LEVEL,
164     RequiredFeatureFlags: UINT64,
165     Name: LPCSTR,
166     FunctionParameterCount: INT,
167     HasReturn: BOOL,
168     Has10Level9VertexShader: BOOL,
169     Has10Level9PixelShader: BOOL,
170 }}
171 STRUCT!{struct D3D11_PARAMETER_DESC {
172     Name: LPCSTR,
173     SemanticName: LPCSTR,
174     Type: D3D_SHADER_VARIABLE_TYPE,
175     Class: D3D_SHADER_VARIABLE_CLASS,
176     Rows: UINT,
177     Columns: UINT,
178     InterpolationMode: D3D_INTERPOLATION_MODE,
179     Flags: D3D_PARAMETER_FLAGS,
180     FirstInRegister: UINT,
181     FirstInComponent: UINT,
182     FirstOutRegister: UINT,
183     FirstOutComponent: UINT,
184 }}
185 DEFINE_GUID!{IID_ID3D11ShaderReflectionType,
186     0x6e6ffa6a, 0x9bae, 0x4613, 0xa5, 0x1e, 0x91, 0x65, 0x2d, 0x50, 0x8c, 0x21}
187 RIDL!{#[uuid(0x6e6ffa6a, 0x9bae, 0x4613, 0xa5, 0x1e, 0x91, 0x65, 0x2d, 0x50, 0x8c, 0x21)]
188 interface ID3D11ShaderReflectionType(ID3D11ShaderReflectionTypeVtbl) {
189     fn GetDesc(
190         pDesc: *mut D3D11_SHADER_TYPE_DESC,
191     ) -> HRESULT,
192     fn GetMemberTypeByIndex(
193         Index: UINT,
194     ) -> *mut ID3D11ShaderReflectionType,
195     fn GetMemberTypeByName(
196         Name: LPCSTR,
197     ) -> *mut ID3D11ShaderReflectionType,
198     fn GetMemberTypeName(
199         Index: UINT,
200     ) -> LPCSTR,
201     fn IsEqual(
202         pType: *mut ID3D11ShaderReflectionType,
203     ) -> HRESULT,
204     fn GetSubType() -> *mut ID3D11ShaderReflectionType,
205     fn GetBaseClass() -> *mut ID3D11ShaderReflectionType,
206     fn GetNumInterfaces() -> UINT,
207     fn GetInterfaceByIndex(
208         uIndex: UINT,
209     ) -> *mut ID3D11ShaderReflectionType,
210     fn IsOfType(
211         pType: *mut ID3D11ShaderReflectionType,
212     ) -> HRESULT,
213     fn ImplementsInterface(
214         pBase: *mut ID3D11ShaderReflectionType,
215     ) -> HRESULT,
216 }}
217 DEFINE_GUID!{IID_ID3D11ShaderReflectionVariable,
218     0x51f23923, 0xf3e5, 0x4bd1, 0x91, 0xcb, 0x60, 0x61, 0x77, 0xd8, 0xdb, 0x4c}
219 RIDL!{#[uuid(0x51f23923, 0xf3e5, 0x4bd1, 0x91, 0xcb, 0x60, 0x61, 0x77, 0xd8, 0xdb, 0x4c)]
220 interface ID3D11ShaderReflectionVariable(ID3D11ShaderReflectionVariableVtbl) {
221     fn GetDesc(
222         pDesc: *mut D3D11_SHADER_VARIABLE_DESC,
223     ) -> HRESULT,
224     fn GetType() -> *mut ID3D11ShaderReflectionType,
225     fn GetBuffer() -> *mut ID3D11ShaderReflectionConstantBuffer,
226     fn GetInterfaceSlot(
227         uArrayIndex: UINT,
228     ) -> UINT,
229 }}
230 DEFINE_GUID!{IID_ID3D11ShaderReflectionConstantBuffer,
231     0xeb62d63d, 0x93dd, 0x4318, 0x8a, 0xe8, 0xc6, 0xf8, 0x3a, 0xd3, 0x71, 0xb8}
232 RIDL!{#[uuid(0xeb62d63d, 0x93dd, 0x4318, 0x8a, 0xe8, 0xc6, 0xf8, 0x3a, 0xd3, 0x71, 0xb8)]
233 interface ID3D11ShaderReflectionConstantBuffer(ID3D11ShaderReflectionConstantBufferVtbl) {
234     fn GetDesc(
235         pDesc: *mut D3D11_SHADER_BUFFER_DESC,
236     ) -> HRESULT,
237     fn GetVariableByIndex(
238         Index: UINT,
239     ) -> *mut ID3D11ShaderReflectionVariable,
240     fn GetVariableByName(
241         Name: LPCSTR,
242     ) -> *mut ID3D11ShaderReflectionVariable,
243 }}
244 DEFINE_GUID!{IID_ID3D11ShaderReflection,
245     0x8d536ca1, 0x0cca, 0x4956, 0xa8, 0x37, 0x78, 0x69, 0x63, 0x75, 0x55, 0x84}
246 RIDL!{#[uuid(0x8d536ca1, 0x0cca, 0x4956, 0xa8, 0x37, 0x78, 0x69, 0x63, 0x75, 0x55, 0x84)]
247 interface ID3D11ShaderReflection(ID3D11ShaderReflectionVtbl): IUnknown(IUnknownVtbl) {
248     fn GetDesc(
249         pDesc: *mut D3D11_SHADER_DESC,
250     ) -> HRESULT,
251     fn GetConstantBufferByIndex(
252         Index: UINT,
253     ) -> *mut ID3D11ShaderReflectionConstantBuffer,
254     fn GetConstantBufferByName(
255         Name: LPCSTR,
256     ) -> *mut ID3D11ShaderReflectionConstantBuffer,
257     fn GetResourceBindingDesc(
258         ResourceIndex: UINT,
259         pDesc: *mut D3D11_SHADER_INPUT_BIND_DESC,
260     ) -> HRESULT,
261     fn GetInputParameterDesc(
262         ParameterIndex: UINT,
263         pDesc: *mut D3D11_SIGNATURE_PARAMETER_DESC,
264     ) -> HRESULT,
265     fn GetOutputParameterDesc(
266         ParameterIndex: UINT,
267         pDesc: *mut D3D11_SIGNATURE_PARAMETER_DESC,
268     ) -> HRESULT,
269     fn GetPatchConstantParameterDesc(
270         ParameterIndex: UINT,
271         pDesc: *mut D3D11_SIGNATURE_PARAMETER_DESC,
272     ) -> HRESULT,
273     fn GetVariableByName(
274         Name: LPCSTR,
275     ) -> *mut ID3D11ShaderReflectionVariable,
276     fn GetResourceBindingDescByName(
277         Name: LPCSTR,
278         pDesc: *mut D3D11_SHADER_INPUT_BIND_DESC,
279     ) -> HRESULT,
280     fn GetMovInstructionCount() -> UINT,
281     fn GetMovcInstructionCount() -> UINT,
282     fn GetConversionInstructionCount() -> UINT,
283     fn GetBitwiseInstructionCount() -> UINT,
284     fn GetGSInputPrimitive() -> D3D_PRIMITIVE,
285     fn IsSampleFrequencyShader() -> BOOL,
286     fn GetNumInterfaceSlots() -> UINT,
287     fn GetMinFeatureLevel(
288         pLevel: *mut D3D_FEATURE_LEVEL,
289     ) -> HRESULT,
290     fn GetThreadGroupSize(
291         pSizeX: *mut UINT,
292         pSizeY: *mut UINT,
293         pSizeZ: *mut UINT,
294     ) -> UINT,
295     fn GetRequiresFlags() -> UINT64,
296 }}
297 DEFINE_GUID!{IID_ID3D11LibraryReflection,
298     0x54384f1b, 0x5b3e, 0x4bb7, 0xae, 0x01, 0x60, 0xba, 0x30, 0x97, 0xcb, 0xb6}
299 RIDL!{#[uuid(0x54384f1b, 0x5b3e, 0x4bb7, 0xae, 0x01, 0x60, 0xba, 0x30, 0x97, 0xcb, 0xb6)]
300 interface ID3D11LibraryReflection(ID3D11LibraryReflectionVtbl): IUnknown(IUnknownVtbl) {
301     fn GetDesc(
302         pDesc: *mut D3D11_LIBRARY_DESC,
303     ) -> HRESULT,
304     fn GetFunctionByIndex(
305         FunctionIndex: INT,
306     ) -> *mut ID3D11FunctionReflection,
307 }}
308 DEFINE_GUID!{IID_ID3D11FunctionReflection,
309     0x207bcecb, 0xd683, 0x4a06, 0xa8, 0xa3, 0x9b, 0x14, 0x9b, 0x9f, 0x73, 0xa4}
310 RIDL!{#[uuid(0x207bcecb, 0xd683, 0x4a06, 0xa8, 0xa3, 0x9b, 0x14, 0x9b, 0x9f, 0x73, 0xa4)]
311 interface ID3D11FunctionReflection(ID3D11FunctionReflectionVtbl) {
312     fn GetDesc(
313         pDesc: *mut D3D11_FUNCTION_DESC,
314     ) -> HRESULT,
315     fn GetConstantBufferByIndex(
316         BufferIndex: UINT,
317     ) -> *mut ID3D11ShaderReflectionConstantBuffer,
318     fn GetConstantBufferByName(
319         Name: LPCSTR,
320     ) -> *mut ID3D11ShaderReflectionConstantBuffer,
321     fn GetResourceBindingDesc(
322         ResourceIndex: UINT,
323         pDesc: *mut D3D11_SHADER_INPUT_BIND_DESC,
324     ) -> HRESULT,
325     fn GetVariableByName(
326         Name: LPCSTR,
327     ) -> *mut ID3D11ShaderReflectionVariable,
328     fn GetResourceBindingDescByName(
329         Name: LPCSTR,
330         pDesc: *mut D3D11_SHADER_INPUT_BIND_DESC,
331     ) -> HRESULT,
332     fn GetFunctionParameter(
333         ParameterIndex: INT,
334     ) -> *mut ID3D11FunctionParameterReflection,
335 }}
336 DEFINE_GUID!{IID_ID3D11FunctionParameterReflection,
337     0x42757488, 0x334f, 0x47fe, 0x98, 0x2e, 0x1a, 0x65, 0xd0, 0x8c, 0xc4, 0x62}
338 RIDL!{#[uuid(0x42757488, 0x334f, 0x47fe, 0x98, 0x2e, 0x1a, 0x65, 0xd0, 0x8c, 0xc4, 0x62)]
339 interface ID3D11FunctionParameterReflection(ID3D11FunctionParameterReflectionVtbl) {
340     fn GetDesc(
341         pDesc: *mut D3D11_PARAMETER_DESC,
342     ) -> HRESULT,
343 }}
344 DEFINE_GUID!{IID_ID3D11Module,
345     0xcac701ee, 0x80fc, 0x4122, 0x82, 0x42, 0x10, 0xb3, 0x9c, 0x8c, 0xec, 0x34}
346 RIDL!{#[uuid(0xcac701ee, 0x80fc, 0x4122, 0x82, 0x42, 0x10, 0xb3, 0x9c, 0x8c, 0xec, 0x34)]
347 interface ID3D11Module(ID3D11ModuleVtbl): IUnknown(IUnknownVtbl) {
348     fn CreateInstance(
349         pNamespace: LPCSTR,
350         ppModuleInstance: *mut *mut ID3D11ModuleInstance,
351     ) -> HRESULT,
352 }}
353 DEFINE_GUID!{IID_ID3D11ModuleInstance,
354     0x469e07f7, 0x045a, 0x48d5, 0xaa, 0x12, 0x68, 0xa4, 0x78, 0xcd, 0xf7, 0x5d}
355 RIDL!{#[uuid(0x469e07f7, 0x045a, 0x48d5, 0xaa, 0x12, 0x68, 0xa4, 0x78, 0xcd, 0xf7, 0x5d)]
356 interface ID3D11ModuleInstance(ID3D11ModuleInstanceVtbl): IUnknown(IUnknownVtbl) {
357     fn BindConstantBuffer(
358         uSrcSlot: UINT,
359         uDstSlot: UINT,
360         cbDstOffset: UINT,
361     ) -> HRESULT,
362     fn BindConstantBufferByName(
363         pName: LPCSTR,
364         uDstSlot: UINT,
365         cbDstOffset: UINT,
366     ) -> HRESULT,
367     fn BindResource(
368         uSrcSlot: UINT,
369         uDstSlot: UINT,
370         uCount: UINT,
371     ) -> HRESULT,
372     fn BindResourceByName(
373         pName: LPCSTR,
374         uDstSlot: UINT,
375         uCount: UINT,
376     ) -> HRESULT,
377     fn BindSampler(
378         uSrcSlot: UINT,
379         uDstSlot: UINT,
380         uCount: UINT,
381     ) -> HRESULT,
382     fn BindSamplerByName(
383         pName: LPCSTR,
384         uDstSlot: UINT,
385         uCount: UINT,
386     ) -> HRESULT,
387     fn BindUnorderedAccessView(
388         uSrcSlot: UINT,
389         uDstSlot: UINT,
390         uCount: UINT,
391     ) -> HRESULT,
392     fn BindUnorderedAccessViewByName(
393         pName: LPCSTR,
394         uDstSlot: UINT,
395         uCount: UINT,
396     ) -> HRESULT,
397     fn BindResourceAsUnorderedAccessView(
398         uSrcSrvSlot: UINT,
399         uDstUavSlot: UINT,
400         uCount: UINT,
401     ) -> HRESULT,
402     fn BindResourceAsUnorderedAccessViewByName(
403         pSrvName: LPCSTR,
404         uDstUavSlot: UINT,
405         uCount: UINT,
406     ) -> HRESULT,
407 }}
408 DEFINE_GUID!{IID_ID3D11Linker,
409     0x59a6cd0e, 0xe10d, 0x4c1f, 0x88, 0xc0, 0x63, 0xab, 0xa1, 0xda, 0xf3, 0x0e}
410 RIDL!{#[uuid(0x59a6cd0e, 0xe10d, 0x4c1f, 0x88, 0xc0, 0x63, 0xab, 0xa1, 0xda, 0xf3, 0x0e)]
411 interface ID3D11Linker(ID3D11LinkerVtbl): IUnknown(IUnknownVtbl) {
412     fn Link(
413         pEntry: *mut ID3D11ModuleInstance,
414         pEntryName: LPCSTR,
415         pTargetName: LPCSTR,
416         uFlags: UINT,
417         ppShaderBlob: *mut *mut ID3DBlob,
418         ppErrorBuffer: *mut *mut ID3DBlob,
419     ) -> HRESULT,
420     fn UseLibrary(
421         pLibraryMI: *mut ID3D11ModuleInstance,
422     ) -> HRESULT,
423     fn AddClipPlaneFromCBuffer(
424         uCBufferSlot: UINT,
425         uCBufferEntry: UINT,
426     ) -> HRESULT,
427 }}
428 DEFINE_GUID!{IID_ID3D11LinkingNode,
429     0xd80dd70c, 0x8d2f, 0x4751, 0x94, 0xa1, 0x03, 0xc7, 0x9b, 0x35, 0x56, 0xdb}
430 RIDL!{#[uuid(0xd80dd70c, 0x8d2f, 0x4751, 0x94, 0xa1, 0x03, 0xc7, 0x9b, 0x35, 0x56, 0xdb)]
431 interface ID3D11LinkingNode(ID3D11LinkingNodeVtbl): IUnknown(IUnknownVtbl) {}}
432 DEFINE_GUID!{IID_ID3D11FunctionLinkingGraph,
433     0x54133220, 0x1ce8, 0x43d3, 0x82, 0x36, 0x98, 0x55, 0xc5, 0xce, 0xec, 0xff}
434 RIDL!{#[uuid(0x54133220, 0x1ce8, 0x43d3, 0x82, 0x36, 0x98, 0x55, 0xc5, 0xce, 0xec, 0xff)]
435 interface ID3D11FunctionLinkingGraph(ID3D11FunctionLinkingGraphVtbl): IUnknown(IUnknownVtbl) {
436     fn CreateModuleInstance(
437         ppModuleInstance: *mut *mut ID3D11ModuleInstance,
438         ppErrorBuffer: *mut *mut ID3DBlob,
439     ) -> HRESULT,
440     fn SetInputSignature(
441         pInputParameters: *const D3D11_PARAMETER_DESC,
442         cInputParameters: UINT,
443         ppInputNode: *mut *mut ID3D11LinkingNode,
444     ) -> HRESULT,
445     fn SetOutputSignature(
446         pOutputParameters: *const D3D11_PARAMETER_DESC,
447         cOutputParameters: UINT,
448         ppOutputNode: *mut *mut ID3D11LinkingNode,
449     ) -> HRESULT,
450     fn CallFunction(
451         pModuleInstanceNamespace: LPCSTR,
452         pModuleWithFunctionPrototype: *mut ID3D11Module,
453         pFunctionName: LPCSTR,
454         ppCallNode: *mut *mut ID3D11LinkingNode,
455     ) -> HRESULT,
456     fn PassValue(
457         pSrcNode: *mut ID3D11LinkingNode,
458         SrcParameterIndex: INT,
459         pDstNode: *mut ID3D11LinkingNode,
460         DstParameterIndex: INT,
461     ) -> HRESULT,
462     fn PassValueWithSwizzle(
463         pSrcNode: *mut ID3D11LinkingNode,
464         SrcParameterIndex: INT,
465         pSrcSwizzle: LPCSTR,
466         pDstNode: *mut ID3D11LinkingNode,
467         DstParameterIndex: INT,
468         pDstSwizzle: LPCSTR,
469     ) -> HRESULT,
470     fn GetLastError(
471         ppErrorBuffer: *mut *mut ID3DBlob,
472     ) -> HRESULT,
473     fn GenerateHlsl(
474         uFlags: UINT,
475         ppBuffer: *mut *mut ID3DBlob,
476     ) -> HRESULT,
477 }}
478