diff --git a/src/Generator/Program.cs b/src/Generator/Program.cs index b4b7425..d12fc8c 100644 --- a/src/Generator/Program.cs +++ b/src/Generator/Program.cs @@ -19,6 +19,7 @@ public static class Program "Graphics.Direct3D.json", "Graphics.Direct3D11.json", "Graphics.Direct3D12.json", + "Graphics.Direct3D.Dxc.json", //"Graphics.Imaging.json", }; @@ -53,8 +54,8 @@ public static class Program { "Foundation.LPARAM", "IntPtr" }, { "Foundation.LRESULT", "IntPtr" }, { "Foundation.WPARAM", "UIntPtr" }, - { "Foundation.PSTR", "byte*" }, - { "Foundation.PWSTR", "char*" }, + { "Foundation.PSTR", "sbyte*" }, + { "Foundation.PWSTR", "ushort*" }, { "Foundation.CHAR", "byte" }, { "Foundation.LUID", "Luid" }, @@ -64,6 +65,7 @@ public static class Program { "System.Com.IUnknown", "IUnknown" }, { "System.Com.ISequentialStream", "Com.ISequentialStream" }, { "System.Com.IStream", "Com.IStream" }, + { "System.Com.IMalloc", "Com.IMalloc" }, { "Graphics.Gdi.HMONITOR", "IntPtr" }, { "Graphics.Gdi.HDC", "IntPtr" }, @@ -82,7 +84,6 @@ public static class Program { "Foundation.SIZE", "System.Drawing.Size" }, }; - private static readonly Dictionary s_partRenames = new() { { "NONPREROTATED", "NonPrerotated" }, @@ -210,6 +211,10 @@ public static class Program "ExecuteExtensionCommand", "ResolveEncoderOutputMetadata", "ResolveSubresourceRegion", + "InPlaceEdit", + "RootSignatureOnly", + "ModuleOnly", + "ValidMask", }; private static readonly HashSet s_preserveCaps = new(StringComparer.OrdinalIgnoreCase) @@ -276,6 +281,9 @@ public static class Program { "D3D12_DEBUG_DEVICE_PARAMETER_TYPE", "D3D12_DEBUG_DEVICE_PARAMETER" }, { "D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE", "D3D12_DEBUG_COMMAND_LIST_PARAMETER" }, { "D3D12_SHADER_VERSION_TYPE", "D3D12_SHVER" }, + + // Dxc + { "DXC_OUT_KIND", "DXC_OUT" }, }; private static readonly Dictionary s_knownEnumValueNames = new() @@ -310,6 +318,9 @@ public static class Program {"DXGI_PRESENT", true }, {"DXGI_MWA", true }, {"DXGI_ENUM_MODES", true }, + {"DXC_HASHFLAG", true }, + {"DxcValidatorFlags", true }, + {"DxcVersionInfoFlags", true }, }; private static readonly HashSet s_ignoredStartParts = new(StringComparer.OrdinalIgnoreCase) @@ -343,6 +354,11 @@ public static class Program // D2D1 { "D2D1_2DAFFINETRANSFORM_INTERPOLATION_MODE", "AffineTransform2DInterpolationMode" }, + + // Dxc + { "DXC_HASHFLAG", "DxcHashFlags" }, + { "DxcValidatorFlags", "DxcValidatorFlags" }, + { "DxcVersionInfoFlags", "DxcVersionInfoFlags" }, }; private static readonly Dictionary s_structFieldTypeRemap = new() @@ -382,6 +398,9 @@ public static class Program // D3D12 { "D3D12_RENDER_TARGET_BLEND_DESC::RenderTargetWriteMask", "D3D12_COLOR_WRITE_ENABLE" }, + + // Dxc + { "DxcShaderHash::Flags", "DXC_HASHFLAG" }, }; private static readonly Dictionary s_mapFunctionParameters = new() @@ -506,7 +525,8 @@ public static class Program string typeName = GetTypeName(constant.Type); if (typeName == "Guid") { - writer.WriteLine($"public static readonly Guid {constant.Name} = {FormatGuid(constant.Value.ToString())};"); + WriteGuid(writer, constant.Value.ToString(), constant.Name); + writer.WriteLine(); } else if (typeName == "HResult") { @@ -772,12 +792,12 @@ public static class Program foreach (ApiParameter parameter in function.Params) { bool asPointer = false; - string parameterType = default; + string parameterType = string.Empty; if (parameter.Type.Kind == "ApiRef") { if (parameter.Type.TargetKind == "FunctionPointer") { - var functionType = api.Types.First(item => item.Name == parameter.Type.Name && item.Kind == "FunctionPointer"); + ApiType functionType = api.Types.First(item => item.Name == parameter.Type.Name && item.Kind == "FunctionPointer"); parameterType = "delegate* unmanaged[Stdcall]"; } else @@ -967,8 +987,15 @@ public static class Program } else { - csTypeName = GetDataTypeName(structType.Name, out structPrefix); - AddCsMapping(writer.Api, structType.Name, csTypeName); + if (structType.Name.StartsWith("Dxc")) + { + csTypeName = structType.Name; + } + else + { + csTypeName = GetDataTypeName(structType.Name, out structPrefix); + AddCsMapping(writer.Api, structType.Name, csTypeName); + } writer.WriteLine($"/// "); @@ -1219,51 +1246,7 @@ public static class Program if (comType.Guid != null) { // Generate IID - using (writer.PushBlock($"public static ref readonly Guid IID_{csTypeName}")) - { - writer.WriteLine("[MethodImpl(MethodImplOptions.AggressiveInlining)]"); - using (writer.PushBlock("get")) - { - var guid = Guid.Parse(comType.Guid).ToString("N"); - var _1 = "0x" + guid.Substring(6, 2).ToUpperInvariant(); - var _2 = "0x" + guid.Substring(4, 2).ToUpperInvariant(); - var _3 = "0x" + guid.Substring(2, 2).ToUpperInvariant(); - var _4 = "0x" + guid.Substring(0, 2).ToUpperInvariant(); - - var _5 = "0x" + guid.Substring(10, 2).ToUpperInvariant(); - var _6 = "0x" + guid.Substring(8, 2).ToUpperInvariant(); - - var _7 = "0x" + guid.Substring(14, 2).ToUpperInvariant(); - var _8 = "0x" + guid.Substring(12, 2).ToUpperInvariant(); - - var d = "0x" + guid.Substring(16, 2).ToUpperInvariant(); - var e = "0x" + guid.Substring(18, 2).ToUpperInvariant(); - var f = "0x" + guid.Substring(20, 2).ToUpperInvariant(); - var g = "0x" + guid.Substring(22, 2).ToUpperInvariant(); - var h = "0x" + guid.Substring(24, 2).ToUpperInvariant(); - var i = "0x" + guid.Substring(26, 2).ToUpperInvariant(); - var j = "0x" + guid.Substring(28, 2).ToUpperInvariant(); - var k = "0x" + guid.Substring(30, 2).ToUpperInvariant(); - - writer.WriteLine("ReadOnlySpan data = new byte[] {"); - writer.WriteLine($"{'\t'}{_1}, {_2}, {_3}, {_4},"); - writer.WriteLine($"{'\t'}{_5}, {_6},"); - writer.WriteLine($"{'\t'}{_7}, {_8},"); - writer.WriteLine($"{'\t'}{d},"); - writer.WriteLine($"{'\t'}{e},"); - writer.WriteLine($"{'\t'}{f},"); - writer.WriteLine($"{'\t'}{g},"); - writer.WriteLine($"{'\t'}{h},"); - writer.WriteLine($"{'\t'}{i},"); - writer.WriteLine($"{'\t'}{j},"); - writer.WriteLine($"{'\t'}{k}"); - writer.WriteLine("};"); - writer.WriteLine(); - - writer.WriteLine("Debug.Assert(data.Length == Unsafe.SizeOf());"); - writer.WriteLine("return ref Unsafe.As(ref MemoryMarshal.GetReference(data));"); - } - } + WriteGuid(writer, comType.Guid, $"IID_{csTypeName}"); writer.WriteLine(); writer.WriteLine($"public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_{csTypeName}));"); @@ -1338,12 +1321,18 @@ public static class Program foreach (ApiParameter parameter in method.Params) { bool asPointer = false; - string parameterType = default; + string parameterType = string.Empty; + + + if (method.Name == "Compile" && parameter.Name == "pArguments") + { + } + if (parameter.Type.Kind == "ApiRef") { if (parameter.Type.TargetKind == "FunctionPointer") { - var functionType = api.Types.First(item => item.Name == parameter.Type.Name && item.Kind == "FunctionPointer"); + ApiType functionType = api.Types.First(item => item.Name == parameter.Type.Name && item.Kind == "FunctionPointer"); parameterType = "delegate* unmanaged[Stdcall]"; } else @@ -1374,11 +1363,6 @@ public static class Program parameterType = NormalizeTypeName(writer.Api, parameterType); string parameterName = parameter.Name; - if (method.Name == "RSSetScissorRects" && parameterName == "pRects") - { - - } - bool isOptional = parameter.Attrs.Any(item => item is string str && str == "Optional"); if (parameter.Attrs.Any(item => item is string str && str == "ComOutPtr")) { @@ -1776,23 +1760,53 @@ public static class Program return prettyName; } - private static string FormatGuid(string value) + private static void WriteGuid(CodeWriter writer, string guidValue, string guidName) { - var guid = Guid.Parse(value).ToString("N"); + using (writer.PushBlock($"public static ref readonly Guid {guidName}")) + { + writer.WriteLine("[MethodImpl(MethodImplOptions.AggressiveInlining)]"); + using (writer.PushBlock("get")) + { + var guid = Guid.Parse(guidValue).ToString("N"); + var _1 = "0x" + guid.Substring(6, 2).ToUpperInvariant(); + var _2 = "0x" + guid.Substring(4, 2).ToUpperInvariant(); + var _3 = "0x" + guid.Substring(2, 2).ToUpperInvariant(); + var _4 = "0x" + guid.Substring(0, 2).ToUpperInvariant(); - var a = "0x" + guid.Substring(0, 8); - var b = "0x" + guid.Substring(8, 4); - var c = "0x" + guid.Substring(12, 4); - var d = "0x" + guid.Substring(16, 2); - var e = "0x" + guid.Substring(18, 2); - var f = "0x" + guid.Substring(20, 2); - var g = "0x" + guid.Substring(22, 2); - var h = "0x" + guid.Substring(24, 2); - var i = "0x" + guid.Substring(26, 2); - var j = "0x" + guid.Substring(28, 2); - var k = "0x" + guid.Substring(30, 2); + var _5 = "0x" + guid.Substring(10, 2).ToUpperInvariant(); + var _6 = "0x" + guid.Substring(8, 2).ToUpperInvariant(); - return $"new Guid({a}, {b}, {c}, {d}, {e}, {f}, {g}, {h}, {i}, {j}, {k})"; + var _7 = "0x" + guid.Substring(14, 2).ToUpperInvariant(); + var _8 = "0x" + guid.Substring(12, 2).ToUpperInvariant(); + + var d = "0x" + guid.Substring(16, 2).ToUpperInvariant(); + var e = "0x" + guid.Substring(18, 2).ToUpperInvariant(); + var f = "0x" + guid.Substring(20, 2).ToUpperInvariant(); + var g = "0x" + guid.Substring(22, 2).ToUpperInvariant(); + var h = "0x" + guid.Substring(24, 2).ToUpperInvariant(); + var i = "0x" + guid.Substring(26, 2).ToUpperInvariant(); + var j = "0x" + guid.Substring(28, 2).ToUpperInvariant(); + var k = "0x" + guid.Substring(30, 2).ToUpperInvariant(); + + writer.WriteLine("ReadOnlySpan data = new byte[] {"); + writer.WriteLine($"{'\t'}{_1}, {_2}, {_3}, {_4},"); + writer.WriteLine($"{'\t'}{_5}, {_6},"); + writer.WriteLine($"{'\t'}{_7}, {_8},"); + writer.WriteLine($"{'\t'}{d},"); + writer.WriteLine($"{'\t'}{e},"); + writer.WriteLine($"{'\t'}{f},"); + writer.WriteLine($"{'\t'}{g},"); + writer.WriteLine($"{'\t'}{h},"); + writer.WriteLine($"{'\t'}{i},"); + writer.WriteLine($"{'\t'}{j},"); + writer.WriteLine($"{'\t'}{k}"); + writer.WriteLine("};"); + writer.WriteLine(); + + writer.WriteLine("Debug.Assert(data.Length == Unsafe.SizeOf());"); + writer.WriteLine("return ref Unsafe.As(ref MemoryMarshal.GetReference(data));"); + } + } } private static string GetApiName(ApiDataType dataType) @@ -1848,12 +1862,21 @@ public static class Program private static bool IsPrimitive(string typeName) { + if (typeName.EndsWith("*")) + { + typeName = typeName.Substring(0, typeName.Length - 1); + } + switch (typeName) { case "void": case "bool": + case "byte": + case "sbyte": case "int": case "uint": + case "short": + case "ushort": case "Bool32": return true; @@ -1878,6 +1901,10 @@ public static class Program { return IsPrimitive(dataType.Child); } + else if (dataType.Kind == "LPArray") + { + return IsPrimitive(dataType.Child); + } if (dataType.Kind != "Native") { diff --git a/src/Vortice.Win32/Com/IMalloc.cs b/src/Vortice.Win32/Com/IMalloc.cs new file mode 100644 index 0000000..0049b5b --- /dev/null +++ b/src/Vortice.Win32/Com/IMalloc.cs @@ -0,0 +1,110 @@ +// Copyright © Amer Koleci and Contributors. +// Licensed under the MIT License (MIT). See LICENSE in the repository root for more information. + +using System.Diagnostics; +using System.Runtime.CompilerServices; + +namespace Win32.Com; + +[Guid("00000002-0000-0000-C000-000000000046")] +[NativeTypeName("struct IMalloc : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IMalloc +{ + public static ref readonly Guid IID_IMalloc + { + get + { + ReadOnlySpan data = new byte[] { + 0x02, 0x00, 0x00, 0x00, + 0x00, 0x00, + 0x00, 0x00, + 0xC0, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x46 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IMalloc)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((ISequentialStream*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((ISequentialStream*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((ISequentialStream*)Unsafe.AsPointer(ref this)); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void* Alloc([NativeTypeName("SIZE_T")] nuint cb) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IMalloc*)Unsafe.AsPointer(ref this), cb); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void* Realloc(void* pv, [NativeTypeName("SIZE_T")] nuint cb) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IMalloc*)Unsafe.AsPointer(ref this), pv, cb); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public void Free(void* pv) + { + ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IMalloc*)Unsafe.AsPointer(ref this), pv); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + [return: NativeTypeName("SIZE_T")] + public nuint GetSize(void* pv) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IMalloc*)Unsafe.AsPointer(ref this), pv); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public int DidAlloc(void* pv) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IMalloc*)Unsafe.AsPointer(ref this), pv); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public void HeapMinimize() + { + ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IMalloc*)Unsafe.AsPointer(ref this)); + } +} diff --git a/src/Vortice.Win32/Generated/Dxc.xml b/src/Vortice.Win32/Generated/Dxc.xml new file mode 100644 index 0000000..442da29 --- /dev/null +++ b/src/Vortice.Win32/Generated/Dxc.xml @@ -0,0 +1,2 @@ + + \ No newline at end of file diff --git a/src/Vortice.Win32/Generated/Graphics/Direct3D.Dxc.cs b/src/Vortice.Win32/Generated/Graphics/Direct3D.Dxc.cs new file mode 100644 index 0000000..d2f8299 --- /dev/null +++ b/src/Vortice.Win32/Generated/Graphics/Direct3D.Dxc.cs @@ -0,0 +1,3045 @@ +// ------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +// ------------------------------------------------------------------------------ + +using System.Diagnostics; +using System.Runtime.CompilerServices; + +#if !NET6_0_OR_GREATER +using MemoryMarshal = Win32.MemoryMarshal; +#endif + +namespace Win32.Graphics.Direct3D.Dxc; + +public static partial class Apis +{ + public static ref readonly Guid CLSID_DxcCompiler + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x93, 0x2D, 0xE2, 0x73, + 0xCE, 0xE6, + 0xF3, 0x47, + 0xB5, + 0xBF, + 0xF0, + 0x66, + 0x4F, + 0x39, + 0xC1, + 0xB0 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_DxcLinker + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x87, 0x80, 0x6A, 0xEF, + 0xEA, 0xB0, + 0x56, 0x4D, + 0x9E, + 0x45, + 0xD0, + 0x7E, + 0x1A, + 0x8B, + 0x78, + 0x06 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_DxcDiaDataSource + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x73, 0x6B, 0x1F, 0xCD, + 0xB0, 0x2A, + 0x4D, 0x48, + 0x8E, + 0xDC, + 0xEB, + 0xE7, + 0xA4, + 0x3C, + 0xA0, + 0x9F + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_DxcCompilerArgs + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x82, 0xAE, 0x56, 0x3E, + 0x4D, 0x22, + 0x0F, 0x47, + 0xA1, + 0xA1, + 0xFE, + 0x30, + 0x16, + 0xEE, + 0x9F, + 0x9D + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_DxcLibrary + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xAF, 0xD6, 0x45, 0x62, + 0xE0, 0x66, + 0xFD, 0x48, + 0x80, + 0xB4, + 0x4D, + 0x27, + 0x17, + 0x96, + 0x74, + 0x8C + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_DxcValidator + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x15, 0xE2, 0xA3, 0x8C, + 0x28, 0xF7, + 0xF3, 0x4C, + 0x8C, + 0xDD, + 0x88, + 0xAF, + 0x91, + 0x75, + 0x87, + 0xA1 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_DxcAssembler + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x68, 0xDB, 0x28, 0xD7, + 0x03, 0xF9, + 0x80, 0x4F, + 0x94, + 0xCD, + 0xDC, + 0xCF, + 0x76, + 0xEC, + 0x71, + 0x51 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_DxcContainerReflection + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x89, 0x44, 0xF5, 0xB9, + 0xB8, 0x55, + 0x0C, 0x40, + 0xBA, + 0x3A, + 0x16, + 0x75, + 0xE4, + 0x72, + 0x8B, + 0x91 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_DxcOptimizer + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x9F, 0xD7, 0x2C, 0xAE, + 0x22, 0xCC, + 0x3F, 0x45, + 0x9B, + 0x6B, + 0xB1, + 0x24, + 0xE7, + 0xA5, + 0x20, + 0x4C + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_DxcContainerBuilder + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x94, 0x42, 0x13, 0x94, + 0x1F, 0x41, + 0x74, 0x45, + 0xB4, + 0xD0, + 0x87, + 0x41, + 0xE2, + 0x52, + 0x40, + 0xD2 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_DxcPdbUtils + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xFB, 0x1D, 0x62, 0x54, + 0xCE, 0xF2, + 0x7E, 0x45, + 0xAE, + 0x8C, + 0xEC, + 0x35, + 0x5F, + 0xAE, + 0xEC, + 0x7C + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + +} + +#region Enums +/// +/// DXC_CP +public enum DxcCp : uint +{ + /// + /// DXC_CP_ACP + Acp = 0, + /// + /// DXC_CP_UTF16 + Utf16 = 1200, + /// + /// DXC_CP_UTF8 + Utf8 = 65001, +} + +/// +/// DXC_OUT_KIND +public enum DxcOutKind : int +{ + /// + /// DXC_OUT_NONE + None = 0, + /// + /// DXC_OUT_OBJECT + Object = 1, + /// + /// DXC_OUT_ERRORS + Errors = 2, + /// + /// DXC_OUT_PDB + Pdb = 3, + /// + /// DXC_OUT_SHADER_HASH + ShaderHash = 4, + /// + /// DXC_OUT_DISASSEMBLY + Disassembly = 5, + /// + /// DXC_OUT_HLSL + Hlsl = 6, + /// + /// DXC_OUT_TEXT + Text = 7, + /// + /// DXC_OUT_REFLECTION + Reflection = 8, + /// + /// DXC_OUT_ROOT_SIGNATURE + RootSignature = 9, + /// + /// DXC_OUT_EXTRA_OUTPUTS + ExtraOutputs = 10, +} + +#endregion Enums + +#region Generated Enums +/// DXC_HASHFLAG +[Flags] +public enum DxcHashFlags : uint +{ + None = 0, + /// DXC_HASHFLAG_INCLUDES_SOURCE + IncludesSource = 1, +} + +/// DxcValidatorFlags +[Flags] +public enum DxcValidatorFlags : uint +{ + None = 0, + /// DxcValidatorFlags_Default + Default = 0, + /// DxcValidatorFlags_InPlaceEdit + InPlaceEdit = 1, + /// DxcValidatorFlags_RootSignatureOnly + RootSignatureOnly = 2, + /// DxcValidatorFlags_ModuleOnly + ModuleOnly = 4, + /// DxcValidatorFlags_ValidMask + ValidMask = 7, +} + +/// DxcVersionInfoFlags +[Flags] +public enum DxcVersionInfoFlags : uint +{ + /// DxcVersionInfoFlags_None + None = 0, + /// DxcVersionInfoFlags_Debug + Debug = 1, + /// DxcVersionInfoFlags_Internal + Internal = 2, +} + +#endregion Generated Enums + +#region Structs +/// +/// DxcShaderHash +public partial struct DxcShaderHash +{ + /// + public DxcHashFlags Flags; + + /// + public unsafe fixed byte Hashdigest[16]; +} + +/// +/// DxcBuffer +public partial struct DxcBuffer +{ + /// + public unsafe void* Ptr; + + /// + public nuint Size; + + /// + public uint Encoding; +} + +/// +/// DxcDefine +public partial struct DxcDefine +{ + /// + public unsafe ushort* Name; + + /// + public unsafe ushort* Value; +} + +/// +/// DxcArgPair +public partial struct DxcArgPair +{ + /// + public unsafe ushort* Pname; + + /// + public unsafe ushort* Pvalue; +} + +#endregion Structs + +#region COM Types +/// +/// IDxcBlob +[Guid("8ba5fb08-5195-40e2-ac58-0d989c3a0102")] +[NativeTypeName("struct IDxcBlob : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDxcBlob +{ + public static ref readonly Guid IID_IDxcBlob + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x08, 0xFB, 0xA5, 0x8B, + 0x95, 0x51, + 0xE2, 0x40, + 0xAC, + 0x58, + 0x0D, + 0x98, + 0x9C, + 0x3A, + 0x01, + 0x02 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcBlob)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void* GetBufferPointer() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDxcBlob*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public nuint GetBufferSize() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDxcBlob*)Unsafe.AsPointer(ref this)); + } + +} + +/// +/// IDxcBlobEncoding +[Guid("7241d424-2646-4191-97c0-98e96e42fc68")] +[NativeTypeName("struct IDxcBlobEncoding : IDxcBlob")] +[NativeInheritance("IDxcBlob")] +public unsafe partial struct IDxcBlobEncoding +{ + public static ref readonly Guid IID_IDxcBlobEncoding + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xD4, 0x41, 0x72, + 0x46, 0x26, + 0x91, 0x41, + 0x97, + 0xC0, + 0x98, + 0xE9, + 0x6E, + 0x42, + 0xFC, + 0x68 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcBlobEncoding)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void* GetBufferPointer() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDxcBlobEncoding*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public nuint GetBufferSize() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDxcBlobEncoding*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetEncoding(Bool32* pKnown, DxcCp* pCodePage) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDxcBlobEncoding*)Unsafe.AsPointer(ref this), pKnown, pCodePage); + } + +} + +/// +/// IDxcBlobUtf16 +[Guid("a3f84eab-0faa-497e-a39c-ee6ed60b2d84")] +[NativeTypeName("struct IDxcBlobUtf16 : IDxcBlobEncoding")] +[NativeInheritance("IDxcBlobEncoding")] +public unsafe partial struct IDxcBlobUtf16 +{ + public static ref readonly Guid IID_IDxcBlobUtf16 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xAB, 0x4E, 0xF8, 0xA3, + 0xAA, 0x0F, + 0x7E, 0x49, + 0xA3, + 0x9C, + 0xEE, + 0x6E, + 0xD6, + 0x0B, + 0x2D, + 0x84 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcBlobUtf16)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetEncoding(Bool32* pKnown, DxcCp* pCodePage) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDxcBlobUtf16*)Unsafe.AsPointer(ref this), pKnown, pCodePage); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void* GetBufferPointer() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDxcBlobUtf16*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public nuint GetBufferSize() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDxcBlobUtf16*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public ushort* GetStringPointer() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDxcBlobUtf16*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public nuint GetStringLength() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDxcBlobUtf16*)Unsafe.AsPointer(ref this)); + } + +} + +/// +/// IDxcBlobUtf8 +[Guid("3da636c9-ba71-4024-a301-30cbf125305b")] +[NativeTypeName("struct IDxcBlobUtf8 : IDxcBlobEncoding")] +[NativeInheritance("IDxcBlobEncoding")] +public unsafe partial struct IDxcBlobUtf8 +{ + public static ref readonly Guid IID_IDxcBlobUtf8 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xC9, 0x36, 0xA6, 0x3D, + 0x71, 0xBA, + 0x24, 0x40, + 0xA3, + 0x01, + 0x30, + 0xCB, + 0xF1, + 0x25, + 0x30, + 0x5B + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcBlobUtf8)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetEncoding(Bool32* pKnown, DxcCp* pCodePage) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDxcBlobUtf8*)Unsafe.AsPointer(ref this), pKnown, pCodePage); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void* GetBufferPointer() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDxcBlobUtf8*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public nuint GetBufferSize() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDxcBlobUtf8*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public sbyte* GetStringPointer() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDxcBlobUtf8*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public nuint GetStringLength() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDxcBlobUtf8*)Unsafe.AsPointer(ref this)); + } + +} + +/// +/// IDxcIncludeHandler +[Guid("7f61fc7d-950d-467f-b3e3-3c02fb49187c")] +[NativeTypeName("struct IDxcIncludeHandler : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDxcIncludeHandler +{ + public static ref readonly Guid IID_IDxcIncludeHandler + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x7D, 0xFC, 0x61, 0x7F, + 0x0D, 0x95, + 0x7F, 0x46, + 0xB3, + 0xE3, + 0x3C, + 0x02, + 0xFB, + 0x49, + 0x18, + 0x7C + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcIncludeHandler)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult LoadSource(ushort* pFilename, IDxcBlob** ppIncludeSource) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDxcIncludeHandler*)Unsafe.AsPointer(ref this), pFilename, ppIncludeSource); + } + +} + +/// +/// IDxcCompilerArgs +[Guid("73effe2a-70dc-45f8-9690-eff64c02429d")] +[NativeTypeName("struct IDxcCompilerArgs : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDxcCompilerArgs +{ + public static ref readonly Guid IID_IDxcCompilerArgs + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x2A, 0xFE, 0xEF, 0x73, + 0xDC, 0x70, + 0xF8, 0x45, + 0x96, + 0x90, + 0xEF, + 0xF6, + 0x4C, + 0x02, + 0x42, + 0x9D + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcCompilerArgs)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public ushort** GetArguments() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDxcCompilerArgs*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public uint GetCount() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDxcCompilerArgs*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult AddArguments(ushort** pArguments, uint argCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDxcCompilerArgs*)Unsafe.AsPointer(ref this), pArguments, argCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult AddArgumentsUTF8(sbyte** pArguments, uint argCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDxcCompilerArgs*)Unsafe.AsPointer(ref this), pArguments, argCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult AddDefines(DxcDefine* pDefines, uint defineCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDxcCompilerArgs*)Unsafe.AsPointer(ref this), pDefines, defineCount); + } + +} + +/// +/// IDxcLibrary +[Guid("e5204dc7-d18c-4c3c-bdfb-851673980fe7")] +[NativeTypeName("struct IDxcLibrary : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDxcLibrary +{ + public static ref readonly Guid IID_IDxcLibrary + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xC7, 0x4D, 0x20, 0xE5, + 0x8C, 0xD1, + 0x3C, 0x4C, + 0xBD, + 0xFB, + 0x85, + 0x16, + 0x73, + 0x98, + 0x0F, + 0xE7 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcLibrary)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult SetMalloc(Com.IMalloc* pMalloc) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDxcLibrary*)Unsafe.AsPointer(ref this), pMalloc); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult CreateBlobFromBlob(IDxcBlob* pBlob, uint offset, uint length, IDxcBlob** ppResult) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDxcLibrary*)Unsafe.AsPointer(ref this), pBlob, offset, length, ppResult); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult CreateBlobFromFile(ushort* pFileName, DxcCp* codePage, IDxcBlobEncoding** pBlobEncoding) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDxcLibrary*)Unsafe.AsPointer(ref this), pFileName, codePage, pBlobEncoding); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult CreateBlobWithEncodingFromPinned(void* pText, uint size, DxcCp codePage, IDxcBlobEncoding** pBlobEncoding) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDxcLibrary*)Unsafe.AsPointer(ref this), pText, size, codePage, pBlobEncoding); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult CreateBlobWithEncodingOnHeapCopy(void* pText, uint size, DxcCp codePage, IDxcBlobEncoding** pBlobEncoding) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDxcLibrary*)Unsafe.AsPointer(ref this), pText, size, codePage, pBlobEncoding); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult CreateBlobWithEncodingOnMalloc(void* pText, Com.IMalloc* pIMalloc, uint size, DxcCp codePage, IDxcBlobEncoding** pBlobEncoding) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDxcLibrary*)Unsafe.AsPointer(ref this), pText, pIMalloc, size, codePage, pBlobEncoding); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult CreateIncludeHandler(IDxcIncludeHandler** ppResult) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDxcLibrary*)Unsafe.AsPointer(ref this), ppResult); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult CreateStreamFromBlobReadOnly(IDxcBlob* pBlob, Com.IStream** ppStream) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDxcLibrary*)Unsafe.AsPointer(ref this), pBlob, ppStream); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult GetBlobAsUtf8(IDxcBlob* pBlob, IDxcBlobEncoding** pBlobEncoding) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDxcLibrary*)Unsafe.AsPointer(ref this), pBlob, pBlobEncoding); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult GetBlobAsUtf16(IDxcBlob* pBlob, IDxcBlobEncoding** pBlobEncoding) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IDxcLibrary*)Unsafe.AsPointer(ref this), pBlob, pBlobEncoding); + } + +} + +/// +/// IDxcOperationResult +[Guid("cedb484a-d4e9-445a-b991-ca21ca157dc2")] +[NativeTypeName("struct IDxcOperationResult : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDxcOperationResult +{ + public static ref readonly Guid IID_IDxcOperationResult + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x4A, 0x48, 0xDB, 0xCE, + 0xE9, 0xD4, + 0x5A, 0x44, + 0xB9, + 0x91, + 0xCA, + 0x21, + 0xCA, + 0x15, + 0x7D, + 0xC2 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcOperationResult)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetStatus(HResult* pStatus) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDxcOperationResult*)Unsafe.AsPointer(ref this), pStatus); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetResult(IDxcBlob** ppResult) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDxcOperationResult*)Unsafe.AsPointer(ref this), ppResult); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetErrorBuffer(IDxcBlobEncoding** ppErrors) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDxcOperationResult*)Unsafe.AsPointer(ref this), ppErrors); + } + +} + +/// +/// IDxcCompiler +[Guid("8c210bf3-011f-4422-8d70-6f9acb8db617")] +[NativeTypeName("struct IDxcCompiler : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDxcCompiler +{ + public static ref readonly Guid IID_IDxcCompiler + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xF3, 0x0B, 0x21, 0x8C, + 0x1F, 0x01, + 0x22, 0x44, + 0x8D, + 0x70, + 0x6F, + 0x9A, + 0xCB, + 0x8D, + 0xB6, + 0x17 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcCompiler)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult Compile(IDxcBlob* pSource, ushort* pSourceName, ushort* pEntryPoint, ushort* pTargetProfile, ushort** pArguments, uint argCount, DxcDefine* pDefines, uint defineCount, IDxcIncludeHandler* pIncludeHandler, IDxcOperationResult** ppResult) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDxcCompiler*)Unsafe.AsPointer(ref this), pSource, pSourceName, pEntryPoint, pTargetProfile, pArguments, argCount, pDefines, defineCount, pIncludeHandler, ppResult); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult Preprocess(IDxcBlob* pSource, ushort* pSourceName, ushort** pArguments, uint argCount, DxcDefine* pDefines, uint defineCount, IDxcIncludeHandler* pIncludeHandler, IDxcOperationResult** ppResult) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDxcCompiler*)Unsafe.AsPointer(ref this), pSource, pSourceName, pArguments, argCount, pDefines, defineCount, pIncludeHandler, ppResult); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult Disassemble(IDxcBlob* pSource, IDxcBlobEncoding** ppDisassembly) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDxcCompiler*)Unsafe.AsPointer(ref this), pSource, ppDisassembly); + } + +} + +/// +/// IDxcCompiler2 +[Guid("a005a9d9-b8bb-4594-b5c9-0e633bec4d37")] +[NativeTypeName("struct IDxcCompiler2 : IDxcCompiler")] +[NativeInheritance("IDxcCompiler")] +public unsafe partial struct IDxcCompiler2 +{ + public static ref readonly Guid IID_IDxcCompiler2 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xD9, 0xA9, 0x05, 0xA0, + 0xBB, 0xB8, + 0x94, 0x45, + 0xB5, + 0xC9, + 0x0E, + 0x63, + 0x3B, + 0xEC, + 0x4D, + 0x37 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcCompiler2)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult Compile(IDxcBlob* pSource, ushort* pSourceName, ushort* pEntryPoint, ushort* pTargetProfile, ushort** pArguments, uint argCount, DxcDefine* pDefines, uint defineCount, IDxcIncludeHandler* pIncludeHandler, IDxcOperationResult** ppResult) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDxcCompiler2*)Unsafe.AsPointer(ref this), pSource, pSourceName, pEntryPoint, pTargetProfile, pArguments, argCount, pDefines, defineCount, pIncludeHandler, ppResult); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult Preprocess(IDxcBlob* pSource, ushort* pSourceName, ushort** pArguments, uint argCount, DxcDefine* pDefines, uint defineCount, IDxcIncludeHandler* pIncludeHandler, IDxcOperationResult** ppResult) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDxcCompiler2*)Unsafe.AsPointer(ref this), pSource, pSourceName, pArguments, argCount, pDefines, defineCount, pIncludeHandler, ppResult); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult Disassemble(IDxcBlob* pSource, IDxcBlobEncoding** ppDisassembly) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDxcCompiler2*)Unsafe.AsPointer(ref this), pSource, ppDisassembly); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult CompileWithDebug(IDxcBlob* pSource, ushort* pSourceName, ushort* pEntryPoint, ushort* pTargetProfile, ushort** pArguments, uint argCount, DxcDefine* pDefines, uint defineCount, IDxcIncludeHandler* pIncludeHandler, IDxcOperationResult** ppResult, ushort** ppDebugBlobName, IDxcBlob** ppDebugBlob) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDxcCompiler2*)Unsafe.AsPointer(ref this), pSource, pSourceName, pEntryPoint, pTargetProfile, pArguments, argCount, pDefines, defineCount, pIncludeHandler, ppResult, ppDebugBlobName, ppDebugBlob); + } + +} + +/// +/// IDxcLinker +[Guid("f1b5be2a-62dd-4327-a1c2-42ac1e1e78e6")] +[NativeTypeName("struct IDxcLinker : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDxcLinker +{ + public static ref readonly Guid IID_IDxcLinker + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x2A, 0xBE, 0xB5, 0xF1, + 0xDD, 0x62, + 0x27, 0x43, + 0xA1, + 0xC2, + 0x42, + 0xAC, + 0x1E, + 0x1E, + 0x78, + 0xE6 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcLinker)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult RegisterLibrary(ushort* pLibName, IDxcBlob* pLib) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDxcLinker*)Unsafe.AsPointer(ref this), pLibName, pLib); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult Link(ushort* pEntryName, ushort* pTargetProfile, ushort** pLibNames, uint libCount, ushort** pArguments, uint argCount, IDxcOperationResult** ppResult) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDxcLinker*)Unsafe.AsPointer(ref this), pEntryName, pTargetProfile, pLibNames, libCount, pArguments, argCount, ppResult); + } + +} + +/// +/// IDxcUtils +[Guid("4605c4cb-2019-492a-ada4-65f20bb7d67f")] +[NativeTypeName("struct IDxcUtils : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDxcUtils +{ + public static ref readonly Guid IID_IDxcUtils + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xCB, 0xC4, 0x05, 0x46, + 0x19, 0x20, + 0x2A, 0x49, + 0xAD, + 0xA4, + 0x65, + 0xF2, + 0x0B, + 0xB7, + 0xD6, + 0x7F + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcUtils)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult CreateBlobFromBlob(IDxcBlob* pBlob, uint offset, uint length, IDxcBlob** ppResult) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDxcUtils*)Unsafe.AsPointer(ref this), pBlob, offset, length, ppResult); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult CreateBlobFromPinned(void* pData, uint size, DxcCp codePage, IDxcBlobEncoding** pBlobEncoding) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDxcUtils*)Unsafe.AsPointer(ref this), pData, size, codePage, pBlobEncoding); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult MoveToBlob(void* pData, Com.IMalloc* pIMalloc, uint size, DxcCp codePage, IDxcBlobEncoding** pBlobEncoding) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDxcUtils*)Unsafe.AsPointer(ref this), pData, pIMalloc, size, codePage, pBlobEncoding); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult CreateBlob(void* pData, uint size, DxcCp codePage, IDxcBlobEncoding** pBlobEncoding) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDxcUtils*)Unsafe.AsPointer(ref this), pData, size, codePage, pBlobEncoding); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult LoadFile(ushort* pFileName, DxcCp* pCodePage, IDxcBlobEncoding** pBlobEncoding) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDxcUtils*)Unsafe.AsPointer(ref this), pFileName, pCodePage, pBlobEncoding); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult CreateReadOnlyStreamFromBlob(IDxcBlob* pBlob, Com.IStream** ppStream) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDxcUtils*)Unsafe.AsPointer(ref this), pBlob, ppStream); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult CreateDefaultIncludeHandler(IDxcIncludeHandler** ppResult) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDxcUtils*)Unsafe.AsPointer(ref this), ppResult); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult GetBlobAsUtf8(IDxcBlob* pBlob, IDxcBlobUtf8** pBlobEncoding) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDxcUtils*)Unsafe.AsPointer(ref this), pBlob, pBlobEncoding); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult GetBlobAsUtf16(IDxcBlob* pBlob, IDxcBlobUtf16** pBlobEncoding) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDxcUtils*)Unsafe.AsPointer(ref this), pBlob, pBlobEncoding); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult GetDxilContainerPart(DxcBuffer* pShader, uint DxcPart, void** ppPartData, uint* pPartSizeInBytes) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IDxcUtils*)Unsafe.AsPointer(ref this), pShader, DxcPart, ppPartData, pPartSizeInBytes); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult CreateReflection(DxcBuffer* pData, Guid* iid, void** ppvReflection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IDxcUtils*)Unsafe.AsPointer(ref this), pData, iid, ppvReflection); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult BuildArguments(ushort* pSourceName, ushort* pEntryPoint, ushort* pTargetProfile, ushort** pArguments, uint argCount, DxcDefine* pDefines, uint defineCount, IDxcCompilerArgs** ppArgs) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((IDxcUtils*)Unsafe.AsPointer(ref this), pSourceName, pEntryPoint, pTargetProfile, pArguments, argCount, pDefines, defineCount, ppArgs); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult GetPDBContents(IDxcBlob* pPDBBlob, IDxcBlob** ppHash, IDxcBlob** ppContainer) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((IDxcUtils*)Unsafe.AsPointer(ref this), pPDBBlob, ppHash, ppContainer); + } + +} + +/// +/// IDxcResult +[Guid("58346cda-dde7-4497-9461-6f87af5e0659")] +[NativeTypeName("struct IDxcResult : IDxcOperationResult")] +[NativeInheritance("IDxcOperationResult")] +public unsafe partial struct IDxcResult +{ + public static ref readonly Guid IID_IDxcResult + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xDA, 0x6C, 0x34, 0x58, + 0xE7, 0xDD, + 0x97, 0x44, + 0x94, + 0x61, + 0x6F, + 0x87, + 0xAF, + 0x5E, + 0x06, + 0x59 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcResult)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetStatus(HResult* pStatus) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDxcResult*)Unsafe.AsPointer(ref this), pStatus); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetResult(IDxcBlob** ppResult) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDxcResult*)Unsafe.AsPointer(ref this), ppResult); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetErrorBuffer(IDxcBlobEncoding** ppErrors) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDxcResult*)Unsafe.AsPointer(ref this), ppErrors); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public Bool32 HasOutput(DxcOutKind dxcOutKind) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDxcResult*)Unsafe.AsPointer(ref this), dxcOutKind); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetOutput(DxcOutKind dxcOutKind, Guid* iid, void** ppvObject, IDxcBlobUtf16** ppOutputName) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDxcResult*)Unsafe.AsPointer(ref this), dxcOutKind, iid, ppvObject, ppOutputName); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public uint GetNumOutputs() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDxcResult*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public Graphics.Direct3D.Dxc.DxcOutKind GetOutputByIndex(uint Index) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDxcResult*)Unsafe.AsPointer(ref this), Index); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public Graphics.Direct3D.Dxc.DxcOutKind PrimaryOutput() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDxcResult*)Unsafe.AsPointer(ref this)); + } + +} + +/// +/// IDxcExtraOutputs +[Guid("319b37a2-a5c2-494a-a5de-4801b2faf989")] +[NativeTypeName("struct IDxcExtraOutputs : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDxcExtraOutputs +{ + public static ref readonly Guid IID_IDxcExtraOutputs + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xA2, 0x37, 0x9B, 0x31, + 0xC2, 0xA5, + 0x4A, 0x49, + 0xA5, + 0xDE, + 0x48, + 0x01, + 0xB2, + 0xFA, + 0xF9, + 0x89 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcExtraOutputs)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public uint GetOutputCount() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDxcExtraOutputs*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetOutput(uint uIndex, Guid* iid, void** ppvObject, IDxcBlobUtf16** ppOutputType, IDxcBlobUtf16** ppOutputName) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDxcExtraOutputs*)Unsafe.AsPointer(ref this), uIndex, iid, ppvObject, ppOutputType, ppOutputName); + } + +} + +/// +/// IDxcCompiler3 +[Guid("228b4687-5a6a-4730-900c-9702b2203f54")] +[NativeTypeName("struct IDxcCompiler3 : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDxcCompiler3 +{ + public static ref readonly Guid IID_IDxcCompiler3 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x87, 0x46, 0x8B, 0x22, + 0x6A, 0x5A, + 0x30, 0x47, + 0x90, + 0x0C, + 0x97, + 0x02, + 0xB2, + 0x20, + 0x3F, + 0x54 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcCompiler3)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult Compile(DxcBuffer* pSource, ushort** pArguments, uint argCount, IDxcIncludeHandler* pIncludeHandler, Guid* riid, void** ppResult) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDxcCompiler3*)Unsafe.AsPointer(ref this), pSource, pArguments, argCount, pIncludeHandler, riid, ppResult); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult Disassemble(DxcBuffer* pObject, Guid* riid, void** ppResult) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDxcCompiler3*)Unsafe.AsPointer(ref this), pObject, riid, ppResult); + } + +} + +/// +/// IDxcValidator +[Guid("a6e82bd2-1fd7-4826-9811-2857e797f49a")] +[NativeTypeName("struct IDxcValidator : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDxcValidator +{ + public static ref readonly Guid IID_IDxcValidator + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xD2, 0x2B, 0xE8, 0xA6, + 0xD7, 0x1F, + 0x26, 0x48, + 0x98, + 0x11, + 0x28, + 0x57, + 0xE7, + 0x97, + 0xF4, + 0x9A + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcValidator)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult Validate(IDxcBlob* pShader, uint Flags, IDxcOperationResult** ppResult) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDxcValidator*)Unsafe.AsPointer(ref this), pShader, Flags, ppResult); + } + +} + +/// +/// IDxcValidator2 +[Guid("458e1fd1-b1b2-4750-a6e1-9c10f03bed92")] +[NativeTypeName("struct IDxcValidator2 : IDxcValidator")] +[NativeInheritance("IDxcValidator")] +public unsafe partial struct IDxcValidator2 +{ + public static ref readonly Guid IID_IDxcValidator2 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xD1, 0x1F, 0x8E, 0x45, + 0xB2, 0xB1, + 0x50, 0x47, + 0xA6, + 0xE1, + 0x9C, + 0x10, + 0xF0, + 0x3B, + 0xED, + 0x92 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcValidator2)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult Validate(IDxcBlob* pShader, uint Flags, IDxcOperationResult** ppResult) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDxcValidator2*)Unsafe.AsPointer(ref this), pShader, Flags, ppResult); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult ValidateWithDebug(IDxcBlob* pShader, uint Flags, DxcBuffer* pOptDebugBitcode, IDxcOperationResult** ppResult) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDxcValidator2*)Unsafe.AsPointer(ref this), pShader, Flags, pOptDebugBitcode, ppResult); + } + +} + +/// +/// IDxcContainerBuilder +[Guid("334b1f50-2292-4b35-99a1-25588d8c17fe")] +[NativeTypeName("struct IDxcContainerBuilder : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDxcContainerBuilder +{ + public static ref readonly Guid IID_IDxcContainerBuilder + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x50, 0x1F, 0x4B, 0x33, + 0x92, 0x22, + 0x35, 0x4B, + 0x99, + 0xA1, + 0x25, + 0x58, + 0x8D, + 0x8C, + 0x17, + 0xFE + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcContainerBuilder)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult Load(IDxcBlob* pDxilContainerHeader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDxcContainerBuilder*)Unsafe.AsPointer(ref this), pDxilContainerHeader); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult AddPart(uint fourCC, IDxcBlob* pSource) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDxcContainerBuilder*)Unsafe.AsPointer(ref this), fourCC, pSource); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult RemovePart(uint fourCC) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDxcContainerBuilder*)Unsafe.AsPointer(ref this), fourCC); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SerializeContainer(IDxcOperationResult* ppResult) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDxcContainerBuilder*)Unsafe.AsPointer(ref this), ppResult); + } + +} + +/// +/// IDxcAssembler +[Guid("091f7a26-1c1f-4948-904b-e6e3a8a771d5")] +[NativeTypeName("struct IDxcAssembler : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDxcAssembler +{ + public static ref readonly Guid IID_IDxcAssembler + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x26, 0x7A, 0x1F, 0x09, + 0x1F, 0x1C, + 0x48, 0x49, + 0x90, + 0x4B, + 0xE6, + 0xE3, + 0xA8, + 0xA7, + 0x71, + 0xD5 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcAssembler)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult AssembleToContainer(IDxcBlob* pShader, IDxcOperationResult** ppResult) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDxcAssembler*)Unsafe.AsPointer(ref this), pShader, ppResult); + } + +} + +/// +/// IDxcContainerReflection +[Guid("d2c21b26-8350-4bdc-976a-331ce6f4c54c")] +[NativeTypeName("struct IDxcContainerReflection : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDxcContainerReflection +{ + public static ref readonly Guid IID_IDxcContainerReflection + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x26, 0x1B, 0xC2, 0xD2, + 0x50, 0x83, + 0xDC, 0x4B, + 0x97, + 0x6A, + 0x33, + 0x1C, + 0xE6, + 0xF4, + 0xC5, + 0x4C + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcContainerReflection)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult Load(IDxcBlob* pContainer) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDxcContainerReflection*)Unsafe.AsPointer(ref this), pContainer); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetPartCount(uint* pResult) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDxcContainerReflection*)Unsafe.AsPointer(ref this), pResult); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetPartKind(uint idx, uint* pResult) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDxcContainerReflection*)Unsafe.AsPointer(ref this), idx, pResult); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetPartContent(uint idx, IDxcBlob** ppResult) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDxcContainerReflection*)Unsafe.AsPointer(ref this), idx, ppResult); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult FindFirstPartKind(uint kind, uint* pResult) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDxcContainerReflection*)Unsafe.AsPointer(ref this), kind, pResult); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetPartReflection(uint idx, Guid* iid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDxcContainerReflection*)Unsafe.AsPointer(ref this), idx, iid, ppvObject); + } + +} + +/// +/// IDxcOptimizerPass +[Guid("ae2cd79f-cc22-453f-9b6b-b124e7a5204c")] +[NativeTypeName("struct IDxcOptimizerPass : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDxcOptimizerPass +{ + public static ref readonly Guid IID_IDxcOptimizerPass + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x9F, 0xD7, 0x2C, 0xAE, + 0x22, 0xCC, + 0x3F, 0x45, + 0x9B, + 0x6B, + 0xB1, + 0x24, + 0xE7, + 0xA5, + 0x20, + 0x4C + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcOptimizerPass)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetOptionName(ushort** ppResult) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDxcOptimizerPass*)Unsafe.AsPointer(ref this), ppResult); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetDescription(ushort** ppResult) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDxcOptimizerPass*)Unsafe.AsPointer(ref this), ppResult); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetOptionArgCount(uint* pCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDxcOptimizerPass*)Unsafe.AsPointer(ref this), pCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetOptionArgName(uint argIndex, ushort** ppResult) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDxcOptimizerPass*)Unsafe.AsPointer(ref this), argIndex, ppResult); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetOptionArgDescription(uint argIndex, ushort** ppResult) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDxcOptimizerPass*)Unsafe.AsPointer(ref this), argIndex, ppResult); + } + +} + +/// +/// IDxcOptimizer +[Guid("25740e2e-9cba-401b-9119-4fb42f39f270")] +[NativeTypeName("struct IDxcOptimizer : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDxcOptimizer +{ + public static ref readonly Guid IID_IDxcOptimizer + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x2E, 0x0E, 0x74, 0x25, + 0xBA, 0x9C, + 0x1B, 0x40, + 0x91, + 0x19, + 0x4F, + 0xB4, + 0x2F, + 0x39, + 0xF2, + 0x70 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcOptimizer)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetAvailablePassCount(uint* pCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDxcOptimizer*)Unsafe.AsPointer(ref this), pCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetAvailablePass(uint index, IDxcOptimizerPass** ppResult) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDxcOptimizer*)Unsafe.AsPointer(ref this), index, ppResult); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult RunOptimizer(IDxcBlob* pBlob, ushort** ppOptions, uint optionCount, IDxcBlob** pOutputModule, IDxcBlobEncoding** ppOutputText) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDxcOptimizer*)Unsafe.AsPointer(ref this), pBlob, ppOptions, optionCount, pOutputModule, ppOutputText); + } + +} + +/// +/// IDxcVersionInfo +[Guid("b04f5b50-2059-4f12-a8ff-a1e0cde1cc7e")] +[NativeTypeName("struct IDxcVersionInfo : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDxcVersionInfo +{ + public static ref readonly Guid IID_IDxcVersionInfo + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x50, 0x5B, 0x4F, 0xB0, + 0x59, 0x20, + 0x12, 0x4F, + 0xA8, + 0xFF, + 0xA1, + 0xE0, + 0xCD, + 0xE1, + 0xCC, + 0x7E + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcVersionInfo)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetVersion(uint* pMajor, uint* pMinor) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDxcVersionInfo*)Unsafe.AsPointer(ref this), pMajor, pMinor); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetFlags(uint* pFlags) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDxcVersionInfo*)Unsafe.AsPointer(ref this), pFlags); + } + +} + +/// +/// IDxcVersionInfo2 +[Guid("fb6904c4-42f0-4b62-9c46-983af7da7c83")] +[NativeTypeName("struct IDxcVersionInfo2 : IDxcVersionInfo")] +[NativeInheritance("IDxcVersionInfo")] +public unsafe partial struct IDxcVersionInfo2 +{ + public static ref readonly Guid IID_IDxcVersionInfo2 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xC4, 0x04, 0x69, 0xFB, + 0xF0, 0x42, + 0x62, 0x4B, + 0x9C, + 0x46, + 0x98, + 0x3A, + 0xF7, + 0xDA, + 0x7C, + 0x83 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcVersionInfo2)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetVersion(uint* pMajor, uint* pMinor) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDxcVersionInfo2*)Unsafe.AsPointer(ref this), pMajor, pMinor); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetFlags(uint* pFlags) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDxcVersionInfo2*)Unsafe.AsPointer(ref this), pFlags); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetCommitInfo(uint* pCommitCount, sbyte** pCommitHash) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDxcVersionInfo2*)Unsafe.AsPointer(ref this), pCommitCount, pCommitHash); + } + +} + +/// +/// IDxcVersionInfo3 +[Guid("5e13e843-9d25-473c-9ad2-03b2d0b44b1e")] +[NativeTypeName("struct IDxcVersionInfo3 : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDxcVersionInfo3 +{ + public static ref readonly Guid IID_IDxcVersionInfo3 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x43, 0xE8, 0x13, 0x5E, + 0x25, 0x9D, + 0x3C, 0x47, + 0x9A, + 0xD2, + 0x03, + 0xB2, + 0xD0, + 0xB4, + 0x4B, + 0x1E + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcVersionInfo3)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetCustomVersionString(sbyte** pVersionString) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDxcVersionInfo3*)Unsafe.AsPointer(ref this), pVersionString); + } + +} + +/// +/// IDxcPdbUtils +[Guid("e6c9647e-9d6a-4c3b-b94c-524b5a6c343d")] +[NativeTypeName("struct IDxcPdbUtils : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDxcPdbUtils +{ + public static ref readonly Guid IID_IDxcPdbUtils + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x7E, 0x64, 0xC9, 0xE6, + 0x6A, 0x9D, + 0x3B, 0x4C, + 0xB9, + 0x4C, + 0x52, + 0x4B, + 0x5A, + 0x6C, + 0x34, + 0x3D + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcPdbUtils)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult Load(IDxcBlob* pPdbOrDxil) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), pPdbOrDxil); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetSourceCount(uint* pCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), pCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetSource(uint uIndex, IDxcBlobEncoding** ppResult) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), uIndex, ppResult); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetSourceName(uint uIndex, char** pResult) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), uIndex, pResult); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetFlagCount(uint* pCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), pCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetFlag(uint uIndex, char** pResult) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), uIndex, pResult); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult GetArgCount(uint* pCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), pCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult GetArg(uint uIndex, char** pResult) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), uIndex, pResult); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult GetArgPairCount(uint* pCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), pCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult GetArgPair(uint uIndex, char** pName, char** pValue) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), uIndex, pName, pValue); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult GetDefineCount(uint* pCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), pCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult GetDefine(uint uIndex, char** pResult) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), uIndex, pResult); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult GetTargetProfile(char** pResult) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), pResult); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult GetEntryPoint(char** pResult) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), pResult); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult GetMainFileName(char** pResult) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), pResult); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public HResult GetHash(IDxcBlob** ppResult) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), ppResult); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public HResult GetName(char** pResult) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), pResult); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public Bool32 IsFullPDB() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public HResult GetFullPDB(IDxcBlob** ppFullPDB) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), ppFullPDB); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public HResult GetVersionInfo(IDxcVersionInfo** ppVersionInfo) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), ppVersionInfo); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public HResult SetCompiler(IDxcCompiler3* pCompiler) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), pCompiler); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public HResult CompileForFullPDB(IDxcResult** ppResult) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), ppResult); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public HResult OverrideArgs(DxcArgPair* pArgPairs, uint uNumArgPairs) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), pArgPairs, uNumArgPairs); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public HResult OverrideRootSignature(ushort* pRootSignature) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), pRootSignature); + } + +} + +#endregion Com Types + +#region Functions +public static unsafe partial class Apis +{ + [DllImport("dxcompiler", ExactSpelling = true)] + public static extern HResult DxcCreateInstance(Guid* rclsid, Guid* riid, void** ppv); + + [DllImport("dxcompiler", ExactSpelling = true)] + public static extern HResult DxcCreateInstance2(Com.IMalloc* pMalloc, Guid* rclsid, Guid* riid, void** ppv); +} +#endregion Functions diff --git a/src/Vortice.Win32/Generated/Graphics/Direct3D.cs b/src/Vortice.Win32/Generated/Graphics/Direct3D.cs index a333473..1958665 100644 --- a/src/Vortice.Win32/Generated/Graphics/Direct3D.cs +++ b/src/Vortice.Win32/Generated/Graphics/Direct3D.cs @@ -64,16 +64,154 @@ public static partial class Apis public const uint D3D_SHADER_FEATURE_SAMPLER_DESCRIPTOR_HEAP_INDEXING = 67108864; public const uint D3D_SHADER_FEATURE_WAVE_MMA = 134217728; public const uint D3D_SHADER_FEATURE_ATOMIC_INT64_ON_DESCRIPTOR_HEAP_RESOURCE = 268435456; - public static readonly Guid WKPDID_D3DDebugObjectName = new Guid(0x429b8c22, 0x9188, 0x4b0c, 0x87, 0x42, 0xac, 0xb0, 0xbf, 0x85, 0xc2, 0x00); - public static readonly Guid WKPDID_D3DDebugObjectNameW = new Guid(0x4cca5fd8, 0x921f, 0x42c8, 0x85, 0x66, 0x70, 0xca, 0xf2, 0xa9, 0xb7, 0x41); - public static readonly Guid WKPDID_CommentStringW = new Guid(0xd0149dc0, 0x90e8, 0x4ec8, 0x81, 0x44, 0xe9, 0x00, 0xad, 0x26, 0x6b, 0xb2); - public static readonly Guid WKPDID_D3D12UniqueObjectId = new Guid(0x1b39de15, 0xec04, 0x4bae, 0xba, 0x4d, 0x8c, 0xef, 0x79, 0xfc, 0x04, 0xc1); + public static ref readonly Guid WKPDID_D3DDebugObjectName + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x22, 0x8C, 0x9B, 0x42, + 0x88, 0x91, + 0x0C, 0x4B, + 0x87, + 0x42, + 0xAC, + 0xB0, + 0xBF, + 0x85, + 0xC2, + 0x00 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid WKPDID_D3DDebugObjectNameW + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xD8, 0x5F, 0xCA, 0x4C, + 0x1F, 0x92, + 0xC8, 0x42, + 0x85, + 0x66, + 0x70, + 0xCA, + 0xF2, + 0xA9, + 0xB7, + 0x41 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid WKPDID_CommentStringW + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xC0, 0x9D, 0x14, 0xD0, + 0xE8, 0x90, + 0xC8, 0x4E, + 0x81, + 0x44, + 0xE9, + 0x00, + 0xAD, + 0x26, + 0x6B, + 0xB2 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid WKPDID_D3D12UniqueObjectId + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x15, 0xDE, 0x39, 0x1B, + 0x04, 0xEC, + 0xAE, 0x4B, + 0xBA, + 0x4D, + 0x8C, + 0xEF, + 0x79, + 0xFC, + 0x04, + 0xC1 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + public const uint D3D_COMPONENT_MASK_X = 1; public const uint D3D_COMPONENT_MASK_Y = 2; public const uint D3D_COMPONENT_MASK_Z = 4; public const uint D3D_COMPONENT_MASK_W = 8; - public static readonly Guid D3D_TEXTURE_LAYOUT_ROW_MAJOR = new Guid(0xb5dc234f, 0x72bb, 0x4bec, 0x97, 0x05, 0x8c, 0xf2, 0x58, 0xdf, 0x6b, 0x6c); - public static readonly Guid D3D_TEXTURE_LAYOUT_64KB_STANDARD_SWIZZLE = new Guid(0x4c0f29e3, 0x3f5f, 0x4d35, 0x84, 0xc9, 0xbc, 0x09, 0x83, 0xb6, 0x2c, 0x28); + public static ref readonly Guid D3D_TEXTURE_LAYOUT_ROW_MAJOR + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x4F, 0x23, 0xDC, 0xB5, + 0xBB, 0x72, + 0xEC, 0x4B, + 0x97, + 0x05, + 0x8C, + 0xF2, + 0x58, + 0xDF, + 0x6B, + 0x6C + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D_TEXTURE_LAYOUT_64KB_STANDARD_SWIZZLE + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xE3, 0x29, 0x0F, 0x4C, + 0x5F, 0x3F, + 0x35, 0x4D, + 0x84, + 0xC9, + 0xBC, + 0x09, + 0x83, + 0xB6, + 0x2C, + 0x28 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + } #region Enums @@ -1073,10 +1211,10 @@ public enum ParameterFlags : int public partial struct ShaderMacro { /// - public unsafe byte* Name; + public unsafe sbyte* Name; /// - public unsafe byte* Definition; + public unsafe sbyte* Definition; } #endregion Structs @@ -1249,9 +1387,9 @@ public unsafe partial struct ID3DInclude /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(0)] - public HResult Open(IncludeType IncludeType, byte** pFileName, void* pParentData, void** ppData, uint* pBytes) + public HResult Open(IncludeType IncludeType, sbyte* pFileName, void* pParentData, void** ppData, uint* pBytes) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((ID3DInclude*)Unsafe.AsPointer(ref this), IncludeType, pFileName, pParentData, ppData, pBytes); + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((ID3DInclude*)Unsafe.AsPointer(ref this), IncludeType, pFileName, pParentData, ppData, pBytes); } /// diff --git a/src/Vortice.Win32/Generated/Graphics/Direct3D11.cs b/src/Vortice.Win32/Generated/Graphics/Direct3D11.cs index e70f0a2..0153e36 100644 --- a/src/Vortice.Win32/Generated/Graphics/Direct3D11.cs +++ b/src/Vortice.Win32/Generated/Graphics/Direct3D11.cs @@ -402,68 +402,1494 @@ public static partial class Apis public const uint D3D11_MIP_FILTER_SHIFT = 0; public const uint D3D11_COMPARISON_FILTERING_BIT = 128; public const uint D3D11_ANISOTROPIC_FILTERING_BIT = 64; - public static readonly Guid D3D11_DECODER_PROFILE_MPEG2_MOCOMP = new Guid(0xe6a9f44b, 0x61b0, 0x4563, 0x9e, 0xa4, 0x63, 0xd2, 0xa3, 0xc6, 0xfe, 0x66); - public static readonly Guid D3D11_DECODER_PROFILE_MPEG2_IDCT = new Guid(0xbf22ad00, 0x03ea, 0x4690, 0x80, 0x77, 0x47, 0x33, 0x46, 0x20, 0x9b, 0x7e); - public static readonly Guid D3D11_DECODER_PROFILE_MPEG2_VLD = new Guid(0xee27417f, 0x5e28, 0x4e65, 0xbe, 0xea, 0x1d, 0x26, 0xb5, 0x08, 0xad, 0xc9); - public static readonly Guid D3D11_DECODER_PROFILE_MPEG1_VLD = new Guid(0x6f3ec719, 0x3735, 0x42cc, 0x80, 0x63, 0x65, 0xcc, 0x3c, 0xb3, 0x66, 0x16); - public static readonly Guid D3D11_DECODER_PROFILE_MPEG2and1_VLD = new Guid(0x86695f12, 0x340e, 0x4f04, 0x9f, 0xd3, 0x92, 0x53, 0xdd, 0x32, 0x74, 0x60); - public static readonly Guid D3D11_DECODER_PROFILE_H264_MOCOMP_NOFGT = new Guid(0x1b81be64, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5); - public static readonly Guid D3D11_DECODER_PROFILE_H264_MOCOMP_FGT = new Guid(0x1b81be65, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5); - public static readonly Guid D3D11_DECODER_PROFILE_H264_IDCT_NOFGT = new Guid(0x1b81be66, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5); - public static readonly Guid D3D11_DECODER_PROFILE_H264_IDCT_FGT = new Guid(0x1b81be67, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5); - public static readonly Guid D3D11_DECODER_PROFILE_H264_VLD_NOFGT = new Guid(0x1b81be68, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5); - public static readonly Guid D3D11_DECODER_PROFILE_H264_VLD_FGT = new Guid(0x1b81be69, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5); - public static readonly Guid D3D11_DECODER_PROFILE_H264_VLD_WITHFMOASO_NOFGT = new Guid(0xd5f04ff9, 0x3418, 0x45d8, 0x95, 0x61, 0x32, 0xa7, 0x6a, 0xae, 0x2d, 0xdd); - public static readonly Guid D3D11_DECODER_PROFILE_H264_VLD_STEREO_PROGRESSIVE_NOFGT = new Guid(0xd79be8da, 0x0cf1, 0x4c81, 0xb8, 0x2a, 0x69, 0xa4, 0xe2, 0x36, 0xf4, 0x3d); - public static readonly Guid D3D11_DECODER_PROFILE_H264_VLD_STEREO_NOFGT = new Guid(0xf9aaccbb, 0xc2b6, 0x4cfc, 0x87, 0x79, 0x57, 0x07, 0xb1, 0x76, 0x05, 0x52); - public static readonly Guid D3D11_DECODER_PROFILE_H264_VLD_MULTIVIEW_NOFGT = new Guid(0x705b9d82, 0x76cf, 0x49d6, 0xb7, 0xe6, 0xac, 0x88, 0x72, 0xdb, 0x01, 0x3c); - public static readonly Guid D3D11_DECODER_PROFILE_WMV8_POSTPROC = new Guid(0x1b81be80, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5); - public static readonly Guid D3D11_DECODER_PROFILE_WMV8_MOCOMP = new Guid(0x1b81be81, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5); - public static readonly Guid D3D11_DECODER_PROFILE_WMV9_POSTPROC = new Guid(0x1b81be90, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5); - public static readonly Guid D3D11_DECODER_PROFILE_WMV9_MOCOMP = new Guid(0x1b81be91, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5); - public static readonly Guid D3D11_DECODER_PROFILE_WMV9_IDCT = new Guid(0x1b81be94, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5); - public static readonly Guid D3D11_DECODER_PROFILE_VC1_POSTPROC = new Guid(0x1b81bea0, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5); - public static readonly Guid D3D11_DECODER_PROFILE_VC1_MOCOMP = new Guid(0x1b81bea1, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5); - public static readonly Guid D3D11_DECODER_PROFILE_VC1_IDCT = new Guid(0x1b81bea2, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5); - public static readonly Guid D3D11_DECODER_PROFILE_VC1_VLD = new Guid(0x1b81bea3, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5); - public static readonly Guid D3D11_DECODER_PROFILE_VC1_D2010 = new Guid(0x1b81bea4, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5); - public static readonly Guid D3D11_DECODER_PROFILE_MPEG4PT2_VLD_SIMPLE = new Guid(0xefd64d74, 0xc9e8, 0x41d7, 0xa5, 0xe9, 0xe9, 0xb0, 0xe3, 0x9f, 0xa3, 0x19); - public static readonly Guid D3D11_DECODER_PROFILE_MPEG4PT2_VLD_ADVSIMPLE_NOGMC = new Guid(0xed418a9f, 0x010d, 0x4eda, 0x9a, 0xe3, 0x9a, 0x65, 0x35, 0x8d, 0x8d, 0x2e); - public static readonly Guid D3D11_DECODER_PROFILE_MPEG4PT2_VLD_ADVSIMPLE_GMC = new Guid(0xab998b5b, 0x4258, 0x44a9, 0x9f, 0xeb, 0x94, 0xe5, 0x97, 0xa6, 0xba, 0xae); - public static readonly Guid D3D11_DECODER_PROFILE_HEVC_VLD_MAIN = new Guid(0x5b11d51b, 0x2f4c, 0x4452, 0xbc, 0xc3, 0x09, 0xf2, 0xa1, 0x16, 0x0c, 0xc0); - public static readonly Guid D3D11_DECODER_PROFILE_HEVC_VLD_MAIN10 = new Guid(0x107af0e0, 0xef1a, 0x4d19, 0xab, 0xa8, 0x67, 0xa1, 0x63, 0x07, 0x3d, 0x13); - public static readonly Guid D3D11_DECODER_PROFILE_VP9_VLD_PROFILE0 = new Guid(0x463707f8, 0xa1d0, 0x4585, 0x87, 0x6d, 0x83, 0xaa, 0x6d, 0x60, 0xb8, 0x9e); - public static readonly Guid D3D11_DECODER_PROFILE_VP9_VLD_10BIT_PROFILE2 = new Guid(0xa4c749ef, 0x6ecf, 0x48aa, 0x84, 0x48, 0x50, 0xa7, 0xa1, 0x16, 0x5f, 0xf7); - public static readonly Guid D3D11_DECODER_PROFILE_VP8_VLD = new Guid(0x90b899ea, 0x3a62, 0x4705, 0x88, 0xb3, 0x8d, 0xf0, 0x4b, 0x27, 0x44, 0xe7); - public static readonly Guid D3D11_DECODER_PROFILE_AV1_VLD_PROFILE0 = new Guid(0xb8be4ccb, 0xcf53, 0x46ba, 0x8d, 0x59, 0xd6, 0xb8, 0xa6, 0xda, 0x5d, 0x2a); - public static readonly Guid D3D11_DECODER_PROFILE_AV1_VLD_PROFILE1 = new Guid(0x6936ff0f, 0x45b1, 0x4163, 0x9c, 0xc1, 0x64, 0x6e, 0xf6, 0x94, 0x61, 0x08); - public static readonly Guid D3D11_DECODER_PROFILE_AV1_VLD_PROFILE2 = new Guid(0x0c5f2aa1, 0xe541, 0x4089, 0xbb, 0x7b, 0x98, 0x11, 0x0a, 0x19, 0xd7, 0xc8); - public static readonly Guid D3D11_DECODER_PROFILE_AV1_VLD_12BIT_PROFILE2 = new Guid(0x17127009, 0xa00f, 0x4ce1, 0x99, 0x4e, 0xbf, 0x40, 0x81, 0xf6, 0xf3, 0xf0); - public static readonly Guid D3D11_DECODER_PROFILE_AV1_VLD_12BIT_PROFILE2_420 = new Guid(0x2d80bed6, 0x9cac, 0x4835, 0x9e, 0x91, 0x32, 0x7b, 0xbc, 0x4f, 0x9e, 0xe8); - public static readonly Guid D3D11_CRYPTO_TYPE_AES128_CTR = new Guid(0x9b6bd711, 0x4f74, 0x41c9, 0x9e, 0x7b, 0x0b, 0xe2, 0xd7, 0xd9, 0x3b, 0x4f); - public static readonly Guid D3D11_DECODER_ENCRYPTION_HW_CENC = new Guid(0x89d6ac4f, 0x09f2, 0x4229, 0xb2, 0xcd, 0x37, 0x74, 0x0a, 0x6d, 0xfd, 0x81); - public static readonly Guid D3D11_DECODER_BITSTREAM_ENCRYPTION_TYPE_CENC = new Guid(0xb0405235, 0xc13d, 0x44f2, 0x9a, 0xe5, 0xdd, 0x48, 0xe0, 0x8e, 0x5b, 0x67); - public static readonly Guid D3D11_DECODER_BITSTREAM_ENCRYPTION_TYPE_CBCS = new Guid(0x422d9319, 0x9d21, 0x4bb7, 0x93, 0x71, 0xfa, 0xf5, 0xa8, 0x2c, 0x3e, 0x04); - public static readonly Guid D3D11_KEY_EXCHANGE_HW_PROTECTION = new Guid(0xb1170d8a, 0x628d, 0x4da3, 0xad, 0x3b, 0x82, 0xdd, 0xb0, 0x8b, 0x49, 0x70); - public static readonly Guid D3D11_AUTHENTICATED_QUERY_PROTECTION = new Guid(0xa84eb584, 0xc495, 0x48aa, 0xb9, 0x4d, 0x8b, 0xd2, 0xd6, 0xfb, 0xce, 0x05); - public static readonly Guid D3D11_AUTHENTICATED_QUERY_CHANNEL_TYPE = new Guid(0xbc1b18a5, 0xb1fb, 0x42ab, 0xbd, 0x94, 0xb5, 0x82, 0x8b, 0x4b, 0xf7, 0xbe); - public static readonly Guid D3D11_AUTHENTICATED_QUERY_DEVICE_HANDLE = new Guid(0xec1c539d, 0x8cff, 0x4e2a, 0xbc, 0xc4, 0xf5, 0x69, 0x2f, 0x99, 0xf4, 0x80); - public static readonly Guid D3D11_AUTHENTICATED_QUERY_CRYPTO_SESSION = new Guid(0x2634499e, 0xd018, 0x4d74, 0xac, 0x17, 0x7f, 0x72, 0x40, 0x59, 0x52, 0x8d); - public static readonly Guid D3D11_AUTHENTICATED_QUERY_RESTRICTED_SHARED_RESOURCE_PROCESS_COUNT = new Guid(0x0db207b3, 0x9450, 0x46a6, 0x82, 0xde, 0x1b, 0x96, 0xd4, 0x4f, 0x9c, 0xf2); - public static readonly Guid D3D11_AUTHENTICATED_QUERY_RESTRICTED_SHARED_RESOURCE_PROCESS = new Guid(0x649bbadb, 0xf0f4, 0x4639, 0xa1, 0x5b, 0x24, 0x39, 0x3f, 0xc3, 0xab, 0xac); - public static readonly Guid D3D11_AUTHENTICATED_QUERY_UNRESTRICTED_PROTECTED_SHARED_RESOURCE_COUNT = new Guid(0x012f0bd6, 0xe662, 0x4474, 0xbe, 0xfd, 0xaa, 0x53, 0xe5, 0x14, 0x3c, 0x6d); - public static readonly Guid D3D11_AUTHENTICATED_QUERY_OUTPUT_ID_COUNT = new Guid(0x2c042b5e, 0x8c07, 0x46d5, 0xaa, 0xbe, 0x8f, 0x75, 0xcb, 0xad, 0x4c, 0x31); - public static readonly Guid D3D11_AUTHENTICATED_QUERY_OUTPUT_ID = new Guid(0x839ddca3, 0x9b4e, 0x41e4, 0xb0, 0x53, 0x89, 0x2b, 0xd2, 0xa1, 0x1e, 0xe7); - public static readonly Guid D3D11_AUTHENTICATED_QUERY_ACCESSIBILITY_ATTRIBUTES = new Guid(0x6214d9d2, 0x432c, 0x4abb, 0x9f, 0xce, 0x21, 0x6e, 0xea, 0x26, 0x9e, 0x3b); - public static readonly Guid D3D11_AUTHENTICATED_QUERY_ENCRYPTION_WHEN_ACCESSIBLE_GUID_COUNT = new Guid(0xb30f7066, 0x203c, 0x4b07, 0x93, 0xfc, 0xce, 0xaa, 0xfd, 0x61, 0x24, 0x1e); - public static readonly Guid D3D11_AUTHENTICATED_QUERY_ENCRYPTION_WHEN_ACCESSIBLE_GUID = new Guid(0xf83a5958, 0xe986, 0x4bda, 0xbe, 0xb0, 0x41, 0x1f, 0x6a, 0x7a, 0x01, 0xb7); - public static readonly Guid D3D11_AUTHENTICATED_QUERY_CURRENT_ENCRYPTION_WHEN_ACCESSIBLE = new Guid(0xec1791c7, 0xdad3, 0x4f15, 0x9e, 0xc3, 0xfa, 0xa9, 0x3d, 0x60, 0xd4, 0xf0); - public static readonly Guid D3D11_AUTHENTICATED_CONFIGURE_INITIALIZE = new Guid(0x06114bdb, 0x3523, 0x470a, 0x8d, 0xca, 0xfb, 0xc2, 0x84, 0x51, 0x54, 0xf0); - public static readonly Guid D3D11_AUTHENTICATED_CONFIGURE_PROTECTION = new Guid(0x50455658, 0x3f47, 0x4362, 0xbf, 0x99, 0xbf, 0xdf, 0xcd, 0xe9, 0xed, 0x29); - public static readonly Guid D3D11_AUTHENTICATED_CONFIGURE_CRYPTO_SESSION = new Guid(0x6346cc54, 0x2cfc, 0x4ad4, 0x82, 0x24, 0xd1, 0x58, 0x37, 0xde, 0x77, 0x00); - public static readonly Guid D3D11_AUTHENTICATED_CONFIGURE_SHARED_RESOURCE = new Guid(0x0772d047, 0x1b40, 0x48e8, 0x9c, 0xa6, 0xb5, 0xf5, 0x10, 0xde, 0x9f, 0x01); - public static readonly Guid D3D11_AUTHENTICATED_CONFIGURE_ENCRYPTION_WHEN_ACCESSIBLE = new Guid(0x41fff286, 0x6ae0, 0x4d43, 0x9d, 0x55, 0xa4, 0x6e, 0x9e, 0xfd, 0x15, 0x8a); - public static readonly Guid D3D11_KEY_EXCHANGE_RSAES_OAEP = new Guid(0xc1949895, 0xd72a, 0x4a1d, 0x8e, 0x5d, 0xed, 0x85, 0x7d, 0x17, 0x15, 0x20); + public static ref readonly Guid D3D11_DECODER_PROFILE_MPEG2_MOCOMP + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x4B, 0xF4, 0xA9, 0xE6, + 0xB0, 0x61, + 0x63, 0x45, + 0x9E, + 0xA4, + 0x63, + 0xD2, + 0xA3, + 0xC6, + 0xFE, + 0x66 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_MPEG2_IDCT + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x00, 0xAD, 0x22, 0xBF, + 0xEA, 0x03, + 0x90, 0x46, + 0x80, + 0x77, + 0x47, + 0x33, + 0x46, + 0x20, + 0x9B, + 0x7E + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_MPEG2_VLD + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x7F, 0x41, 0x27, 0xEE, + 0x28, 0x5E, + 0x65, 0x4E, + 0xBE, + 0xEA, + 0x1D, + 0x26, + 0xB5, + 0x08, + 0xAD, + 0xC9 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_MPEG1_VLD + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x19, 0xC7, 0x3E, 0x6F, + 0x35, 0x37, + 0xCC, 0x42, + 0x80, + 0x63, + 0x65, + 0xCC, + 0x3C, + 0xB3, + 0x66, + 0x16 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_MPEG2and1_VLD + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x12, 0x5F, 0x69, 0x86, + 0x0E, 0x34, + 0x04, 0x4F, + 0x9F, + 0xD3, + 0x92, + 0x53, + 0xDD, + 0x32, + 0x74, + 0x60 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_H264_MOCOMP_NOFGT + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x64, 0xBE, 0x81, 0x1B, + 0xC7, 0xA0, + 0xD3, 0x11, + 0xB9, + 0x84, + 0x00, + 0xC0, + 0x4F, + 0x2E, + 0x73, + 0xC5 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_H264_MOCOMP_FGT + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x65, 0xBE, 0x81, 0x1B, + 0xC7, 0xA0, + 0xD3, 0x11, + 0xB9, + 0x84, + 0x00, + 0xC0, + 0x4F, + 0x2E, + 0x73, + 0xC5 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_H264_IDCT_NOFGT + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x66, 0xBE, 0x81, 0x1B, + 0xC7, 0xA0, + 0xD3, 0x11, + 0xB9, + 0x84, + 0x00, + 0xC0, + 0x4F, + 0x2E, + 0x73, + 0xC5 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_H264_IDCT_FGT + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x67, 0xBE, 0x81, 0x1B, + 0xC7, 0xA0, + 0xD3, 0x11, + 0xB9, + 0x84, + 0x00, + 0xC0, + 0x4F, + 0x2E, + 0x73, + 0xC5 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_H264_VLD_NOFGT + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x68, 0xBE, 0x81, 0x1B, + 0xC7, 0xA0, + 0xD3, 0x11, + 0xB9, + 0x84, + 0x00, + 0xC0, + 0x4F, + 0x2E, + 0x73, + 0xC5 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_H264_VLD_FGT + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x69, 0xBE, 0x81, 0x1B, + 0xC7, 0xA0, + 0xD3, 0x11, + 0xB9, + 0x84, + 0x00, + 0xC0, + 0x4F, + 0x2E, + 0x73, + 0xC5 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_H264_VLD_WITHFMOASO_NOFGT + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xF9, 0x4F, 0xF0, 0xD5, + 0x18, 0x34, + 0xD8, 0x45, + 0x95, + 0x61, + 0x32, + 0xA7, + 0x6A, + 0xAE, + 0x2D, + 0xDD + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_H264_VLD_STEREO_PROGRESSIVE_NOFGT + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xDA, 0xE8, 0x9B, 0xD7, + 0xF1, 0x0C, + 0x81, 0x4C, + 0xB8, + 0x2A, + 0x69, + 0xA4, + 0xE2, + 0x36, + 0xF4, + 0x3D + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_H264_VLD_STEREO_NOFGT + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xBB, 0xCC, 0xAA, 0xF9, + 0xB6, 0xC2, + 0xFC, 0x4C, + 0x87, + 0x79, + 0x57, + 0x07, + 0xB1, + 0x76, + 0x05, + 0x52 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_H264_VLD_MULTIVIEW_NOFGT + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x82, 0x9D, 0x5B, 0x70, + 0xCF, 0x76, + 0xD6, 0x49, + 0xB7, + 0xE6, + 0xAC, + 0x88, + 0x72, + 0xDB, + 0x01, + 0x3C + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_WMV8_POSTPROC + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x80, 0xBE, 0x81, 0x1B, + 0xC7, 0xA0, + 0xD3, 0x11, + 0xB9, + 0x84, + 0x00, + 0xC0, + 0x4F, + 0x2E, + 0x73, + 0xC5 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_WMV8_MOCOMP + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x81, 0xBE, 0x81, 0x1B, + 0xC7, 0xA0, + 0xD3, 0x11, + 0xB9, + 0x84, + 0x00, + 0xC0, + 0x4F, + 0x2E, + 0x73, + 0xC5 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_WMV9_POSTPROC + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x90, 0xBE, 0x81, 0x1B, + 0xC7, 0xA0, + 0xD3, 0x11, + 0xB9, + 0x84, + 0x00, + 0xC0, + 0x4F, + 0x2E, + 0x73, + 0xC5 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_WMV9_MOCOMP + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x91, 0xBE, 0x81, 0x1B, + 0xC7, 0xA0, + 0xD3, 0x11, + 0xB9, + 0x84, + 0x00, + 0xC0, + 0x4F, + 0x2E, + 0x73, + 0xC5 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_WMV9_IDCT + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x94, 0xBE, 0x81, 0x1B, + 0xC7, 0xA0, + 0xD3, 0x11, + 0xB9, + 0x84, + 0x00, + 0xC0, + 0x4F, + 0x2E, + 0x73, + 0xC5 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_VC1_POSTPROC + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xA0, 0xBE, 0x81, 0x1B, + 0xC7, 0xA0, + 0xD3, 0x11, + 0xB9, + 0x84, + 0x00, + 0xC0, + 0x4F, + 0x2E, + 0x73, + 0xC5 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_VC1_MOCOMP + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xA1, 0xBE, 0x81, 0x1B, + 0xC7, 0xA0, + 0xD3, 0x11, + 0xB9, + 0x84, + 0x00, + 0xC0, + 0x4F, + 0x2E, + 0x73, + 0xC5 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_VC1_IDCT + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xA2, 0xBE, 0x81, 0x1B, + 0xC7, 0xA0, + 0xD3, 0x11, + 0xB9, + 0x84, + 0x00, + 0xC0, + 0x4F, + 0x2E, + 0x73, + 0xC5 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_VC1_VLD + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xA3, 0xBE, 0x81, 0x1B, + 0xC7, 0xA0, + 0xD3, 0x11, + 0xB9, + 0x84, + 0x00, + 0xC0, + 0x4F, + 0x2E, + 0x73, + 0xC5 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_VC1_D2010 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xA4, 0xBE, 0x81, 0x1B, + 0xC7, 0xA0, + 0xD3, 0x11, + 0xB9, + 0x84, + 0x00, + 0xC0, + 0x4F, + 0x2E, + 0x73, + 0xC5 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_MPEG4PT2_VLD_SIMPLE + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x74, 0x4D, 0xD6, 0xEF, + 0xE8, 0xC9, + 0xD7, 0x41, + 0xA5, + 0xE9, + 0xE9, + 0xB0, + 0xE3, + 0x9F, + 0xA3, + 0x19 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_MPEG4PT2_VLD_ADVSIMPLE_NOGMC + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x9F, 0x8A, 0x41, 0xED, + 0x0D, 0x01, + 0xDA, 0x4E, + 0x9A, + 0xE3, + 0x9A, + 0x65, + 0x35, + 0x8D, + 0x8D, + 0x2E + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_MPEG4PT2_VLD_ADVSIMPLE_GMC + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x5B, 0x8B, 0x99, 0xAB, + 0x58, 0x42, + 0xA9, 0x44, + 0x9F, + 0xEB, + 0x94, + 0xE5, + 0x97, + 0xA6, + 0xBA, + 0xAE + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_HEVC_VLD_MAIN + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x1B, 0xD5, 0x11, 0x5B, + 0x4C, 0x2F, + 0x52, 0x44, + 0xBC, + 0xC3, + 0x09, + 0xF2, + 0xA1, + 0x16, + 0x0C, + 0xC0 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_HEVC_VLD_MAIN10 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xE0, 0xF0, 0x7A, 0x10, + 0x1A, 0xEF, + 0x19, 0x4D, + 0xAB, + 0xA8, + 0x67, + 0xA1, + 0x63, + 0x07, + 0x3D, + 0x13 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_VP9_VLD_PROFILE0 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xF8, 0x07, 0x37, 0x46, + 0xD0, 0xA1, + 0x85, 0x45, + 0x87, + 0x6D, + 0x83, + 0xAA, + 0x6D, + 0x60, + 0xB8, + 0x9E + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_VP9_VLD_10BIT_PROFILE2 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xEF, 0x49, 0xC7, 0xA4, + 0xCF, 0x6E, + 0xAA, 0x48, + 0x84, + 0x48, + 0x50, + 0xA7, + 0xA1, + 0x16, + 0x5F, + 0xF7 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_VP8_VLD + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xEA, 0x99, 0xB8, 0x90, + 0x62, 0x3A, + 0x05, 0x47, + 0x88, + 0xB3, + 0x8D, + 0xF0, + 0x4B, + 0x27, + 0x44, + 0xE7 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_AV1_VLD_PROFILE0 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xCB, 0x4C, 0xBE, 0xB8, + 0x53, 0xCF, + 0xBA, 0x46, + 0x8D, + 0x59, + 0xD6, + 0xB8, + 0xA6, + 0xDA, + 0x5D, + 0x2A + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_AV1_VLD_PROFILE1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x0F, 0xFF, 0x36, 0x69, + 0xB1, 0x45, + 0x63, 0x41, + 0x9C, + 0xC1, + 0x64, + 0x6E, + 0xF6, + 0x94, + 0x61, + 0x08 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_AV1_VLD_PROFILE2 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xA1, 0x2A, 0x5F, 0x0C, + 0x41, 0xE5, + 0x89, 0x40, + 0xBB, + 0x7B, + 0x98, + 0x11, + 0x0A, + 0x19, + 0xD7, + 0xC8 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_AV1_VLD_12BIT_PROFILE2 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x09, 0x70, 0x12, 0x17, + 0x0F, 0xA0, + 0xE1, 0x4C, + 0x99, + 0x4E, + 0xBF, + 0x40, + 0x81, + 0xF6, + 0xF3, + 0xF0 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_PROFILE_AV1_VLD_12BIT_PROFILE2_420 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xD6, 0xBE, 0x80, 0x2D, + 0xAC, 0x9C, + 0x35, 0x48, + 0x9E, + 0x91, + 0x32, + 0x7B, + 0xBC, + 0x4F, + 0x9E, + 0xE8 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_CRYPTO_TYPE_AES128_CTR + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x11, 0xD7, 0x6B, 0x9B, + 0x74, 0x4F, + 0xC9, 0x41, + 0x9E, + 0x7B, + 0x0B, + 0xE2, + 0xD7, + 0xD9, + 0x3B, + 0x4F + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_ENCRYPTION_HW_CENC + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x4F, 0xAC, 0xD6, 0x89, + 0xF2, 0x09, + 0x29, 0x42, + 0xB2, + 0xCD, + 0x37, + 0x74, + 0x0A, + 0x6D, + 0xFD, + 0x81 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_BITSTREAM_ENCRYPTION_TYPE_CENC + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x35, 0x52, 0x40, 0xB0, + 0x3D, 0xC1, + 0xF2, 0x44, + 0x9A, + 0xE5, + 0xDD, + 0x48, + 0xE0, + 0x8E, + 0x5B, + 0x67 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_DECODER_BITSTREAM_ENCRYPTION_TYPE_CBCS + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x19, 0x93, 0x2D, 0x42, + 0x21, 0x9D, + 0xB7, 0x4B, + 0x93, + 0x71, + 0xFA, + 0xF5, + 0xA8, + 0x2C, + 0x3E, + 0x04 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_KEY_EXCHANGE_HW_PROTECTION + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x8A, 0x0D, 0x17, 0xB1, + 0x8D, 0x62, + 0xA3, 0x4D, + 0xAD, + 0x3B, + 0x82, + 0xDD, + 0xB0, + 0x8B, + 0x49, + 0x70 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_AUTHENTICATED_QUERY_PROTECTION + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x84, 0xB5, 0x4E, 0xA8, + 0x95, 0xC4, + 0xAA, 0x48, + 0xB9, + 0x4D, + 0x8B, + 0xD2, + 0xD6, + 0xFB, + 0xCE, + 0x05 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_AUTHENTICATED_QUERY_CHANNEL_TYPE + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xA5, 0x18, 0x1B, 0xBC, + 0xFB, 0xB1, + 0xAB, 0x42, + 0xBD, + 0x94, + 0xB5, + 0x82, + 0x8B, + 0x4B, + 0xF7, + 0xBE + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_AUTHENTICATED_QUERY_DEVICE_HANDLE + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x9D, 0x53, 0x1C, 0xEC, + 0xFF, 0x8C, + 0x2A, 0x4E, + 0xBC, + 0xC4, + 0xF5, + 0x69, + 0x2F, + 0x99, + 0xF4, + 0x80 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_AUTHENTICATED_QUERY_CRYPTO_SESSION + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x9E, 0x49, 0x34, 0x26, + 0x18, 0xD0, + 0x74, 0x4D, + 0xAC, + 0x17, + 0x7F, + 0x72, + 0x40, + 0x59, + 0x52, + 0x8D + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_AUTHENTICATED_QUERY_RESTRICTED_SHARED_RESOURCE_PROCESS_COUNT + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xB3, 0x07, 0xB2, 0x0D, + 0x50, 0x94, + 0xA6, 0x46, + 0x82, + 0xDE, + 0x1B, + 0x96, + 0xD4, + 0x4F, + 0x9C, + 0xF2 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_AUTHENTICATED_QUERY_RESTRICTED_SHARED_RESOURCE_PROCESS + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xDB, 0xBA, 0x9B, 0x64, + 0xF4, 0xF0, + 0x39, 0x46, + 0xA1, + 0x5B, + 0x24, + 0x39, + 0x3F, + 0xC3, + 0xAB, + 0xAC + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_AUTHENTICATED_QUERY_UNRESTRICTED_PROTECTED_SHARED_RESOURCE_COUNT + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xD6, 0x0B, 0x2F, 0x01, + 0x62, 0xE6, + 0x74, 0x44, + 0xBE, + 0xFD, + 0xAA, + 0x53, + 0xE5, + 0x14, + 0x3C, + 0x6D + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_AUTHENTICATED_QUERY_OUTPUT_ID_COUNT + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x5E, 0x2B, 0x04, 0x2C, + 0x07, 0x8C, + 0xD5, 0x46, + 0xAA, + 0xBE, + 0x8F, + 0x75, + 0xCB, + 0xAD, + 0x4C, + 0x31 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_AUTHENTICATED_QUERY_OUTPUT_ID + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xA3, 0xDC, 0x9D, 0x83, + 0x4E, 0x9B, + 0xE4, 0x41, + 0xB0, + 0x53, + 0x89, + 0x2B, + 0xD2, + 0xA1, + 0x1E, + 0xE7 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_AUTHENTICATED_QUERY_ACCESSIBILITY_ATTRIBUTES + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xD2, 0xD9, 0x14, 0x62, + 0x2C, 0x43, + 0xBB, 0x4A, + 0x9F, + 0xCE, + 0x21, + 0x6E, + 0xEA, + 0x26, + 0x9E, + 0x3B + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_AUTHENTICATED_QUERY_ENCRYPTION_WHEN_ACCESSIBLE_GUID_COUNT + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x66, 0x70, 0x0F, 0xB3, + 0x3C, 0x20, + 0x07, 0x4B, + 0x93, + 0xFC, + 0xCE, + 0xAA, + 0xFD, + 0x61, + 0x24, + 0x1E + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_AUTHENTICATED_QUERY_ENCRYPTION_WHEN_ACCESSIBLE_GUID + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x58, 0x59, 0x3A, 0xF8, + 0x86, 0xE9, + 0xDA, 0x4B, + 0xBE, + 0xB0, + 0x41, + 0x1F, + 0x6A, + 0x7A, + 0x01, + 0xB7 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_AUTHENTICATED_QUERY_CURRENT_ENCRYPTION_WHEN_ACCESSIBLE + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xC7, 0x91, 0x17, 0xEC, + 0xD3, 0xDA, + 0x15, 0x4F, + 0x9E, + 0xC3, + 0xFA, + 0xA9, + 0x3D, + 0x60, + 0xD4, + 0xF0 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_AUTHENTICATED_CONFIGURE_INITIALIZE + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xDB, 0x4B, 0x11, 0x06, + 0x23, 0x35, + 0x0A, 0x47, + 0x8D, + 0xCA, + 0xFB, + 0xC2, + 0x84, + 0x51, + 0x54, + 0xF0 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_AUTHENTICATED_CONFIGURE_PROTECTION + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x58, 0x56, 0x45, 0x50, + 0x47, 0x3F, + 0x62, 0x43, + 0xBF, + 0x99, + 0xBF, + 0xDF, + 0xCD, + 0xE9, + 0xED, + 0x29 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_AUTHENTICATED_CONFIGURE_CRYPTO_SESSION + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x54, 0xCC, 0x46, 0x63, + 0xFC, 0x2C, + 0xD4, 0x4A, + 0x82, + 0x24, + 0xD1, + 0x58, + 0x37, + 0xDE, + 0x77, + 0x00 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_AUTHENTICATED_CONFIGURE_SHARED_RESOURCE + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x47, 0xD0, 0x72, 0x07, + 0x40, 0x1B, + 0xE8, 0x48, + 0x9C, + 0xA6, + 0xB5, + 0xF5, + 0x10, + 0xDE, + 0x9F, + 0x01 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_AUTHENTICATED_CONFIGURE_ENCRYPTION_WHEN_ACCESSIBLE + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x86, 0xF2, 0xFF, 0x41, + 0xE0, 0x6A, + 0x43, 0x4D, + 0x9D, + 0x55, + 0xA4, + 0x6E, + 0x9E, + 0xFD, + 0x15, + 0x8A + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D11_KEY_EXCHANGE_RSAES_OAEP + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x95, 0x98, 0x94, 0xC1, + 0x2A, 0xD7, + 0x1D, 0x4A, + 0x8E, + 0x5D, + 0xED, + 0x85, + 0x7D, + 0x17, + 0x15, + 0x20 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + public const uint D3D11_SDK_VERSION = 7; public const uint D3D11_PACKED_TILE = 4294967295; public const uint D3D11_SDK_LAYERS_VERSION = 1; @@ -474,7 +1900,30 @@ public static partial class Apis public const uint D3D11_DEBUG_FEATURE_NEVER_DISCARD_OFFERED_RESOURCE = 16; public const uint D3D11_DEBUG_FEATURE_AVOID_BEHAVIOR_CHANGING_DEBUG_AIDS = 64; public const uint D3D11_DEBUG_FEATURE_DISABLE_TILED_RESOURCE_MAPPING_TRACKING_AND_VALIDATION = 128; - public static readonly Guid DXGI_DEBUG_D3D11 = new Guid(0x4b99317b, 0xac39, 0x4aa6, 0xbb, 0x0b, 0xba, 0xa0, 0x47, 0x84, 0x79, 0x8f); + public static ref readonly Guid DXGI_DEBUG_D3D11 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x7B, 0x31, 0x99, 0x4B, + 0x39, 0xAC, + 0xA6, 0x4A, + 0xBB, + 0x0B, + 0xBA, + 0xA0, + 0x47, + 0x84, + 0x79, + 0x8F + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + public const uint D3D11_INFO_QUEUE_DEFAULT_MESSAGE_COUNT_LIMIT = 1024; public const int D3D_RETURN_PARAMETER_INDEX = -1; public const uint D3D_SHADER_REQUIRES_DOUBLES = 1; @@ -6993,7 +8442,7 @@ public partial struct AuthenticatedProtectionFlags public partial struct InputElementDescription { /// - public unsafe byte* SemanticName; + public unsafe sbyte* SemanticName; /// public uint SemanticIndex; @@ -7022,7 +8471,7 @@ public partial struct SODeclarationEntry public uint Stream; /// - public unsafe byte* SemanticName; + public unsafe sbyte* SemanticName; /// public uint SemanticIndex; @@ -11178,7 +12627,7 @@ public partial struct FeatureDataD3D11Options4 public partial struct SignatureParameterDescription { /// - public unsafe byte* SemanticName; + public unsafe sbyte* SemanticName; /// public uint SemanticIndex; @@ -11210,7 +12659,7 @@ public partial struct SignatureParameterDescription public partial struct ShaderBufferDescription { /// - public unsafe byte* Name; + public unsafe sbyte* Name; /// public Graphics.Direct3D.CBufferType Type; @@ -11230,7 +12679,7 @@ public partial struct ShaderBufferDescription public partial struct ShaderVariableDescription { /// - public unsafe byte* Name; + public unsafe sbyte* Name; /// public uint StartOffset; @@ -11283,7 +12732,7 @@ public partial struct ShaderTypeDescription public uint Offset; /// - public unsafe byte* Name; + public unsafe sbyte* Name; } /// @@ -11294,7 +12743,7 @@ public partial struct ShaderDescription public uint Version; /// - public unsafe byte* Creator; + public unsafe sbyte* Creator; /// public uint Flags; @@ -11410,7 +12859,7 @@ public partial struct ShaderDescription public partial struct ShaderInputBindDescription { /// - public unsafe byte* Name; + public unsafe sbyte* Name; /// public Graphics.Direct3D.ShaderInputType Type; @@ -11439,7 +12888,7 @@ public partial struct ShaderInputBindDescription public partial struct LibraryDescription { /// - public unsafe byte* Creator; + public unsafe sbyte* Creator; /// public uint Flags; @@ -11456,7 +12905,7 @@ public partial struct FunctionDescription public uint Version; /// - public unsafe byte* Creator; + public unsafe sbyte* Creator; /// public uint Flags; @@ -11537,7 +12986,7 @@ public partial struct FunctionDescription public ulong RequiredFeatureFlags; /// - public unsafe byte* Name; + public unsafe sbyte* Name; /// public int FunctionParameterCount; @@ -11557,10 +13006,10 @@ public partial struct FunctionDescription public partial struct ParameterDescription { /// - public unsafe byte* Name; + public unsafe sbyte* Name; /// - public unsafe byte* SemanticName; + public unsafe sbyte* SemanticName; /// public Graphics.Direct3D.ShaderVariableType Type; @@ -14956,17 +16405,17 @@ public unsafe partial struct ID3D11ClassLinkage /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(7)] - public HResult GetClassInstance(byte** pClassInstanceName, uint InstanceIndex, ID3D11ClassInstance** ppInstance) + public HResult GetClassInstance(sbyte* pClassInstanceName, uint InstanceIndex, ID3D11ClassInstance** ppInstance) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11ClassLinkage*)Unsafe.AsPointer(ref this), pClassInstanceName, InstanceIndex, ppInstance); + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11ClassLinkage*)Unsafe.AsPointer(ref this), pClassInstanceName, InstanceIndex, ppInstance); } /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(8)] - public HResult CreateClassInstance(byte** pClassTypeName, uint ConstantBufferOffset, uint ConstantVectorOffset, uint TextureOffset, uint SamplerOffset, ID3D11ClassInstance** ppInstance) + public HResult CreateClassInstance(sbyte* pClassTypeName, uint ConstantBufferOffset, uint ConstantVectorOffset, uint TextureOffset, uint SamplerOffset, ID3D11ClassInstance** ppInstance) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11ClassLinkage*)Unsafe.AsPointer(ref this), pClassTypeName, ConstantBufferOffset, ConstantVectorOffset, TextureOffset, SamplerOffset, ppInstance); + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11ClassLinkage*)Unsafe.AsPointer(ref this), pClassTypeName, ConstantBufferOffset, ConstantVectorOffset, TextureOffset, SamplerOffset, ppInstance); } } @@ -18825,17 +20274,17 @@ public unsafe partial struct ID3D11InfoQueue /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(28)] - public HResult AddMessage(MessageCategory Category, MessageSeverity Severity, MessageId ID, byte** pDescription) + public HResult AddMessage(MessageCategory Category, MessageSeverity Severity, MessageId ID, sbyte* pDescription) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this), Category, Severity, ID, pDescription); + return ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this), Category, Severity, ID, pDescription); } /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(29)] - public HResult AddApplicationMessage(MessageSeverity Severity, byte** pDescription) + public HResult AddApplicationMessage(MessageSeverity Severity, sbyte* pDescription) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this), Severity, pDescription); + return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this), Severity, pDescription); } /// @@ -21817,9 +23266,9 @@ public unsafe partial struct ID3D11Device1 /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(49)] - public HResult OpenSharedResourceByName(char** lpName, uint dwDesiredAccess, Guid* returnedInterface, void** ppResource) + public HResult OpenSharedResourceByName(ushort* lpName, uint dwDesiredAccess, Guid* returnedInterface, void** ppResource) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[49]))((ID3D11Device1*)Unsafe.AsPointer(ref this), lpName, dwDesiredAccess, returnedInterface, ppResource); + return ((delegate* unmanaged[Stdcall])(lpVtbl[49]))((ID3D11Device1*)Unsafe.AsPointer(ref this), lpName, dwDesiredAccess, returnedInterface, ppResource); } } @@ -21888,9 +23337,9 @@ public unsafe partial struct ID3DUserDefinedAnnotation /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(3)] - public int BeginEvent(char** Name) + public int BeginEvent(ushort* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3DUserDefinedAnnotation*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3DUserDefinedAnnotation*)Unsafe.AsPointer(ref this), Name); } /// @@ -21904,9 +23353,9 @@ public unsafe partial struct ID3DUserDefinedAnnotation /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(5)] - public void SetMarker(char** Name) + public void SetMarker(ushort* Name) { - ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3DUserDefinedAnnotation*)Unsafe.AsPointer(ref this), Name); + ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3DUserDefinedAnnotation*)Unsafe.AsPointer(ref this), Name); } /// @@ -23087,17 +24536,17 @@ public unsafe partial struct ID3D11DeviceContext2 /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(141)] - public void SetMarkerInt(char** pLabel, int Data) + public void SetMarkerInt(ushort* pLabel, int Data) { - ((delegate* unmanaged[Stdcall])(lpVtbl[141]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pLabel, Data); + ((delegate* unmanaged[Stdcall])(lpVtbl[141]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pLabel, Data); } /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(142)] - public void BeginEventInt(char** pLabel, int Data) + public void BeginEventInt(ushort* pLabel, int Data) { - ((delegate* unmanaged[Stdcall])(lpVtbl[142]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pLabel, Data); + ((delegate* unmanaged[Stdcall])(lpVtbl[142]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this), pLabel, Data); } /// @@ -23222,9 +24671,9 @@ public unsafe partial struct ID3D11Device2 /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(9)] - public HResult OpenSharedResourceByName(char** lpName, uint dwDesiredAccess, Guid* returnedInterface, void** ppResource) + public HResult OpenSharedResourceByName(ushort* lpName, uint dwDesiredAccess, Guid* returnedInterface, void** ppResource) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11Device2*)Unsafe.AsPointer(ref this), lpName, dwDesiredAccess, returnedInterface, ppResource); + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11Device2*)Unsafe.AsPointer(ref this), lpName, dwDesiredAccess, returnedInterface, ppResource); } /// @@ -24566,17 +26015,17 @@ public unsafe partial struct ID3D11DeviceContext3 /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(10)] - public void SetMarkerInt(char** pLabel, int Data) + public void SetMarkerInt(ushort* pLabel, int Data) { - ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pLabel, Data); + ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pLabel, Data); } /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(11)] - public void BeginEventInt(char** pLabel, int Data) + public void BeginEventInt(ushort* pLabel, int Data) { - ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pLabel, Data); + ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pLabel, Data); } /// @@ -25757,9 +27206,9 @@ public unsafe partial struct ID3D11Fence /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(7)] - public HResult CreateSharedHandle(Security.SECURITY_ATTRIBUTES* pAttributes, uint dwAccess, char** lpName, IntPtr* pHandle) + public HResult CreateSharedHandle(Security.SECURITY_ATTRIBUTES* pAttributes, uint dwAccess, ushort* lpName, IntPtr* pHandle) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11Fence*)Unsafe.AsPointer(ref this), pAttributes, dwAccess, lpName, pHandle); + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11Fence*)Unsafe.AsPointer(ref this), pAttributes, dwAccess, lpName, pHandle); } /// @@ -25924,17 +27373,17 @@ public unsafe partial struct ID3D11DeviceContext4 /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(13)] - public void SetMarkerInt(char** pLabel, int Data) + public void SetMarkerInt(ushort* pLabel, int Data) { - ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pLabel, Data); + ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pLabel, Data); } /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(14)] - public void BeginEventInt(char** pLabel, int Data) + public void BeginEventInt(ushort* pLabel, int Data) { - ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pLabel, Data); + ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pLabel, Data); } /// @@ -27155,9 +28604,9 @@ public unsafe partial struct ID3D11Device3 /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(13)] - public HResult OpenSharedResourceByName(char** lpName, uint dwDesiredAccess, Guid* returnedInterface, void** ppResource) + public HResult OpenSharedResourceByName(ushort* lpName, uint dwDesiredAccess, Guid* returnedInterface, void** ppResource) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D11Device3*)Unsafe.AsPointer(ref this), lpName, dwDesiredAccess, returnedInterface, ppResource); + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D11Device3*)Unsafe.AsPointer(ref this), lpName, dwDesiredAccess, returnedInterface, ppResource); } /// @@ -27802,9 +29251,9 @@ public unsafe partial struct ID3D11Device4 /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(24)] - public HResult OpenSharedResourceByName(char** lpName, uint dwDesiredAccess, Guid* returnedInterface, void** ppResource) + public HResult OpenSharedResourceByName(ushort* lpName, uint dwDesiredAccess, Guid* returnedInterface, void** ppResource) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((ID3D11Device4*)Unsafe.AsPointer(ref this), lpName, dwDesiredAccess, returnedInterface, ppResource); + return ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((ID3D11Device4*)Unsafe.AsPointer(ref this), lpName, dwDesiredAccess, returnedInterface, ppResource); } /// @@ -28393,9 +29842,9 @@ public unsafe partial struct ID3D11Device5 /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(26)] - public HResult OpenSharedResourceByName(char** lpName, uint dwDesiredAccess, Guid* returnedInterface, void** ppResource) + public HResult OpenSharedResourceByName(ushort* lpName, uint dwDesiredAccess, Guid* returnedInterface, void** ppResource) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((ID3D11Device5*)Unsafe.AsPointer(ref this), lpName, dwDesiredAccess, returnedInterface, ppResource); + return ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((ID3D11Device5*)Unsafe.AsPointer(ref this), lpName, dwDesiredAccess, returnedInterface, ppResource); } /// @@ -30552,17 +32001,17 @@ public unsafe partial struct ID3D11ShaderReflectionType /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(2)] - public Graphics.Direct3D11.ID3D11ShaderReflectionType GetMemberTypeByName(byte** Name) + public Graphics.Direct3D11.ID3D11ShaderReflectionType GetMemberTypeByName(sbyte* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((ID3D11ShaderReflectionType*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((ID3D11ShaderReflectionType*)Unsafe.AsPointer(ref this), Name); } /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(3)] - public byte* GetMemberTypeName(uint Index) + public sbyte* GetMemberTypeName(uint Index) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11ShaderReflectionType*)Unsafe.AsPointer(ref this), Index); + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11ShaderReflectionType*)Unsafe.AsPointer(ref this), Index); } /// @@ -30742,9 +32191,9 @@ public unsafe partial struct ID3D11ShaderReflectionConstantBuffer /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(2)] - public Graphics.Direct3D11.ID3D11ShaderReflectionVariable GetVariableByName(byte** Name) + public Graphics.Direct3D11.ID3D11ShaderReflectionVariable GetVariableByName(sbyte* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((ID3D11ShaderReflectionConstantBuffer*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((ID3D11ShaderReflectionConstantBuffer*)Unsafe.AsPointer(ref this), Name); } } @@ -30829,9 +32278,9 @@ public unsafe partial struct ID3D11ShaderReflection /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(5)] - public Graphics.Direct3D11.ID3D11ShaderReflectionConstantBuffer GetConstantBufferByName(byte** Name) + public Graphics.Direct3D11.ID3D11ShaderReflectionConstantBuffer GetConstantBufferByName(sbyte* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this), Name); } /// @@ -30869,17 +32318,17 @@ public unsafe partial struct ID3D11ShaderReflection /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(10)] - public Graphics.Direct3D11.ID3D11ShaderReflectionVariable GetVariableByName(byte** Name) + public Graphics.Direct3D11.ID3D11ShaderReflectionVariable GetVariableByName(sbyte* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this), Name); } /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(11)] - public HResult GetResourceBindingDescByName(byte** Name, ShaderInputBindDescription* pDesc) + public HResult GetResourceBindingDescByName(sbyte* Name, ShaderInputBindDescription* pDesc) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this), Name, pDesc); + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this), Name, pDesc); } /// @@ -31095,9 +32544,9 @@ public unsafe partial struct ID3D11FunctionReflection /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(2)] - public Graphics.Direct3D11.ID3D11ShaderReflectionConstantBuffer GetConstantBufferByName(byte** Name) + public Graphics.Direct3D11.ID3D11ShaderReflectionConstantBuffer GetConstantBufferByName(sbyte* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((ID3D11FunctionReflection*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((ID3D11FunctionReflection*)Unsafe.AsPointer(ref this), Name); } /// @@ -31111,17 +32560,17 @@ public unsafe partial struct ID3D11FunctionReflection /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(4)] - public Graphics.Direct3D11.ID3D11ShaderReflectionVariable GetVariableByName(byte** Name) + public Graphics.Direct3D11.ID3D11ShaderReflectionVariable GetVariableByName(sbyte* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11FunctionReflection*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11FunctionReflection*)Unsafe.AsPointer(ref this), Name); } /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(5)] - public HResult GetResourceBindingDescByName(byte** Name, ShaderInputBindDescription* pDesc) + public HResult GetResourceBindingDescByName(sbyte* Name, ShaderInputBindDescription* pDesc) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11FunctionReflection*)Unsafe.AsPointer(ref this), Name, pDesc); + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11FunctionReflection*)Unsafe.AsPointer(ref this), Name, pDesc); } /// @@ -31249,9 +32698,9 @@ public unsafe partial struct ID3D11ModuleInstance /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(4)] - public HResult BindConstantBufferByName(byte** pName, uint uDstSlot, uint cbDstOffset) + public HResult BindConstantBufferByName(sbyte* pName, uint uDstSlot, uint cbDstOffset) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11ModuleInstance*)Unsafe.AsPointer(ref this), pName, uDstSlot, cbDstOffset); + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11ModuleInstance*)Unsafe.AsPointer(ref this), pName, uDstSlot, cbDstOffset); } /// @@ -31265,9 +32714,9 @@ public unsafe partial struct ID3D11ModuleInstance /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(6)] - public HResult BindResourceByName(byte** pName, uint uDstSlot, uint uCount) + public HResult BindResourceByName(sbyte* pName, uint uDstSlot, uint uCount) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11ModuleInstance*)Unsafe.AsPointer(ref this), pName, uDstSlot, uCount); + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11ModuleInstance*)Unsafe.AsPointer(ref this), pName, uDstSlot, uCount); } /// @@ -31281,9 +32730,9 @@ public unsafe partial struct ID3D11ModuleInstance /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(8)] - public HResult BindSamplerByName(byte** pName, uint uDstSlot, uint uCount) + public HResult BindSamplerByName(sbyte* pName, uint uDstSlot, uint uCount) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11ModuleInstance*)Unsafe.AsPointer(ref this), pName, uDstSlot, uCount); + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11ModuleInstance*)Unsafe.AsPointer(ref this), pName, uDstSlot, uCount); } /// @@ -31297,9 +32746,9 @@ public unsafe partial struct ID3D11ModuleInstance /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(10)] - public HResult BindUnorderedAccessViewByName(byte** pName, uint uDstSlot, uint uCount) + public HResult BindUnorderedAccessViewByName(sbyte* pName, uint uDstSlot, uint uCount) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D11ModuleInstance*)Unsafe.AsPointer(ref this), pName, uDstSlot, uCount); + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D11ModuleInstance*)Unsafe.AsPointer(ref this), pName, uDstSlot, uCount); } /// @@ -31313,9 +32762,9 @@ public unsafe partial struct ID3D11ModuleInstance /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(12)] - public HResult BindResourceAsUnorderedAccessViewByName(byte** pSrvName, uint uDstUavSlot, uint uCount) + public HResult BindResourceAsUnorderedAccessViewByName(sbyte* pSrvName, uint uDstUavSlot, uint uCount) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D11ModuleInstance*)Unsafe.AsPointer(ref this), pSrvName, uDstUavSlot, uCount); + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D11ModuleInstance*)Unsafe.AsPointer(ref this), pSrvName, uDstUavSlot, uCount); } } @@ -31384,9 +32833,9 @@ public unsafe partial struct ID3D11Module /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(3)] - public HResult CreateInstance(byte** pNamespace, ID3D11ModuleInstance** ppModuleInstance) + public HResult CreateInstance(sbyte* pNamespace, ID3D11ModuleInstance** ppModuleInstance) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11Module*)Unsafe.AsPointer(ref this), pNamespace, ppModuleInstance); + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11Module*)Unsafe.AsPointer(ref this), pNamespace, ppModuleInstance); } } @@ -31455,9 +32904,9 @@ public unsafe partial struct ID3D11Linker /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(3)] - public HResult Link(ID3D11ModuleInstance* pEntry, byte** pEntryName, byte** pTargetName, uint uFlags, Graphics.Direct3D.ID3DBlob** ppShaderBlob, Graphics.Direct3D.ID3DBlob* ppErrorBuffer) + public HResult Link(ID3D11ModuleInstance* pEntry, sbyte* pEntryName, sbyte* pTargetName, uint uFlags, Graphics.Direct3D.ID3DBlob** ppShaderBlob, Graphics.Direct3D.ID3DBlob* ppErrorBuffer) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11Linker*)Unsafe.AsPointer(ref this), pEntry, pEntryName, pTargetName, uFlags, ppShaderBlob, ppErrorBuffer); + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11Linker*)Unsafe.AsPointer(ref this), pEntry, pEntryName, pTargetName, uFlags, ppShaderBlob, ppErrorBuffer); } /// @@ -31629,9 +33078,9 @@ public unsafe partial struct ID3D11FunctionLinkingGraph /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(6)] - public HResult CallFunction(byte** pModuleInstanceNamespace, ID3D11Module* pModuleWithFunctionPrototype, byte** pFunctionName, ID3D11LinkingNode** ppCallNode) + public HResult CallFunction(sbyte* pModuleInstanceNamespace, ID3D11Module* pModuleWithFunctionPrototype, sbyte* pFunctionName, ID3D11LinkingNode** ppCallNode) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11FunctionLinkingGraph*)Unsafe.AsPointer(ref this), pModuleInstanceNamespace, pModuleWithFunctionPrototype, pFunctionName, ppCallNode); + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11FunctionLinkingGraph*)Unsafe.AsPointer(ref this), pModuleInstanceNamespace, pModuleWithFunctionPrototype, pFunctionName, ppCallNode); } /// @@ -31645,9 +33094,9 @@ public unsafe partial struct ID3D11FunctionLinkingGraph /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(8)] - public HResult PassValueWithSwizzle(ID3D11LinkingNode* pSrcNode, int SrcParameterIndex, byte** pSrcSwizzle, ID3D11LinkingNode* pDstNode, int DstParameterIndex, byte** pDstSwizzle) + public HResult PassValueWithSwizzle(ID3D11LinkingNode* pSrcNode, int SrcParameterIndex, sbyte* pSrcSwizzle, ID3D11LinkingNode* pDstNode, int DstParameterIndex, sbyte* pDstSwizzle) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11FunctionLinkingGraph*)Unsafe.AsPointer(ref this), pSrcNode, SrcParameterIndex, pSrcSwizzle, pDstNode, DstParameterIndex, pDstSwizzle); + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11FunctionLinkingGraph*)Unsafe.AsPointer(ref this), pSrcNode, SrcParameterIndex, pSrcSwizzle, pDstNode, DstParameterIndex, pDstSwizzle); } /// diff --git a/src/Vortice.Win32/Generated/Graphics/Direct3D12.cs b/src/Vortice.Win32/Generated/Graphics/Direct3D12.cs index ff4f5ef..2a3a0d9 100644 --- a/src/Vortice.Win32/Generated/Graphics/Direct3D12.cs +++ b/src/Vortice.Win32/Generated/Graphics/Direct3D12.cs @@ -452,15 +452,176 @@ public static partial class Apis public const uint D3D12_MIP_FILTER_SHIFT = 0; public const uint D3D12_ANISOTROPIC_FILTERING_BIT = 64; public const uint LUID_DEFINED = 1; - public static readonly Guid D3D12_PROTECTED_RESOURCES_SESSION_HARDWARE_PROTECTED = new Guid(0x62b0084e, 0xc70e, 0x4daa, 0xa1, 0x09, 0x30, 0xff, 0x8d, 0x5a, 0x04, 0x82); - public static readonly Guid CLSID_D3D12Debug = new Guid(0xf2352aeb, 0xdd84, 0x49fe, 0xb9, 0x7b, 0xa9, 0xdc, 0xfd, 0xcc, 0x1b, 0x4f); - public static readonly Guid CLSID_D3D12Tools = new Guid(0xe38216b1, 0x3c8c, 0x4833, 0xaa, 0x09, 0x0a, 0x06, 0xb6, 0x5d, 0x96, 0xc8); - public static readonly Guid CLSID_D3D12DeviceRemovedExtendedData = new Guid(0x4a75bbc4, 0x9ff4, 0x4ad8, 0x9f, 0x18, 0xab, 0xae, 0x84, 0xdc, 0x5f, 0xf2); - public static readonly Guid CLSID_D3D12SDKConfiguration = new Guid(0x7cda6aca, 0xa03e, 0x49c8, 0x94, 0x58, 0x03, 0x34, 0xd2, 0x0e, 0x07, 0xce); + public static ref readonly Guid D3D12_PROTECTED_RESOURCES_SESSION_HARDWARE_PROTECTED + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x4E, 0x08, 0xB0, 0x62, + 0x0E, 0xC7, + 0xAA, 0x4D, + 0xA1, + 0x09, + 0x30, + 0xFF, + 0x8D, + 0x5A, + 0x04, + 0x82 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_D3D12Debug + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xEB, 0x2A, 0x35, 0xF2, + 0x84, 0xDD, + 0xFE, 0x49, + 0xB9, + 0x7B, + 0xA9, + 0xDC, + 0xFD, + 0xCC, + 0x1B, + 0x4F + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_D3D12Tools + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xB1, 0x16, 0x82, 0xE3, + 0x8C, 0x3C, + 0x33, 0x48, + 0xAA, + 0x09, + 0x0A, + 0x06, + 0xB6, + 0x5D, + 0x96, + 0xC8 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_D3D12DeviceRemovedExtendedData + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xC4, 0xBB, 0x75, 0x4A, + 0xF4, 0x9F, + 0xD8, 0x4A, + 0x9F, + 0x18, + 0xAB, + 0xAE, + 0x84, + 0xDC, + 0x5F, + 0xF2 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_D3D12SDKConfiguration + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xCA, 0x6A, 0xDA, 0x7C, + 0x3E, 0xA0, + 0xC8, 0x49, + 0x94, + 0x58, + 0x03, + 0x34, + 0xD2, + 0x0E, + 0x07, + 0xCE + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + public const uint D3D12_SHADING_RATE_X_AXIS_SHIFT = 2; public const uint D3D12_SHADING_RATE_VALID_MASK = 3; - public static readonly Guid WKPDID_D3DAutoDebugObjectNameW = new Guid(0xd4902e36, 0x757a, 0x4942, 0x95, 0x94, 0xb6, 0x76, 0x9a, 0xfa, 0x43, 0xcd); - public static readonly Guid DXGI_DEBUG_D3D12 = new Guid(0xcf59a98c, 0xa950, 0x4326, 0x91, 0xef, 0x9b, 0xba, 0xa1, 0x7b, 0xfd, 0x95); + public static ref readonly Guid WKPDID_D3DAutoDebugObjectNameW + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x36, 0x2E, 0x90, 0xD4, + 0x7A, 0x75, + 0x42, 0x49, + 0x95, + 0x94, + 0xB6, + 0x76, + 0x9A, + 0xFA, + 0x43, + 0xCD + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid DXGI_DEBUG_D3D12 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x8C, 0xA9, 0x59, 0xCF, + 0x50, 0xA9, + 0x26, 0x43, + 0x91, + 0xEF, + 0x9B, + 0xBA, + 0xA1, + 0x7B, + 0xFD, + 0x95 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + public const uint D3D12_INFO_QUEUE_DEFAULT_MESSAGE_COUNT_LIMIT = 1024; public const uint D3D_SHADER_REQUIRES_STENCIL_REF = 512; public const uint D3D_SHADER_REQUIRES_INNER_COVERAGE = 1024; @@ -482,9 +643,78 @@ public static partial class Apis public const uint D3D_SHADER_REQUIRES_SAMPLER_DESCRIPTOR_HEAP_INDEXING = 67108864; public const uint D3D_SHADER_REQUIRES_WAVE_MMA = 134217728; public const uint D3D_SHADER_REQUIRES_ATOMIC_INT64_ON_DESCRIPTOR_HEAP_RESOURCE = 268435456; - public static readonly Guid D3D12ExperimentalShaderModels = new Guid(0x76f5573e, 0xf13a, 0x40f5, 0xb2, 0x97, 0x81, 0xce, 0x9e, 0x18, 0x93, 0x3f); - public static readonly Guid D3D12TiledResourceTier4 = new Guid(0xc9c4725f, 0xa81a, 0x4f56, 0x8c, 0x5b, 0xc5, 0x10, 0x39, 0xd6, 0x94, 0xfb); - public static readonly Guid D3D12MetaCommand = new Guid(0xc734c97e, 0x8077, 0x48c8, 0x9f, 0xdc, 0xd9, 0xd1, 0xdd, 0x31, 0xdd, 0x77); + public static ref readonly Guid D3D12ExperimentalShaderModels + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x3E, 0x57, 0xF5, 0x76, + 0x3A, 0xF1, + 0xF5, 0x40, + 0xB2, + 0x97, + 0x81, + 0xCE, + 0x9E, + 0x18, + 0x93, + 0x3F + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D12TiledResourceTier4 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x5F, 0x72, 0xC4, 0xC9, + 0x1A, 0xA8, + 0x56, 0x4F, + 0x8C, + 0x5B, + 0xC5, + 0x10, + 0x39, + 0xD6, + 0x94, + 0xFB + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid D3D12MetaCommand + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x7E, 0xC9, 0x34, 0xC7, + 0x77, 0x80, + 0xC8, 0x48, + 0x9F, + 0xDC, + 0xD9, + 0xD1, + 0xDD, + 0x31, + 0xDD, + 0x77 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + } #region Enums @@ -6721,7 +6951,7 @@ public partial struct CommandQueueDescription public partial struct InputElementDescription { /// - public unsafe byte* SemanticName; + public unsafe sbyte* SemanticName; /// public uint SemanticIndex; @@ -6750,7 +6980,7 @@ public partial struct SODeclarationEntry public uint Stream; /// - public unsafe byte* SemanticName; + public unsafe sbyte* SemanticName; /// public uint SemanticIndex; @@ -10146,7 +10376,7 @@ public partial struct ProtectedResourceSessionDescription public partial struct MetaCommandParameterDescription { /// - public unsafe char* Name; + public unsafe ushort* Name; /// public MetaCommandParameterType Type; @@ -10169,7 +10399,7 @@ public partial struct MetaCommandDescription public Guid Id; /// - public unsafe char* Name; + public unsafe ushort* Name; /// public GraphicsStates InitializationDirtyState; @@ -10226,10 +10456,10 @@ public partial struct NodeMask public partial struct ExportDescription { /// - public unsafe char* Name; + public unsafe ushort* Name; /// - public unsafe char* ExportToRename; + public unsafe ushort* ExportToRename; /// public ExportFlags Flags; @@ -10274,7 +10504,7 @@ public partial struct SubObjectToExportsAssociation public uint NumExports; /// - public unsafe char** pExports; + public unsafe ushort** pExports; } /// @@ -10282,13 +10512,13 @@ public partial struct SubObjectToExportsAssociation public partial struct DxilSubObjectToExportsAssociation { /// - public unsafe char* SubobjectToAssociate; + public unsafe ushort* SubobjectToAssociate; /// public uint NumExports; /// - public unsafe char** pExports; + public unsafe ushort** pExports; } /// @@ -10296,19 +10526,19 @@ public partial struct DxilSubObjectToExportsAssociation public partial struct HitGroupDescription { /// - public unsafe char* HitGroupExport; + public unsafe ushort* HitGroupExport; /// public HitGroupType Type; /// - public unsafe char* AnyHitShaderImport; + public unsafe ushort* AnyHitShaderImport; /// - public unsafe char* ClosestHitShaderImport; + public unsafe ushort* ClosestHitShaderImport; /// - public unsafe char* IntersectionShaderImport; + public unsafe ushort* IntersectionShaderImport; } /// @@ -10726,13 +10956,13 @@ public partial struct AutoBreadcrumbNode public unsafe byte* pCommandListDebugNameA; /// - public unsafe char* pCommandListDebugNameW; + public unsafe ushort* pCommandListDebugNameW; /// public unsafe byte* pCommandQueueDebugNameA; /// - public unsafe char* pCommandQueueDebugNameW; + public unsafe ushort* pCommandQueueDebugNameW; /// public ID3D12GraphicsCommandList pCommandList; @@ -10761,7 +10991,7 @@ public partial struct DredBreadcrumbContext public uint BreadcrumbIndex; /// - public unsafe char* pContextString; + public unsafe ushort* pContextString; } /// @@ -10772,13 +11002,13 @@ public partial struct AutoBreadcrumbNode1 public unsafe byte* pCommandListDebugNameA; /// - public unsafe char* pCommandListDebugNameW; + public unsafe ushort* pCommandListDebugNameW; /// public unsafe byte* pCommandQueueDebugNameA; /// - public unsafe char* pCommandQueueDebugNameW; + public unsafe ushort* pCommandQueueDebugNameW; /// public ID3D12GraphicsCommandList pCommandList; @@ -10824,7 +11054,7 @@ public partial struct DredAllocationNode public unsafe byte* ObjectNameA; /// - public unsafe char* ObjectNameW; + public unsafe ushort* ObjectNameW; /// public DredAllocationType AllocationType; @@ -10841,7 +11071,7 @@ public partial struct DredAllocationNode1 public unsafe byte* ObjectNameA; /// - public unsafe char* ObjectNameW; + public unsafe ushort* ObjectNameW; /// public DredAllocationType AllocationType; @@ -11425,7 +11655,7 @@ public partial struct DispatchMeshArguments public partial struct SignatureParameterDescription { /// - public unsafe byte* SemanticName; + public unsafe sbyte* SemanticName; /// public uint SemanticIndex; @@ -11457,7 +11687,7 @@ public partial struct SignatureParameterDescription public partial struct ShaderBufferDescription { /// - public unsafe byte* Name; + public unsafe sbyte* Name; /// public Graphics.Direct3D.CBufferType Type; @@ -11477,7 +11707,7 @@ public partial struct ShaderBufferDescription public partial struct ShaderVariableDescription { /// - public unsafe byte* Name; + public unsafe sbyte* Name; /// public uint StartOffset; @@ -11530,7 +11760,7 @@ public partial struct ShaderTypeDescription public uint Offset; /// - public unsafe byte* Name; + public unsafe sbyte* Name; } /// @@ -11541,7 +11771,7 @@ public partial struct ShaderDescription public uint Version; /// - public unsafe byte* Creator; + public unsafe sbyte* Creator; /// public uint Flags; @@ -11657,7 +11887,7 @@ public partial struct ShaderDescription public partial struct ShaderInputBindDescription { /// - public unsafe byte* Name; + public unsafe sbyte* Name; /// public Graphics.Direct3D.ShaderInputType Type; @@ -11692,7 +11922,7 @@ public partial struct ShaderInputBindDescription public partial struct LibraryDescription { /// - public unsafe byte* Creator; + public unsafe sbyte* Creator; /// public uint Flags; @@ -11709,7 +11939,7 @@ public partial struct FunctionDescription public uint Version; /// - public unsafe byte* Creator; + public unsafe sbyte* Creator; /// public uint Flags; @@ -11790,7 +12020,7 @@ public partial struct FunctionDescription public ulong RequiredFeatureFlags; /// - public unsafe byte* Name; + public unsafe sbyte* Name; /// public int FunctionParameterCount; @@ -11810,10 +12040,10 @@ public partial struct FunctionDescription public partial struct ParameterDescription { /// - public unsafe byte* Name; + public unsafe sbyte* Name; /// - public unsafe byte* SemanticName; + public unsafe sbyte* SemanticName; /// public Graphics.Direct3D.ShaderVariableType Type; @@ -11937,9 +12167,9 @@ public unsafe partial struct ID3D12Object /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(6)] - public HResult SetName(char** Name) + public HResult SetName(ushort* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12Object*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12Object*)Unsafe.AsPointer(ref this), Name); } } @@ -12032,9 +12262,9 @@ public unsafe partial struct ID3D12DeviceChild /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(6)] - public HResult SetName(char** Name) + public HResult SetName(ushort* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12DeviceChild*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12DeviceChild*)Unsafe.AsPointer(ref this), Name); } /// @@ -12143,9 +12373,9 @@ public unsafe partial struct ID3D12RootSignature /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(7)] - public HResult SetName(char** Name) + public HResult SetName(ushort* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12RootSignature*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12RootSignature*)Unsafe.AsPointer(ref this), Name); } } @@ -12396,9 +12626,9 @@ public unsafe partial struct ID3D12Pageable /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(7)] - public HResult SetName(char** Name) + public HResult SetName(ushort* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12Pageable*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12Pageable*)Unsafe.AsPointer(ref this), Name); } } @@ -12499,9 +12729,9 @@ public unsafe partial struct ID3D12Heap /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(7)] - public HResult SetName(char** Name) + public HResult SetName(ushort* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12Heap*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12Heap*)Unsafe.AsPointer(ref this), Name); } /// @@ -12610,9 +12840,9 @@ public unsafe partial struct ID3D12Resource /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(7)] - public HResult SetName(char** Name) + public HResult SetName(ushort* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12Resource*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12Resource*)Unsafe.AsPointer(ref this), Name); } /// @@ -12769,9 +12999,9 @@ public unsafe partial struct ID3D12CommandAllocator /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(7)] - public HResult SetName(char** Name) + public HResult SetName(ushort* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12CommandAllocator*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12CommandAllocator*)Unsafe.AsPointer(ref this), Name); } /// @@ -12880,9 +13110,9 @@ public unsafe partial struct ID3D12Fence /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(7)] - public HResult SetName(char** Name) + public HResult SetName(ushort* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12Fence*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12Fence*)Unsafe.AsPointer(ref this), Name); } /// @@ -13031,9 +13261,9 @@ public unsafe partial struct ID3D12Fence1 /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(10)] - public HResult SetName(char** Name) + public HResult SetName(ushort* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D12Fence1*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D12Fence1*)Unsafe.AsPointer(ref this), Name); } /// @@ -13142,9 +13372,9 @@ public unsafe partial struct ID3D12PipelineState /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(7)] - public HResult SetName(char** Name) + public HResult SetName(ushort* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12PipelineState*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12PipelineState*)Unsafe.AsPointer(ref this), Name); } /// @@ -13253,9 +13483,9 @@ public unsafe partial struct ID3D12DescriptorHeap /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(7)] - public HResult SetName(char** Name) + public HResult SetName(ushort* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12DescriptorHeap*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12DescriptorHeap*)Unsafe.AsPointer(ref this), Name); } /// @@ -13380,9 +13610,9 @@ public unsafe partial struct ID3D12QueryHeap /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(7)] - public HResult SetName(char** Name) + public HResult SetName(ushort* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12QueryHeap*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12QueryHeap*)Unsafe.AsPointer(ref this), Name); } } @@ -13483,9 +13713,9 @@ public unsafe partial struct ID3D12CommandSignature /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(7)] - public HResult SetName(char** Name) + public HResult SetName(ushort* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12CommandSignature*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12CommandSignature*)Unsafe.AsPointer(ref this), Name); } } @@ -13586,9 +13816,9 @@ public unsafe partial struct ID3D12CommandList /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(7)] - public HResult SetName(char** Name) + public HResult SetName(ushort* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12CommandList*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12CommandList*)Unsafe.AsPointer(ref this), Name); } /// @@ -13705,9 +13935,9 @@ public unsafe partial struct ID3D12GraphicsCommandList /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(8)] - public HResult SetName(char** Name) + public HResult SetName(ushort* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), Name); } /// @@ -14632,9 +14862,9 @@ public unsafe partial struct ID3D12GraphicsCommandList1 /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(59)] - public HResult SetName(char** Name) + public HResult SetName(ushort* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[59]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[59]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), Name); } /// @@ -15247,9 +15477,9 @@ public unsafe partial struct ID3D12GraphicsCommandList2 /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(65)] - public HResult SetName(char** Name) + public HResult SetName(ushort* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[65]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[65]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), Name); } /// @@ -15358,9 +15588,9 @@ public unsafe partial struct ID3D12CommandQueue /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(7)] - public HResult SetName(char** Name) + public HResult SetName(ushort* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12CommandQueue*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12CommandQueue*)Unsafe.AsPointer(ref this), Name); } /// @@ -15541,9 +15771,9 @@ public unsafe partial struct ID3D12Device /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(6)] - public HResult SetName(char** Name) + public HResult SetName(ushort* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12Device*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12Device*)Unsafe.AsPointer(ref this), Name); } /// @@ -15741,9 +15971,9 @@ public unsafe partial struct ID3D12Device /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(31)] - public HResult CreateSharedHandle(ID3D12DeviceChild* pObject, Security.SECURITY_ATTRIBUTES* pAttributes, uint Access, char** Name, IntPtr* pHandle) + public HResult CreateSharedHandle(ID3D12DeviceChild* pObject, Security.SECURITY_ATTRIBUTES* pAttributes, uint Access, ushort* Name, IntPtr* pHandle) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((ID3D12Device*)Unsafe.AsPointer(ref this), pObject, pAttributes, Access, Name, pHandle); + return ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((ID3D12Device*)Unsafe.AsPointer(ref this), pObject, pAttributes, Access, Name, pHandle); } /// @@ -15757,9 +15987,9 @@ public unsafe partial struct ID3D12Device /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(33)] - public HResult OpenSharedHandleByName(char** Name, uint Access, IntPtr* pNTHandle) + public HResult OpenSharedHandleByName(ushort* Name, uint Access, IntPtr* pNTHandle) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((ID3D12Device*)Unsafe.AsPointer(ref this), Name, Access, pNTHandle); + return ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((ID3D12Device*)Unsafe.AsPointer(ref this), Name, Access, pNTHandle); } /// @@ -15940,33 +16170,33 @@ public unsafe partial struct ID3D12PipelineLibrary /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(7)] - public HResult SetName(char** Name) + public HResult SetName(ushort* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12PipelineLibrary*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12PipelineLibrary*)Unsafe.AsPointer(ref this), Name); } /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(8)] - public HResult StorePipeline(char** pName, ID3D12PipelineState* pPipeline) + public HResult StorePipeline(ushort* pName, ID3D12PipelineState* pPipeline) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12PipelineLibrary*)Unsafe.AsPointer(ref this), pName, pPipeline); + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12PipelineLibrary*)Unsafe.AsPointer(ref this), pName, pPipeline); } /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(9)] - public HResult LoadGraphicsPipeline(char** pName, GraphicsPipelineStateDescription* pDesc, Guid* riid, void** ppPipelineState) + public HResult LoadGraphicsPipeline(ushort* pName, GraphicsPipelineStateDescription* pDesc, Guid* riid, void** ppPipelineState) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D12PipelineLibrary*)Unsafe.AsPointer(ref this), pName, pDesc, riid, ppPipelineState); + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D12PipelineLibrary*)Unsafe.AsPointer(ref this), pName, pDesc, riid, ppPipelineState); } /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(10)] - public HResult LoadComputePipeline(char** pName, ComputePipelineStateDescription* pDesc, Guid* riid, void** ppPipelineState) + public HResult LoadComputePipeline(ushort* pName, ComputePipelineStateDescription* pDesc, Guid* riid, void** ppPipelineState) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D12PipelineLibrary*)Unsafe.AsPointer(ref this), pName, pDesc, riid, ppPipelineState); + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D12PipelineLibrary*)Unsafe.AsPointer(ref this), pName, pDesc, riid, ppPipelineState); } /// @@ -16051,25 +16281,25 @@ public unsafe partial struct ID3D12PipelineLibrary1 /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(3)] - public HResult StorePipeline(char** pName, ID3D12PipelineState* pPipeline) + public HResult StorePipeline(ushort* pName, ID3D12PipelineState* pPipeline) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12PipelineLibrary1*)Unsafe.AsPointer(ref this), pName, pPipeline); + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12PipelineLibrary1*)Unsafe.AsPointer(ref this), pName, pPipeline); } /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(4)] - public HResult LoadGraphicsPipeline(char** pName, GraphicsPipelineStateDescription* pDesc, Guid* riid, void** ppPipelineState) + public HResult LoadGraphicsPipeline(ushort* pName, GraphicsPipelineStateDescription* pDesc, Guid* riid, void** ppPipelineState) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12PipelineLibrary1*)Unsafe.AsPointer(ref this), pName, pDesc, riid, ppPipelineState); + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12PipelineLibrary1*)Unsafe.AsPointer(ref this), pName, pDesc, riid, ppPipelineState); } /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(5)] - public HResult LoadComputePipeline(char** pName, ComputePipelineStateDescription* pDesc, Guid* riid, void** ppPipelineState) + public HResult LoadComputePipeline(ushort* pName, ComputePipelineStateDescription* pDesc, Guid* riid, void** ppPipelineState) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12PipelineLibrary1*)Unsafe.AsPointer(ref this), pName, pDesc, riid, ppPipelineState); + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12PipelineLibrary1*)Unsafe.AsPointer(ref this), pName, pDesc, riid, ppPipelineState); } /// @@ -16123,17 +16353,17 @@ public unsafe partial struct ID3D12PipelineLibrary1 /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(12)] - public HResult SetName(char** Name) + public HResult SetName(ushort* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D12PipelineLibrary1*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D12PipelineLibrary1*)Unsafe.AsPointer(ref this), Name); } /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(13)] - public HResult LoadPipeline(char** pName, PipelineStateStreamDescription* pDesc, Guid* riid, void** ppPipelineState) + public HResult LoadPipeline(ushort* pName, PipelineStateStreamDescription* pDesc, Guid* riid, void** ppPipelineState) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D12PipelineLibrary1*)Unsafe.AsPointer(ref this), pName, pDesc, riid, ppPipelineState); + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D12PipelineLibrary1*)Unsafe.AsPointer(ref this), pName, pDesc, riid, ppPipelineState); } } @@ -16394,9 +16624,9 @@ public unsafe partial struct ID3D12Device1 /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(27)] - public HResult CreateSharedHandle(ID3D12DeviceChild* pObject, Security.SECURITY_ATTRIBUTES* pAttributes, uint Access, char** Name, IntPtr* pHandle) + public HResult CreateSharedHandle(ID3D12DeviceChild* pObject, Security.SECURITY_ATTRIBUTES* pAttributes, uint Access, ushort* Name, IntPtr* pHandle) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((ID3D12Device1*)Unsafe.AsPointer(ref this), pObject, pAttributes, Access, Name, pHandle); + return ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((ID3D12Device1*)Unsafe.AsPointer(ref this), pObject, pAttributes, Access, Name, pHandle); } /// @@ -16410,9 +16640,9 @@ public unsafe partial struct ID3D12Device1 /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(29)] - public HResult OpenSharedHandleByName(char** Name, uint Access, IntPtr* pNTHandle) + public HResult OpenSharedHandleByName(ushort* Name, uint Access, IntPtr* pNTHandle) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((ID3D12Device1*)Unsafe.AsPointer(ref this), Name, Access, pNTHandle); + return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((ID3D12Device1*)Unsafe.AsPointer(ref this), Name, Access, pNTHandle); } /// @@ -16522,9 +16752,9 @@ public unsafe partial struct ID3D12Device1 /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(43)] - public HResult SetName(char** Name) + public HResult SetName(ushort* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[43]))((ID3D12Device1*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[43]))((ID3D12Device1*)Unsafe.AsPointer(ref this), Name); } /// @@ -16833,9 +17063,9 @@ public unsafe partial struct ID3D12Device2 /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(30)] - public HResult CreateSharedHandle(ID3D12DeviceChild* pObject, Security.SECURITY_ATTRIBUTES* pAttributes, uint Access, char** Name, IntPtr* pHandle) + public HResult CreateSharedHandle(ID3D12DeviceChild* pObject, Security.SECURITY_ATTRIBUTES* pAttributes, uint Access, ushort* Name, IntPtr* pHandle) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((ID3D12Device2*)Unsafe.AsPointer(ref this), pObject, pAttributes, Access, Name, pHandle); + return ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((ID3D12Device2*)Unsafe.AsPointer(ref this), pObject, pAttributes, Access, Name, pHandle); } /// @@ -16849,9 +17079,9 @@ public unsafe partial struct ID3D12Device2 /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(32)] - public HResult OpenSharedHandleByName(char** Name, uint Access, IntPtr* pNTHandle) + public HResult OpenSharedHandleByName(ushort* Name, uint Access, IntPtr* pNTHandle) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((ID3D12Device2*)Unsafe.AsPointer(ref this), Name, Access, pNTHandle); + return ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((ID3D12Device2*)Unsafe.AsPointer(ref this), Name, Access, pNTHandle); } /// @@ -16961,9 +17191,9 @@ public unsafe partial struct ID3D12Device2 /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(46)] - public HResult SetName(char** Name) + public HResult SetName(ushort* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[46]))((ID3D12Device2*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[46]))((ID3D12Device2*)Unsafe.AsPointer(ref this), Name); } /// @@ -17264,9 +17494,9 @@ public unsafe partial struct ID3D12Device3 /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(31)] - public HResult CreateSharedHandle(ID3D12DeviceChild* pObject, Security.SECURITY_ATTRIBUTES* pAttributes, uint Access, char** Name, IntPtr* pHandle) + public HResult CreateSharedHandle(ID3D12DeviceChild* pObject, Security.SECURITY_ATTRIBUTES* pAttributes, uint Access, ushort* Name, IntPtr* pHandle) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((ID3D12Device3*)Unsafe.AsPointer(ref this), pObject, pAttributes, Access, Name, pHandle); + return ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((ID3D12Device3*)Unsafe.AsPointer(ref this), pObject, pAttributes, Access, Name, pHandle); } /// @@ -17280,9 +17510,9 @@ public unsafe partial struct ID3D12Device3 /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(33)] - public HResult OpenSharedHandleByName(char** Name, uint Access, IntPtr* pNTHandle) + public HResult OpenSharedHandleByName(ushort* Name, uint Access, IntPtr* pNTHandle) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((ID3D12Device3*)Unsafe.AsPointer(ref this), Name, Access, pNTHandle); + return ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((ID3D12Device3*)Unsafe.AsPointer(ref this), Name, Access, pNTHandle); } /// @@ -17392,9 +17622,9 @@ public unsafe partial struct ID3D12Device3 /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(47)] - public HResult SetName(char** Name) + public HResult SetName(ushort* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[47]))((ID3D12Device3*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[47]))((ID3D12Device3*)Unsafe.AsPointer(ref this), Name); } /// @@ -17519,9 +17749,9 @@ public unsafe partial struct ID3D12ProtectedSession /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(7)] - public HResult SetName(char** Name) + public HResult SetName(ushort* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12ProtectedSession*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12ProtectedSession*)Unsafe.AsPointer(ref this), Name); } /// @@ -17654,9 +17884,9 @@ public unsafe partial struct ID3D12ProtectedResourceSession /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(9)] - public HResult SetName(char** Name) + public HResult SetName(ushort* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D12ProtectedResourceSession*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D12ProtectedResourceSession*)Unsafe.AsPointer(ref this), Name); } /// @@ -17981,9 +18211,9 @@ public unsafe partial struct ID3D12Device4 /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(34)] - public HResult CreateSharedHandle(ID3D12DeviceChild* pObject, Security.SECURITY_ATTRIBUTES* pAttributes, uint Access, char** Name, IntPtr* pHandle) + public HResult CreateSharedHandle(ID3D12DeviceChild* pObject, Security.SECURITY_ATTRIBUTES* pAttributes, uint Access, ushort* Name, IntPtr* pHandle) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pObject, pAttributes, Access, Name, pHandle); + return ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((ID3D12Device4*)Unsafe.AsPointer(ref this), pObject, pAttributes, Access, Name, pHandle); } /// @@ -17997,9 +18227,9 @@ public unsafe partial struct ID3D12Device4 /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(36)] - public HResult OpenSharedHandleByName(char** Name, uint Access, IntPtr* pNTHandle) + public HResult OpenSharedHandleByName(ushort* Name, uint Access, IntPtr* pNTHandle) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((ID3D12Device4*)Unsafe.AsPointer(ref this), Name, Access, pNTHandle); + return ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((ID3D12Device4*)Unsafe.AsPointer(ref this), Name, Access, pNTHandle); } /// @@ -18109,9 +18339,9 @@ public unsafe partial struct ID3D12Device4 /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(50)] - public HResult SetName(char** Name) + public HResult SetName(ushort* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[50]))((ID3D12Device4*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[50]))((ID3D12Device4*)Unsafe.AsPointer(ref this), Name); } /// @@ -18426,9 +18656,9 @@ public unsafe partial struct ID3D12LifetimeTracker /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(7)] - public HResult SetName(char** Name) + public HResult SetName(ushort* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12LifetimeTracker*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12LifetimeTracker*)Unsafe.AsPointer(ref this), Name); } /// @@ -18537,9 +18767,9 @@ public unsafe partial struct ID3D12StateObject /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(7)] - public HResult SetName(char** Name) + public HResult SetName(ushort* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12StateObject*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12StateObject*)Unsafe.AsPointer(ref this), Name); } } @@ -18608,17 +18838,17 @@ public unsafe partial struct ID3D12StateObjectProperties /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(3)] - public void* GetShaderIdentifier(char** pExportName) + public void* GetShaderIdentifier(ushort* pExportName) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12StateObjectProperties*)Unsafe.AsPointer(ref this), pExportName); + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12StateObjectProperties*)Unsafe.AsPointer(ref this), pExportName); } /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(4)] - public ulong GetShaderStackSize(char** pExportName) + public ulong GetShaderStackSize(ushort* pExportName) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12StateObjectProperties*)Unsafe.AsPointer(ref this), pExportName); + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12StateObjectProperties*)Unsafe.AsPointer(ref this), pExportName); } /// @@ -18999,9 +19229,9 @@ public unsafe partial struct ID3D12Device5 /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(40)] - public HResult CreateSharedHandle(ID3D12DeviceChild* pObject, Security.SECURITY_ATTRIBUTES* pAttributes, uint Access, char** Name, IntPtr* pHandle) + public HResult CreateSharedHandle(ID3D12DeviceChild* pObject, Security.SECURITY_ATTRIBUTES* pAttributes, uint Access, ushort* Name, IntPtr* pHandle) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[40]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pObject, pAttributes, Access, Name, pHandle); + return ((delegate* unmanaged[Stdcall])(lpVtbl[40]))((ID3D12Device5*)Unsafe.AsPointer(ref this), pObject, pAttributes, Access, Name, pHandle); } /// @@ -19015,9 +19245,9 @@ public unsafe partial struct ID3D12Device5 /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(42)] - public HResult OpenSharedHandleByName(char** Name, uint Access, IntPtr* pNTHandle) + public HResult OpenSharedHandleByName(ushort* Name, uint Access, IntPtr* pNTHandle) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[42]))((ID3D12Device5*)Unsafe.AsPointer(ref this), Name, Access, pNTHandle); + return ((delegate* unmanaged[Stdcall])(lpVtbl[42]))((ID3D12Device5*)Unsafe.AsPointer(ref this), Name, Access, pNTHandle); } /// @@ -19127,9 +19357,9 @@ public unsafe partial struct ID3D12Device5 /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(56)] - public HResult SetName(char** Name) + public HResult SetName(ushort* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[56]))((ID3D12Device5*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[56]))((ID3D12Device5*)Unsafe.AsPointer(ref this), Name); } /// @@ -20089,9 +20319,9 @@ public unsafe partial struct ID3D12Device6 /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(48)] - public HResult CreateSharedHandle(ID3D12DeviceChild* pObject, Security.SECURITY_ATTRIBUTES* pAttributes, uint Access, char** Name, IntPtr* pHandle) + public HResult CreateSharedHandle(ID3D12DeviceChild* pObject, Security.SECURITY_ATTRIBUTES* pAttributes, uint Access, ushort* Name, IntPtr* pHandle) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[48]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pObject, pAttributes, Access, Name, pHandle); + return ((delegate* unmanaged[Stdcall])(lpVtbl[48]))((ID3D12Device6*)Unsafe.AsPointer(ref this), pObject, pAttributes, Access, Name, pHandle); } /// @@ -20105,9 +20335,9 @@ public unsafe partial struct ID3D12Device6 /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(50)] - public HResult OpenSharedHandleByName(char** Name, uint Access, IntPtr* pNTHandle) + public HResult OpenSharedHandleByName(ushort* Name, uint Access, IntPtr* pNTHandle) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[50]))((ID3D12Device6*)Unsafe.AsPointer(ref this), Name, Access, pNTHandle); + return ((delegate* unmanaged[Stdcall])(lpVtbl[50]))((ID3D12Device6*)Unsafe.AsPointer(ref this), Name, Access, pNTHandle); } /// @@ -20217,9 +20447,9 @@ public unsafe partial struct ID3D12Device6 /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(64)] - public HResult SetName(char** Name) + public HResult SetName(ushort* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[64]))((ID3D12Device6*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[64]))((ID3D12Device6*)Unsafe.AsPointer(ref this), Name); } /// @@ -20352,9 +20582,9 @@ public unsafe partial struct ID3D12ProtectedResourceSession1 /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(10)] - public HResult SetName(char** Name) + public HResult SetName(ushort* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D12ProtectedResourceSession1*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D12ProtectedResourceSession1*)Unsafe.AsPointer(ref this), Name); } /// @@ -20799,9 +21029,9 @@ public unsafe partial struct ID3D12Device7 /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(49)] - public HResult CreateSharedHandle(ID3D12DeviceChild* pObject, Security.SECURITY_ATTRIBUTES* pAttributes, uint Access, char** Name, IntPtr* pHandle) + public HResult CreateSharedHandle(ID3D12DeviceChild* pObject, Security.SECURITY_ATTRIBUTES* pAttributes, uint Access, ushort* Name, IntPtr* pHandle) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[49]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pObject, pAttributes, Access, Name, pHandle); + return ((delegate* unmanaged[Stdcall])(lpVtbl[49]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pObject, pAttributes, Access, Name, pHandle); } /// @@ -20815,9 +21045,9 @@ public unsafe partial struct ID3D12Device7 /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(51)] - public HResult OpenSharedHandleByName(char** Name, uint Access, IntPtr* pNTHandle) + public HResult OpenSharedHandleByName(ushort* Name, uint Access, IntPtr* pNTHandle) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[51]))((ID3D12Device7*)Unsafe.AsPointer(ref this), Name, Access, pNTHandle); + return ((delegate* unmanaged[Stdcall])(lpVtbl[51]))((ID3D12Device7*)Unsafe.AsPointer(ref this), Name, Access, pNTHandle); } /// @@ -20927,9 +21157,9 @@ public unsafe partial struct ID3D12Device7 /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(65)] - public HResult SetName(char** Name) + public HResult SetName(ushort* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[65]))((ID3D12Device7*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[65]))((ID3D12Device7*)Unsafe.AsPointer(ref this), Name); } /// @@ -21398,9 +21628,9 @@ public unsafe partial struct ID3D12Device8 /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(51)] - public HResult CreateSharedHandle(ID3D12DeviceChild* pObject, Security.SECURITY_ATTRIBUTES* pAttributes, uint Access, char** Name, IntPtr* pHandle) + public HResult CreateSharedHandle(ID3D12DeviceChild* pObject, Security.SECURITY_ATTRIBUTES* pAttributes, uint Access, ushort* Name, IntPtr* pHandle) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[51]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pObject, pAttributes, Access, Name, pHandle); + return ((delegate* unmanaged[Stdcall])(lpVtbl[51]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pObject, pAttributes, Access, Name, pHandle); } /// @@ -21414,9 +21644,9 @@ public unsafe partial struct ID3D12Device8 /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(53)] - public HResult OpenSharedHandleByName(char** Name, uint Access, IntPtr* pNTHandle) + public HResult OpenSharedHandleByName(ushort* Name, uint Access, IntPtr* pNTHandle) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[53]))((ID3D12Device8*)Unsafe.AsPointer(ref this), Name, Access, pNTHandle); + return ((delegate* unmanaged[Stdcall])(lpVtbl[53]))((ID3D12Device8*)Unsafe.AsPointer(ref this), Name, Access, pNTHandle); } /// @@ -21526,9 +21756,9 @@ public unsafe partial struct ID3D12Device8 /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(67)] - public HResult SetName(char** Name) + public HResult SetName(ushort* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[67]))((ID3D12Device8*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[67]))((ID3D12Device8*)Unsafe.AsPointer(ref this), Name); } /// @@ -21725,9 +21955,9 @@ public unsafe partial struct ID3D12Resource1 /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(14)] - public HResult SetName(char** Name) + public HResult SetName(ushort* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((ID3D12Resource1*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((ID3D12Resource1*)Unsafe.AsPointer(ref this), Name); } /// @@ -21900,9 +22130,9 @@ public unsafe partial struct ID3D12Resource2 /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(15)] - public HResult SetName(char** Name) + public HResult SetName(ushort* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((ID3D12Resource2*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((ID3D12Resource2*)Unsafe.AsPointer(ref this), Name); } /// @@ -22019,9 +22249,9 @@ public unsafe partial struct ID3D12Heap1 /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(8)] - public HResult SetName(char** Name) + public HResult SetName(ushort* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12Heap1*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12Heap1*)Unsafe.AsPointer(ref this), Name); } /// @@ -22602,9 +22832,9 @@ public unsafe partial struct ID3D12GraphicsCommandList3 /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(66)] - public HResult SetName(char** Name) + public HResult SetName(ushort* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[66]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[66]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), Name); } /// @@ -22713,9 +22943,9 @@ public unsafe partial struct ID3D12MetaCommand /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(7)] - public HResult SetName(char** Name) + public HResult SetName(ushort* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12MetaCommand*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12MetaCommand*)Unsafe.AsPointer(ref this), Name); } /// @@ -23304,9 +23534,9 @@ public unsafe partial struct ID3D12GraphicsCommandList4 /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(67)] - public HResult SetName(char** Name) + public HResult SetName(ushort* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[67]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[67]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), Name); } /// @@ -23479,9 +23709,9 @@ public unsafe partial struct ID3D12ShaderCacheSession /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(7)] - public HResult SetName(char** Name) + public HResult SetName(ushort* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12ShaderCacheSession*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12ShaderCacheSession*)Unsafe.AsPointer(ref this), Name); } /// @@ -24006,9 +24236,9 @@ public unsafe partial struct ID3D12Device9 /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(56)] - public HResult CreateSharedHandle(ID3D12DeviceChild* pObject, Security.SECURITY_ATTRIBUTES* pAttributes, uint Access, char** Name, IntPtr* pHandle) + public HResult CreateSharedHandle(ID3D12DeviceChild* pObject, Security.SECURITY_ATTRIBUTES* pAttributes, uint Access, ushort* Name, IntPtr* pHandle) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[56]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pObject, pAttributes, Access, Name, pHandle); + return ((delegate* unmanaged[Stdcall])(lpVtbl[56]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pObject, pAttributes, Access, Name, pHandle); } /// @@ -24022,9 +24252,9 @@ public unsafe partial struct ID3D12Device9 /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(58)] - public HResult OpenSharedHandleByName(char** Name, uint Access, IntPtr* pNTHandle) + public HResult OpenSharedHandleByName(ushort* Name, uint Access, IntPtr* pNTHandle) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[58]))((ID3D12Device9*)Unsafe.AsPointer(ref this), Name, Access, pNTHandle); + return ((delegate* unmanaged[Stdcall])(lpVtbl[58]))((ID3D12Device9*)Unsafe.AsPointer(ref this), Name, Access, pNTHandle); } /// @@ -24134,9 +24364,9 @@ public unsafe partial struct ID3D12Device9 /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(72)] - public HResult SetName(char** Name) + public HResult SetName(ushort* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[72]))((ID3D12Device9*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[72]))((ID3D12Device9*)Unsafe.AsPointer(ref this), Name); } /// @@ -25766,17 +25996,17 @@ public unsafe partial struct ID3D12InfoQueue /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(28)] - public HResult AddMessage(MessageCategory Category, MessageSeverity Severity, MessageId ID, byte** pDescription) + public HResult AddMessage(MessageCategory Category, MessageSeverity Severity, MessageId ID, sbyte* pDescription) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this), Category, Severity, ID, pDescription); + return ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this), Category, Severity, ID, pDescription); } /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(29)] - public HResult AddApplicationMessage(MessageSeverity Severity, byte** pDescription) + public HResult AddApplicationMessage(MessageSeverity Severity, sbyte* pDescription) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this), Severity, pDescription); + return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this), Severity, pDescription); } /// @@ -26109,17 +26339,17 @@ public unsafe partial struct ID3D12InfoQueue1 /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(28)] - public HResult AddMessage(MessageCategory Category, MessageSeverity Severity, MessageId ID, byte** pDescription) + public HResult AddMessage(MessageCategory Category, MessageSeverity Severity, MessageId ID, sbyte* pDescription) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this), Category, Severity, ID, pDescription); + return ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this), Category, Severity, ID, pDescription); } /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(29)] - public HResult AddApplicationMessage(MessageSeverity Severity, byte** pDescription) + public HResult AddApplicationMessage(MessageSeverity Severity, sbyte* pDescription) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this), Severity, pDescription); + return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this), Severity, pDescription); } /// @@ -26268,9 +26498,9 @@ public unsafe partial struct ID3D12SDKConfiguration /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(3)] - public HResult SetSDKVersion(uint SDKVersion, byte** SDKPath) + public HResult SetSDKVersion(uint SDKVersion, sbyte* SDKPath) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12SDKConfiguration*)Unsafe.AsPointer(ref this), SDKVersion, SDKPath); + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12SDKConfiguration*)Unsafe.AsPointer(ref this), SDKVersion, SDKPath); } } @@ -26923,9 +27153,9 @@ public unsafe partial struct ID3D12GraphicsCommandList5 /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(76)] - public HResult SetName(char** Name) + public HResult SetName(ushort* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[76]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[76]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), Name); } /// @@ -27610,9 +27840,9 @@ public unsafe partial struct ID3D12GraphicsCommandList6 /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(78)] - public HResult SetName(char** Name) + public HResult SetName(ushort* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[78]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[78]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), Name); } /// @@ -27677,17 +27907,17 @@ public unsafe partial struct ID3D12ShaderReflectionType /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(2)] - public Graphics.Direct3D12.ID3D12ShaderReflectionType GetMemberTypeByName(byte** Name) + public Graphics.Direct3D12.ID3D12ShaderReflectionType GetMemberTypeByName(sbyte* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((ID3D12ShaderReflectionType*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((ID3D12ShaderReflectionType*)Unsafe.AsPointer(ref this), Name); } /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(3)] - public byte* GetMemberTypeName(uint Index) + public sbyte* GetMemberTypeName(uint Index) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12ShaderReflectionType*)Unsafe.AsPointer(ref this), Index); + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12ShaderReflectionType*)Unsafe.AsPointer(ref this), Index); } /// @@ -27867,9 +28097,9 @@ public unsafe partial struct ID3D12ShaderReflectionConstantBuffer /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(2)] - public Graphics.Direct3D12.ID3D12ShaderReflectionVariable GetVariableByName(byte** Name) + public Graphics.Direct3D12.ID3D12ShaderReflectionVariable GetVariableByName(sbyte* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((ID3D12ShaderReflectionConstantBuffer*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((ID3D12ShaderReflectionConstantBuffer*)Unsafe.AsPointer(ref this), Name); } } @@ -27954,9 +28184,9 @@ public unsafe partial struct ID3D12ShaderReflection /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(5)] - public Graphics.Direct3D12.ID3D12ShaderReflectionConstantBuffer GetConstantBufferByName(byte** Name) + public Graphics.Direct3D12.ID3D12ShaderReflectionConstantBuffer GetConstantBufferByName(sbyte* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12ShaderReflection*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12ShaderReflection*)Unsafe.AsPointer(ref this), Name); } /// @@ -27994,17 +28224,17 @@ public unsafe partial struct ID3D12ShaderReflection /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(10)] - public Graphics.Direct3D12.ID3D12ShaderReflectionVariable GetVariableByName(byte** Name) + public Graphics.Direct3D12.ID3D12ShaderReflectionVariable GetVariableByName(sbyte* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D12ShaderReflection*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D12ShaderReflection*)Unsafe.AsPointer(ref this), Name); } /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(11)] - public HResult GetResourceBindingDescByName(byte** Name, ShaderInputBindDescription* pDesc) + public HResult GetResourceBindingDescByName(sbyte* Name, ShaderInputBindDescription* pDesc) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D12ShaderReflection*)Unsafe.AsPointer(ref this), Name, pDesc); + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D12ShaderReflection*)Unsafe.AsPointer(ref this), Name, pDesc); } /// @@ -28220,9 +28450,9 @@ public unsafe partial struct ID3D12FunctionReflection /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(2)] - public Graphics.Direct3D12.ID3D12ShaderReflectionConstantBuffer GetConstantBufferByName(byte** Name) + public Graphics.Direct3D12.ID3D12ShaderReflectionConstantBuffer GetConstantBufferByName(sbyte* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((ID3D12FunctionReflection*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((ID3D12FunctionReflection*)Unsafe.AsPointer(ref this), Name); } /// @@ -28236,17 +28466,17 @@ public unsafe partial struct ID3D12FunctionReflection /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(4)] - public Graphics.Direct3D12.ID3D12ShaderReflectionVariable GetVariableByName(byte** Name) + public Graphics.Direct3D12.ID3D12ShaderReflectionVariable GetVariableByName(sbyte* Name) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12FunctionReflection*)Unsafe.AsPointer(ref this), Name); + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12FunctionReflection*)Unsafe.AsPointer(ref this), Name); } /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(5)] - public HResult GetResourceBindingDescByName(byte** Name, ShaderInputBindDescription* pDesc) + public HResult GetResourceBindingDescByName(sbyte* Name, ShaderInputBindDescription* pDesc) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12FunctionReflection*)Unsafe.AsPointer(ref this), Name, pDesc); + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12FunctionReflection*)Unsafe.AsPointer(ref this), Name, pDesc); } /// diff --git a/src/Vortice.Win32/Generated/Graphics/Dxgi.cs b/src/Vortice.Win32/Generated/Graphics/Dxgi.cs index 314af5c..03e2d3d 100644 --- a/src/Vortice.Win32/Generated/Graphics/Dxgi.cs +++ b/src/Vortice.Win32/Generated/Graphics/Dxgi.cs @@ -24,10 +24,102 @@ public static partial class Apis public const uint DXGI_SHARED_RESOURCE_READ = 2147483648; public const uint DXGI_SHARED_RESOURCE_WRITE = 1; public const uint DXGI_DEBUG_BINARY_VERSION = 1; - public static readonly Guid DXGI_DEBUG_ALL = new Guid(0xe48ae283, 0xda80, 0x490b, 0x87, 0xe6, 0x43, 0xe9, 0xa9, 0xcf, 0xda, 0x08); - public static readonly Guid DXGI_DEBUG_DX = new Guid(0x35cdd7fc, 0x13b2, 0x421d, 0xa5, 0xd7, 0x7e, 0x44, 0x51, 0x28, 0x7d, 0x64); - public static readonly Guid DXGI_DEBUG_DXGI = new Guid(0x25cddaa4, 0xb1c6, 0x47e1, 0xac, 0x3e, 0x98, 0x87, 0x5b, 0x5a, 0x2e, 0x2a); - public static readonly Guid DXGI_DEBUG_APP = new Guid(0x06cd6e01, 0x4219, 0x4ebd, 0x87, 0x09, 0x27, 0xed, 0x23, 0x36, 0x0c, 0x62); + public static ref readonly Guid DXGI_DEBUG_ALL + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x83, 0xE2, 0x8A, 0xE4, + 0x80, 0xDA, + 0x0B, 0x49, + 0x87, + 0xE6, + 0x43, + 0xE9, + 0xA9, + 0xCF, + 0xDA, + 0x08 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid DXGI_DEBUG_DX + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xFC, 0xD7, 0xCD, 0x35, + 0xB2, 0x13, + 0x1D, 0x42, + 0xA5, + 0xD7, + 0x7E, + 0x44, + 0x51, + 0x28, + 0x7D, + 0x64 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid DXGI_DEBUG_DXGI + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xA4, 0xDA, 0xCD, 0x25, + 0xC6, 0xB1, + 0xE1, 0x47, + 0xAC, + 0x3E, + 0x98, + 0x87, + 0x5B, + 0x5A, + 0x2E, + 0x2A + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid DXGI_DEBUG_APP + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x01, 0x6E, 0xCD, 0x06, + 0x19, 0x42, + 0xBD, 0x4E, + 0x87, + 0x09, + 0x27, + 0xED, + 0x23, + 0x36, + 0x0C, + 0x62 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + public const uint DXGI_INFO_QUEUE_MESSAGE_ID_STRING_FROM_APPLICATION = 0; public const uint DXGI_INFO_QUEUE_DEFAULT_MESSAGE_COUNT_LIMIT = 1024; public const uint DXGI_CREATE_FACTORY_DEBUG = 1; @@ -4781,9 +4873,9 @@ public unsafe partial struct IDXGIResource1 /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(13)] - public HResult CreateSharedHandle(Security.SECURITY_ATTRIBUTES* pAttributes, uint dwAccess, char** lpName, IntPtr* pHandle) + public HResult CreateSharedHandle(Security.SECURITY_ATTRIBUTES* pAttributes, uint dwAccess, ushort* lpName, IntPtr* pHandle) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IDXGIResource1*)Unsafe.AsPointer(ref this), pAttributes, dwAccess, lpName, pHandle); + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IDXGIResource1*)Unsafe.AsPointer(ref this), pAttributes, dwAccess, lpName, pHandle); } } @@ -10819,17 +10911,17 @@ public unsafe partial struct IDXGIInfoQueue /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(30)] - public HResult AddMessage(Guid Producer, InfoQueueMessageCategory Category, InfoQueueMessageSeverity Severity, int ID, byte** pDescription) + public HResult AddMessage(Guid Producer, InfoQueueMessageCategory Category, InfoQueueMessageSeverity Severity, int ID, sbyte* pDescription) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((IDXGIInfoQueue*)Unsafe.AsPointer(ref this), Producer, Category, Severity, ID, pDescription); + return ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((IDXGIInfoQueue*)Unsafe.AsPointer(ref this), Producer, Category, Severity, ID, pDescription); } /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(31)] - public HResult AddApplicationMessage(InfoQueueMessageSeverity Severity, byte** pDescription) + public HResult AddApplicationMessage(InfoQueueMessageSeverity Severity, sbyte* pDescription) { - return ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((IDXGIInfoQueue*)Unsafe.AsPointer(ref this), Severity, pDescription); + return ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((IDXGIInfoQueue*)Unsafe.AsPointer(ref this), Severity, pDescription); } /// diff --git a/src/Vortice.Win32/Graphics/Dxc.Manual.cs b/src/Vortice.Win32/Graphics/Dxc.Manual.cs new file mode 100644 index 0000000..e395d26 --- /dev/null +++ b/src/Vortice.Win32/Graphics/Dxc.Manual.cs @@ -0,0 +1,26 @@ +// Copyright © Amer Koleci and Contributors. +// Licensed under the MIT License (MIT). See LICENSE in the repository root for more information. + +using System.Runtime.CompilerServices; + +namespace Win32.Graphics.Direct3D.Dxc; + +public static unsafe partial class Apis +{ + public static HResult DxcCreateInstance(in Guid rclsid, Guid* riid, void** ppv) + { + return DxcCreateInstance( + (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in rclsid)), + riid, + ppv); + } + + public static HResult DxcCreateInstance2(Com.IMalloc* pMalloc, in Guid rclsid, Guid* riid, void** ppv) + { + return DxcCreateInstance2( + pMalloc, + (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in rclsid)), + riid, + ppv); + } +} diff --git a/src/samples/01-ClearScreen/Program.cs b/src/samples/01-ClearScreen/Program.cs index ba28be1..44e76b4 100644 --- a/src/samples/01-ClearScreen/Program.cs +++ b/src/samples/01-ClearScreen/Program.cs @@ -12,6 +12,8 @@ using MessageId = Win32.Graphics.Direct3D11.MessageId; using InfoQueueFilter = Win32.Graphics.Direct3D11.InfoQueueFilter; using Win32.Graphics.Dxgi.Common; using System.Numerics; +using Win32.Graphics.Direct3D.Dxc; +using static Win32.Graphics.Direct3D.Dxc.Apis; namespace ClearScreen; @@ -37,8 +39,16 @@ public static unsafe class Program } #endif + private static void TestDxc() + { + using ComPtr compiler = default; + DxcCreateInstance(CLSID_DxcCompiler, __uuidof(), compiler.GetVoidAddressOf()); + } + public static void Main() { + TestDxc(); + using ComPtr factory = default; uint factoryFlags = 0;