aurora.directx.d3d11.d3d11shader source code

1 module aurora.directx.d3d11.d3d11shader;
2 
3 import std.bitmanip;
4 import aurora.directx.com;
5 import aurora.directx.d3d11;
6 
7 public:
8 
9 ///
10 /// Constants
11 ///
12 
13 enum int D3D_SHADER_REQUIRES_DOUBLES = 0x00000001;
14 enum int D3D_SHADER_REQUIRES_EARLY_DEPTH_STENCIL = 0x00000002;
15 enum int D3D_SHADER_REQUIRES_UAVS_AT_EVERY_STAGE = 0x00000004;
16 enum int D3D_SHADER_REQUIRES_64_UAVS = 0x00000008;
17 enum int D3D_SHADER_REQUIRES_MINIMUM_PRECISION = 0x00000010;
18 enum int D3D_SHADER_REQUIRES_11_1_DOUBLE_EXTENSIONS = 0x00000020;
19 enum int D3D_SHADER_REQUIRES_11_1_SHADER_EXTENSIONS = 0x00000040;
20 enum int D3D_SHADER_REQUIRES_LEVEL_9_COMPARISON_FILTERING = 0x00000080;
21 enum int D3D_SHADER_REQUIRES_TILED_RESOURCES = 0x00000100;
22 
23 alias D3D_RESOURCE_RETURN_TYPE D3D11_RESOURCE_RETURN_TYPE;
24 alias D3D_CBUFFER_TYPE D3D11_CBUFFER_TYPE;
25 alias D3D_TESSELLATOR_DOMAIN D3D11_TESSELLATOR_DOMAIN;
26 alias D3D_TESSELLATOR_PARTITIONING D3D11_TESSELLATOR_PARTITIONING;
27 alias D3D_TESSELLATOR_OUTPUT_PRIMITIVE D3D11_TESSELLATOR_OUTPUT_PRIMITIVE;
28 
29 ///
30 /// Functions
31 ///
32 
33 ///
34 /// Enumerations
35 ///
36 
37 enum D3D11_SHADER_VERSION_TYPE
38 {
39     PIXEL_SHADER    = 0,
40     VERTEX_SHADER   = 1,
41     GEOMETRY_SHADER = 2,
42     
43     // D3D11 Shaders
44     HULL_SHADER     = 3,
45     DOMAIN_SHADER   = 4,
46     COMPUTE_SHADER  = 5,
47 
48     RESERVED0       = 0xFFF0,
49 }
50 
51 ///
52 /// Structures
53 ///
54 
55 struct D3D11_SIGNATURE_PARAMETER_DESC
56 {
57     const char *SemanticName;
58     uint SemanticIndex;
59     uint Register;
60     D3D_NAME SystemValueType;
61     D3D_REGISTER_COMPONENT_TYPE ComponentType;
62     byte Mask;
63     byte ReadWriteMask;
64     uint Stream;
65     D3D_MIN_PRECISION MinPrecision;
66 }
67 
68 struct D3D11_SHADER_BUFFER_DESC
69 {
70     const char *Name;
71     D3D_CBUFFER_TYPE Type;
72     uint Variables;
73     uint Size;
74     uint uFlags;
75 }
76 
77 struct D3D11_SHADER_VARIABLE_DESC
78 {
79     const char *Name;
80     uint StartOffset;
81     uint Size;
82     uint uFlags;
83     void *DefaultValue;
84     uint StartTexture;
85     uint TextureSize;
86     uint StartSampler;
87     uint SamplerSize;
88 }
89 
90 struct D3D11_SHADER_TYPE_DESC
91 {
92     D3D_SHADER_VARIABLE_CLASS Class;
93     D3D_SHADER_VARIABLE_TYPE Type;
94     uint Rows;
95     uint Columns;
96     uint Elements;
97     uint Members;
98     uint Offset; 
99     const char *Name;
100 }
101 
102 struct D3D11_SHADER_DESC
103 {
104     uint Version;
105     const char *Creator;
106     uint Flags;
107     uint ConstantBuffers;
108     uint BoundResources;
109     uint InputParameters;
110     uint OutputParameters;
111     uint InstructionCount;
112     uint TempRegisterCount;
113     uint TempArrayCount;
114     uint DefCount;
115     uint DclCount;
116     uint TextureNormalInstructions;
117     uint TextureLoadInstructions;
118     uint TextureCompInstructions;
119     uint TextureBiasInstructions;
120     uint TextureGradientInstructions;
121     uint FloatInstructionCount;
122     uint IntInstructionCount;
123     uint UintInstructionCount;
124     uint StaticFlowControlCount;
125     uint DynamicFlowControlCount;
126     uint MacroInstructionCount;
127     uint ArrayInstructionCount;
128     uint CutInstructionCount;
129     uint EmitInstructionCount;
130     D3D_PRIMITIVE_TOPOLOGY GSOutputTopology;
131     uint GSMaxOutputVertexCount;
132     D3D_PRIMITIVE InputPrimitive;
133     uint PatchConstantParameters;
134     uint cGSInstanceCount;
135     uint cControlPoints;
136     D3D_TESSELLATOR_OUTPUT_PRIMITIVE HSOutputPrimitive;
137     D3D_TESSELLATOR_PARTITIONING HSPartitioning;
138     D3D_TESSELLATOR_DOMAIN TessellatorDomain;
139     uint cBarrierInstructions;
140     uint cInterlockedInstructions;
141     uint cTextureStoreInstructions;
142 }
143 
144 struct D3D11_SHADER_INPUT_BIND_DESC
145 {
146     const char *Name;
147     D3D_SHADER_INPUT_TYPE Type;
148     uint BindPoint;
149     uint BindCount;
150     uint uFlags;
151     D3D_RESOURCE_RETURN_TYPE ReturnType;
152     D3D_SRV_DIMENSION Dimension;
153     uint NumSamples;
154 }
155 
156 struct D3D11_LIBRARY_DESC
157 {
158     const char *Creator;
159     uint Flags;
160     uint FunctionCount;
161 }
162 
163 struct D3D11_FUNCTION_DESC
164 {
165     uint Version;
166     const char *Creator;
167     uint Flags;
168     uint ConstantBuffers;
169     uint BoundResources;
170     uint InstructionCount;
171     uint TempRegisterCount;
172     uint TempArrayCount;
173     uint DefCount;
174     uint DclCount;
175     uint TextureNormalInstructions;
176     uint TextureLoadInstructions;
177     uint TextureCompInstructions;
178     uint TextureBiasInstructions;
179     uint TextureGradientInstructions;
180     uint FloatInstructionCount;
181     uint IntInstructionCount;
182     uint UintInstructionCount;
183     uint StaticFlowControlCount;
184     uint DynamicFlowControlCount;
185     uint MacroInstructionCount;
186     uint ArrayInstructionCount;
187     uint MovInstructionCount;
188     uint MovcInstructionCount;
189     uint ConversionInstructionCount;
190     uint BitwiseInstructionCount;
191     D3D_FEATURE_LEVEL MinFeatureLevel;
192     ulong RequiredFeatureFlags;
193     const char *Name;
194     int FunctionParameterCount;
195     bool HasReturn;
196     bool Has10Level9VertexShader;
197     bool Has10Level9PixelShader;
198 }
199 
200 struct D3D11_PARAMETER_DESC
201 {
202     const char *Name;
203     const char *SemanticName;
204     D3D_SHADER_VARIABLE_TYPE Type;
205     D3D_SHADER_VARIABLE_CLASS Class;
206     uint Rows;
207     uint Columns;
208     D3D_INTERPOLATION_MODE InterpolationMode;
209     D3D_PARAMETER_FLAGS Flags;
210     uint FirstInRegister;
211     uint FirstInComponent;
212     uint FirstOutRegister;
213     uint FirstOutComponent;
214 }
215 
216 ///
217 /// Interfaces
218 ///
219 
220 mixin(uuid!(ID3D11ShaderReflectionType, "6E6FFA6A-9BAE-4613-A51E-91652D508C21"));
221 public interface ID3D11ShaderReflectionType : IUnknown
222 {
223 extern(Windows):
224     ID3D11ShaderReflectionType GetBaseClass();
225     HRESULT GetDesc(D3D11_SHADER_TYPE_DESC *pDesc);
226     ID3D11ShaderReflectionType GetInterfaceByIndex(uint uIndex);
227     ID3D11ShaderReflectionType* GetMemberTypeByIndex(uint Index);
228     ID3D11ShaderReflectionType* GetMemberTypeByName(const char *Name);
229     const char* GetMemberTypeName(uint Index);
230     uint GetNumInterfaces();
231     ID3D11ShaderReflectionType GetSubType();
232     HRESULT ImplementsInterface(ID3D11ShaderReflectionType pBase);
233     HRESULT IsEqual(ID3D11ShaderReflectionType pType);
234     HRESULT IsOfType(ID3D11ShaderReflectionType pType);
235 }
236 
237 mixin(uuid!(ID3D11ShaderReflectionVariable, "51F23923-F3E5-4BD1-91CB-606177D8DB4C"));
238 public interface ID3D11ShaderReflectionVariable : IUnknown
239 {
240 extern(Windows):
241     ID3D11ShaderReflectionConstantBuffer GetBuffer();
242     HRESULT GetDesc(D3D11_SHADER_VARIABLE_DESC pDesc);
243     uint GetInterfaceSlot(uint uArrayIndex);
244     ID3D11ShaderReflectionType GetType();
245 }
246 
247 mixin(uuid!(ID3D11ShaderReflectionConstantBuffer, "EB62D63D-93DD-4318-8AE8-C6F83AD371B8"));
248 public interface ID3D11ShaderReflectionConstantBuffer : IUnknown
249 {
250 extern(Windows):
251     HRESULT GetDesc(D3D11_SHADER_BUFFER_DESC *pDesc);
252     ID3D11ShaderReflectionVariable GetVariableByIndex(uint Index);
253     ID3D11ShaderReflectionVariable* GetVariableByName(const char *Name);
254 }
255 
256 mixin(uuid!(ID3D11ShaderReflection, "8d536ca1-0cca-4956-a837-786963755584"));
257 public interface ID3D11ShaderReflection : IUnknown
258 {
259 extern(Windows):
260     uint GetBitwiseInstructionCount();
261     ID3D11ShaderReflectionConstantBuffer GetConstantBufferByIndex(uint Index);
262     ID3D11ShaderReflectionConstantBuffer GetConstantBufferByName(const char *Name);
263     uint GetConversionInstructionCount();
264     HRESULT GetDesc(D3D11_SHADER_DESC *pDesc);
265     D3D_PRIMITIVE GetGSInputPrimitive();
266     HRESULT GetInputParameterDesc(uint ParameterIndex, D3D11_SIGNATURE_PARAMETER_DESC *pDesc);
267     HRESULT GetMinFeatureLevel(D3D_FEATURE_LEVEL *pLevel);
268     uint GetMovInstructionCount();
269     uint GetMovcInstructionCount();
270     uint GetNumInterfaceSlots();
271     HRESULT GetOutputParameterDesc(uint ParameterIndex, D3D11_SIGNATURE_PARAMETER_DESC *pDesc);
272     HRESULT GetPatchConstantParameterDesc(uint ParameterIndex, D3D11_SIGNATURE_PARAMETER_DESC *pDesc);
273     ulong GetRequiresFlags();
274     HRESULT GetResourceBindingDesc(uint ResourceIndex, D3D11_SHADER_INPUT_BIND_DESC *pDesc);
275     HRESULT GetResourceBindingDescByName(const char *Name, D3D11_SHADER_INPUT_BIND_DESC *pDesc);
276     uint GetThreadGroupSize(uint *pSizeX, uint *pSizeY, uint *pSizeZ);
277     ID3D11ShaderReflectionVariable* GetVariableByName(const char *Name);
278     bool IsSampleFrequencyShader();
279 }
280 
281 mixin(uuid!(ID3D11LibraryReflection, "54384F1B-5B3E-4BB7-AE01-60BA3097CBB6"));
282 public interface ID3D11LibraryReflection : IUnknown
283 {
284 extern(Windows):
285     HRESULT GetDesc(D3D11_LIBRARY_DESC *pDesc);
286     ID3D11FunctionReflection GetFunctionByIndex(int FunctionIndex);
287 }
288 
289 mixin(uuid!(ID3D11FunctionReflection, "207BCECB-D683-4A06-A8A3-9B149B9F73A4"));
290 public interface ID3D11FunctionReflection : IUnknown
291 {
292 extern(Windows):
293     ID3D11ShaderReflectionConstantBuffer GetConstantBufferByIndex(uint BufferIndex);
294     ID3D11ShaderReflectionConstantBuffer GetConstantBufferByName(const char *Name);
295     HRESULT GetDesc(D3D11_FUNCTION_DESC *pDesc);
296     ID3D11FunctionParameterReflection GetFunctionParameter(int ParameterIndex);
297     HRESULT GetResourceBindingDesc(uint ResourceIndex, D3D11_SHADER_INPUT_BIND_DESC *pDesc);
298     HRESULT GetResourceBindingDescByName(const char *Name, D3D11_SHADER_INPUT_BIND_DESC *pDesc);
299     ID3D11ShaderReflectionVariable* GetVariableByName(const char *Name);
300 }
301 
302 mixin(uuid!(ID3D11FunctionParameterReflection, "42757488-334F-47FE-982E-1A65D08CC462"));
303 public interface ID3D11FunctionParameterReflection : IUnknown
304 {
305 extern(Windows):
306     HRESULT GetDesc(D3D11_PARAMETER_DESC *pDesc);
307 }
308 
309 mixin(uuid!(ID3D11Module, "CAC701EE-80FC-4122-8242-10B39C8CEC34"));
310 public interface ID3D11Module : IUnknown
311 {
312 extern(Windows):
313     HRESULT CreateInstance(const char *pNamespace, ID3D11ModuleInstance *ppModuleInstance);
314 }
315 
316 mixin(uuid!(ID3D11ModuleInstance, "469E07F7-045A-48D5-AA12-68A478CDF75D"));
317 public interface ID3D11ModuleInstance : IUnknown
318 {
319 extern(Windows):
320     HRESULT BindConstantBuffer(uint uSrcSlot, uint uDstSlot, uint cbDstOffset);
321     HRESULT BindConstantBufferByName(const char *pName, uint uDstSlot, uint cbDstOffset);
322     HRESULT BindResource(uint uSrcSlot, uint uDstSlot, uint uCount);
323     HRESULT BindResourceAsUnorderedAccessView(uint uSrcSrvSlot, uint uDstUavSlot, uint uCount);
324     HRESULT BindResourceAsUnorderedAccessViewByName(const char *pSrvName, uint uDstUavSlot, uint uCount);
325     HRESULT BindResourceByName(const char *pName, uint uDstSlot, uint uCount);
326     HRESULT BindSampler(uint uSrcSlot, uint uDstSlot, uint uCount);
327     HRESULT BindSamplerByName(const char *pName, uint uDstSlot, uint uCount);
328     HRESULT BindUnorderedAccessView(uint uSrcSlot, uint uDstSlot, uint uCount);
329     HRESULT BindUnorderedAccessViewByName(const char *pName, uint uDstSlot, uint uCount);
330 }
331 
332 mixin(uuid!(ID3D11Linker, "59A6CD0E-E10D-4C1F-88C0-63ABA1DAF30E"));
333 public interface ID3D11Linker : IUnknown
334 {
335 extern(Windows):
336     HRESULT AddClipPlaneFromCBuffer(uint uCBufferSlot, uint uCBufferEntry);
337     HRESULT Link(ID3D11ModuleInstance pEntry, const char *pEntryName, const char *pTargetName, uint uFlags, ID3DBlob *ppShaderBlob, ID3DBlob *ppErrorBuffer);
338     HRESULT UseLibrary(ID3D11ModuleInstance pLibraryMI);
339 }
340 
341 mixin(uuid!(ID3D11LinkingNode, "D80DD70C-8D2F-4751-94A1-03C79B3556DB"));
342 public interface ID3D11LinkingNode : IUnknown
343 {
344 extern(Windows):
345 }
346 
347 mixin(uuid!(ID3D11FunctionLinkingGraph, "54133220-1CE8-43D3-8236-9855C5CEECFF"));
348 public interface ID3D11FunctionLinkingGraph : IUnknown
349 {
350 extern(Windows):
351     HRESULT CallFunction(const char *pModuleInstanceNamespace, ID3D11Module pModuleWithFunctionPrototype, const char *pFunctionName, ID3D11LinkingNode *ppCallNode);
352     HRESULT CreateModuleInstance(ID3D11ModuleInstance *ppModuleInstance, ID3DBlob *ppErrorBuffer);
353     HRESULT GenerateHlsl(uint uFlags, ID3DBlob *ppBuffer);
354     HRESULT GetLastError(ID3DBlob *ppErrorBuffer);
355     HRESULT PassValue(ID3D11LinkingNode pSrcNode, int SrcParameterIndex, ID3D11LinkingNode pDstNode, int DstParameterIndex);
356     HRESULT PassValueWithSwizzle(ID3D11LinkingNode pSrcNode, int SrcParameterIndex, const char *pSrcSwizzle, ID3D11LinkingNode pDstNode, int DstParameterIndex, const char *pDstSwizzle);
357     HRESULT SetInputSignature(const D3D11_PARAMETER_DESC *pInputParameters, uint  cInputParameters, ID3D11LinkingNode *ppInputNode);
358     HRESULT SetOutputSignature(const D3D11_PARAMETER_DESC *pOutputParameters, uint cOutputParameters, ID3D11LinkingNode *ppOutputNode);
359 }