Bindings: Separate DXC bindings.

src/Vortice.Win32.Dxc/Generated/Apis.Functions.cs

@@ -0,0 +1,19 @@
+// ------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+// ------------------------------------------------------------------------------
+
+namespace Win32.Graphics.Direct3D.Dxc;
+
+public static unsafe partial class Apis
+{
+	[DllImport("dxcompiler.dll", ExactSpelling = true)]
+	public static extern HResult DxcCreateInstance(Guid* rclsid, Guid* riid, void** ppv);
+
+	[DllImport("dxcompiler.dll", ExactSpelling = true)]
+	public static extern HResult DxcCreateInstance2(Com.IMalloc* pMalloc, Guid* rclsid, Guid* riid, void** ppv);
+}

src/Vortice.Win32.Dxc/Generated/Apis.cs

@@ -0,0 +1,320 @@
+// ------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+// ------------------------------------------------------------------------------
+
+namespace Win32.Graphics.Direct3D.Dxc;
+
+public static partial class Apis
+{
+	public const string DXC_ARG_DEBUG = "-Zi";
+
+	public const string DXC_ARG_SKIP_VALIDATION = "-Vd";
+
+	public const string DXC_ARG_SKIP_OPTIMIZATIONS = "-Od";
+
+	public const string DXC_ARG_PACK_MATRIX_ROW_MAJOR = "-Zpr";
+
+	public const string DXC_ARG_PACK_MATRIX_COLUMN_MAJOR = "-Zpc";
+
+	public const string DXC_ARG_AVOID_FLOW_CONTROL = "-Gfa";
+
+	public const string DXC_ARG_PREFER_FLOW_CONTROL = "-Gfp";
+
+	public const string DXC_ARG_ENABLE_STRICTNESS = "-Ges";
+
+	public const string DXC_ARG_ENABLE_BACKWARDS_COMPATIBILITY = "-Gec";
+
+	public const string DXC_ARG_IEEE_STRICTNESS = "-Gis";
+
+	public const string DXC_ARG_OPTIMIZATION_LEVEL0 = "-O0";
+
+	public const string DXC_ARG_OPTIMIZATION_LEVEL1 = "-O1";
+
+	public const string DXC_ARG_OPTIMIZATION_LEVEL2 = "-O2";
+
+	public const string DXC_ARG_OPTIMIZATION_LEVEL3 = "-O3";
+
+	public const string DXC_ARG_WARNINGS_ARE_ERRORS = "-WX";
+
+	public const string DXC_ARG_RESOURCES_MAY_ALIAS = "-res_may_alias";
+
+	public const string DXC_ARG_ALL_RESOURCES_BOUND = "-all_resources_bound";
+
+	public const string DXC_ARG_DEBUG_NAME_FOR_SOURCE = "-Zss";
+
+	public const string DXC_ARG_DEBUG_NAME_FOR_BINARY = "-Zsb";
+
+	public const string DXC_EXTRA_OUTPUT_NAME_STDOUT = "*stdout*";
+
+	public const string DXC_EXTRA_OUTPUT_NAME_STDERR = "*stderr*";
+
+	public static ref readonly Guid CLSID_DxcCompiler
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> 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<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_DxcLinker
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> 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<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_DxcDiaDataSource
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> 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<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_DxcCompilerArgs
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> 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<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_DxcLibrary
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> 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<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_DxcValidator
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> 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<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_DxcAssembler
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> 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<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_DxcContainerReflection
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> 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<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_DxcOptimizer
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> 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<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_DxcContainerBuilder
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> 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<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+	public static ref readonly Guid CLSID_DxcPdbUtils
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> 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<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+}
+

src/Vortice.Win32.Dxc/Generated/DxcArgPair.cs

@@ -0,0 +1,18 @@
+// ------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+// ------------------------------------------------------------------------------
+
+namespace Win32.Graphics.Direct3D.Dxc;
+
+/// <unmanaged>DxcArgPair</unmanaged>
+public partial struct DxcArgPair
+{
+	public unsafe ushort* pName;
+
+	public unsafe ushort* pValue;
+}

src/Vortice.Win32.Dxc/Generated/DxcBuffer.cs

@@ -0,0 +1,20 @@
+// ------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+// ------------------------------------------------------------------------------
+
+namespace Win32.Graphics.Direct3D.Dxc;
+
+/// <unmanaged>DxcBuffer</unmanaged>
+public partial struct DxcBuffer
+{
+	public unsafe void* Ptr;
+
+	public nuint Size;
+
+	public uint Encoding;
+}

src/Vortice.Win32.Dxc/Generated/DxcCp.cs

@@ -0,0 +1,21 @@
+// ------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+// ------------------------------------------------------------------------------
+
+namespace Win32.Graphics.Direct3D.Dxc;
+
+/// <unmanaged>DXC_CP</unmanaged>
+public enum DxcCp : uint
+{
+	/// <unmanaged>DXC_CP_ACP</unmanaged>
+	Acp = 0,
+	/// <unmanaged>DXC_CP_UTF16</unmanaged>
+	Utf16 = 1200,
+	/// <unmanaged>DXC_CP_UTF8</unmanaged>
+	Utf8 = 65001,
+}

src/Vortice.Win32.Dxc/Generated/DxcDefine.cs

@@ -0,0 +1,18 @@
+// ------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+// ------------------------------------------------------------------------------
+
+namespace Win32.Graphics.Direct3D.Dxc;
+
+/// <unmanaged>DxcDefine</unmanaged>
+public partial struct DxcDefine
+{
+	public unsafe ushort* Name;
+
+	public unsafe ushort* Value;
+}

src/Vortice.Win32.Dxc/Generated/DxcHashFlags.cs

@@ -0,0 +1,19 @@
+// ------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+// ------------------------------------------------------------------------------
+
+namespace Win32.Graphics.Direct3D.Dxc;
+
+/// <unmanaged>DXC_HASHFLAG</unmanaged>
+[Flags]
+public enum DxcHashFlags : uint
+{
+	None = 0,
+	/// <unmanaged>DXC_HASHFLAG_INCLUDES_SOURCE</unmanaged>
+	IncludesSource = 1,
+}

src/Vortice.Win32.Dxc/Generated/DxcOutKind.cs

@@ -0,0 +1,37 @@
+// ------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+// ------------------------------------------------------------------------------
+
+namespace Win32.Graphics.Direct3D.Dxc;
+
+/// <unmanaged>DXC_OUT_KIND</unmanaged>
+public enum DxcOutKind : int
+{
+	/// <unmanaged>DXC_OUT_NONE</unmanaged>
+	None = 0,
+	/// <unmanaged>DXC_OUT_OBJECT</unmanaged>
+	Object = 1,
+	/// <unmanaged>DXC_OUT_ERRORS</unmanaged>
+	Errors = 2,
+	/// <unmanaged>DXC_OUT_PDB</unmanaged>
+	Pdb = 3,
+	/// <unmanaged>DXC_OUT_SHADER_HASH</unmanaged>
+	ShaderHash = 4,
+	/// <unmanaged>DXC_OUT_DISASSEMBLY</unmanaged>
+	Disassembly = 5,
+	/// <unmanaged>DXC_OUT_HLSL</unmanaged>
+	Hlsl = 6,
+	/// <unmanaged>DXC_OUT_TEXT</unmanaged>
+	Text = 7,
+	/// <unmanaged>DXC_OUT_REFLECTION</unmanaged>
+	Reflection = 8,
+	/// <unmanaged>DXC_OUT_ROOT_SIGNATURE</unmanaged>
+	RootSignature = 9,
+	/// <unmanaged>DXC_OUT_EXTRA_OUTPUTS</unmanaged>
+	ExtraOutputs = 10,
+}

src/Vortice.Win32.Dxc/Generated/DxcShaderHash.cs

@@ -0,0 +1,18 @@
+// ------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+// ------------------------------------------------------------------------------
+
+namespace Win32.Graphics.Direct3D.Dxc;
+
+/// <unmanaged>DxcShaderHash</unmanaged>
+public partial struct DxcShaderHash
+{
+	public DxcHashFlags Flags;
+
+	public unsafe fixed byte HashDigest[16];
+}

src/Vortice.Win32.Dxc/Generated/DxcValidatorFlags.cs

@@ -0,0 +1,27 @@
+// ------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+// ------------------------------------------------------------------------------
+
+namespace Win32.Graphics.Direct3D.Dxc;
+
+/// <unmanaged>DxcValidatorFlags</unmanaged>
+[Flags]
+public enum DxcValidatorFlags : uint
+{
+	None = 0,
+	/// <unmanaged>DxcValidatorFlags_Default</unmanaged>
+	Default = 0,
+	/// <unmanaged>DxcValidatorFlags_InPlaceEdit</unmanaged>
+	InPlaceEdit = 1,
+	/// <unmanaged>DxcValidatorFlags_RootSignatureOnly</unmanaged>
+	RootSignatureOnly = 2,
+	/// <unmanaged>DxcValidatorFlags_ModuleOnly</unmanaged>
+	ModuleOnly = 4,
+	/// <unmanaged>DxcValidatorFlags_ValidMask</unmanaged>
+	ValidMask = 7,
+}

src/Vortice.Win32.Dxc/Generated/DxcVersionInfoFlags.cs

@@ -0,0 +1,22 @@
+// ------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+// ------------------------------------------------------------------------------
+
+namespace Win32.Graphics.Direct3D.Dxc;
+
+/// <unmanaged>DxcVersionInfoFlags</unmanaged>
+[Flags]
+public enum DxcVersionInfoFlags : uint
+{
+	/// <unmanaged>DxcVersionInfoFlags_None</unmanaged>
+	None = 0,
+	/// <unmanaged>DxcVersionInfoFlags_Debug</unmanaged>
+	Debug = 1,
+	/// <unmanaged>DxcVersionInfoFlags_Internal</unmanaged>
+	Internal = 2,
+}

src/Vortice.Win32.Dxc/Generated/IDxcAssembler.cs

@@ -0,0 +1,83 @@
+// ------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+// ------------------------------------------------------------------------------
+
+namespace Win32.Graphics.Direct3D.Dxc;
+
+/// <unmanaged>IDxcAssembler</unmanaged>
+[Guid("091f7a26-1c1f-4948-904b-e6e3a8a771d5")]
+[NativeTypeName("struct IDxcAssembler : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcAssembler : INativeGuid
+{
+	public static ref readonly Guid IID_IDxcAssembler
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> 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<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+#if NET6_0_OR_GREATER
+	static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcAssembler));
+#else
+	public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcAssembler));
+#endif
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult AssembleToContainer(IDxcBlob* pShader, IDxcOperationResult** ppResult)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcAssembler*, IDxcBlob*, IDxcOperationResult**, int>)(lpVtbl[3]))((IDxcAssembler*)Unsafe.AsPointer(ref this), pShader, ppResult);
+	}
+}
+

src/Vortice.Win32.Dxc/Generated/IDxcBlob.cs

@@ -0,0 +1,90 @@
+// ------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+// ------------------------------------------------------------------------------
+
+namespace Win32.Graphics.Direct3D.Dxc;
+
+/// <unmanaged>IDxcBlob</unmanaged>
+[Guid("8ba5fb08-5195-40e2-ac58-0d989c3a0102")]
+[NativeTypeName("struct IDxcBlob : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcBlob : INativeGuid
+{
+	public static ref readonly Guid IID_IDxcBlob
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> 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<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+#if NET6_0_OR_GREATER
+	static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcBlob));
+#else
+	public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcBlob));
+#endif
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public void* GetBufferPointer()
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcBlob*, void*>)(lpVtbl[3]))((IDxcBlob*)Unsafe.AsPointer(ref this));
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public nuint GetBufferSize()
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcBlob*, nuint>)(lpVtbl[4]))((IDxcBlob*)Unsafe.AsPointer(ref this));
+	}
+}
+

src/Vortice.Win32.Dxc/Generated/IDxcBlobEncoding.cs

@@ -0,0 +1,99 @@
+// ------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+// ------------------------------------------------------------------------------
+
+namespace Win32.Graphics.Direct3D.Dxc;
+
+/// <unmanaged>IDxcBlobEncoding</unmanaged>
+[Guid("7241d424-2646-4191-97c0-98e96e42fc68")]
+[NativeTypeName("struct IDxcBlobEncoding : IDxcBlob")]
+[NativeInheritance("IDxcBlob")]
+public unsafe partial struct IDxcBlobEncoding : INativeGuid
+{
+	public static ref readonly Guid IID_IDxcBlobEncoding
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> 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<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+#if NET6_0_OR_GREATER
+	static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcBlobEncoding));
+#else
+	public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcBlobEncoding));
+#endif
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IDxcBlob.GetBufferPointer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public void* GetBufferPointer()
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcBlobEncoding*, void*>)(lpVtbl[3]))((IDxcBlobEncoding*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IDxcBlob.GetBufferSize" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public nuint GetBufferSize()
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcBlobEncoding*, nuint>)(lpVtbl[4]))((IDxcBlobEncoding*)Unsafe.AsPointer(ref this));
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult GetEncoding(Bool32* pKnown, DxcCp* pCodePage)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcBlobEncoding*, Bool32*, DxcCp*, int>)(lpVtbl[5]))((IDxcBlobEncoding*)Unsafe.AsPointer(ref this), pKnown, pCodePage);
+	}
+}
+

src/Vortice.Win32.Dxc/Generated/IDxcBlobUtf16.cs

@@ -0,0 +1,114 @@
+// ------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+// ------------------------------------------------------------------------------
+
+namespace Win32.Graphics.Direct3D.Dxc;
+
+/// <unmanaged>IDxcBlobUtf16</unmanaged>
+[Guid("a3f84eab-0faa-497e-a39c-ee6ed60b2d84")]
+[NativeTypeName("struct IDxcBlobUtf16 : IDxcBlobEncoding")]
+[NativeInheritance("IDxcBlobEncoding")]
+public unsafe partial struct IDxcBlobUtf16 : INativeGuid
+{
+	public static ref readonly Guid IID_IDxcBlobUtf16
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> 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<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+#if NET6_0_OR_GREATER
+	static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcBlobUtf16));
+#else
+	public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcBlobUtf16));
+#endif
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IDxcBlob.GetBufferPointer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public void* GetBufferPointer()
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcBlobUtf16*, void*>)(lpVtbl[3]))((IDxcBlobUtf16*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IDxcBlob.GetBufferSize" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public nuint GetBufferSize()
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcBlobUtf16*, nuint>)(lpVtbl[4]))((IDxcBlobUtf16*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IDxcBlobEncoding.GetEncoding" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult GetEncoding(Bool32* pKnown, DxcCp* pCodePage)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcBlobUtf16*, Bool32*, DxcCp*, int>)(lpVtbl[5]))((IDxcBlobUtf16*)Unsafe.AsPointer(ref this), pKnown, pCodePage);
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public ushort* GetStringPointer()
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcBlobUtf16*, ushort*>)(lpVtbl[6]))((IDxcBlobUtf16*)Unsafe.AsPointer(ref this));
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public nuint GetStringLength()
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcBlobUtf16*, nuint>)(lpVtbl[7]))((IDxcBlobUtf16*)Unsafe.AsPointer(ref this));
+	}
+}
+

src/Vortice.Win32.Dxc/Generated/IDxcBlobUtf8.cs

@@ -0,0 +1,114 @@
+// ------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+// ------------------------------------------------------------------------------
+
+namespace Win32.Graphics.Direct3D.Dxc;
+
+/// <unmanaged>IDxcBlobUtf8</unmanaged>
+[Guid("3da636c9-ba71-4024-a301-30cbf125305b")]
+[NativeTypeName("struct IDxcBlobUtf8 : IDxcBlobEncoding")]
+[NativeInheritance("IDxcBlobEncoding")]
+public unsafe partial struct IDxcBlobUtf8 : INativeGuid
+{
+	public static ref readonly Guid IID_IDxcBlobUtf8
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> 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<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+#if NET6_0_OR_GREATER
+	static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcBlobUtf8));
+#else
+	public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcBlobUtf8));
+#endif
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IDxcBlob.GetBufferPointer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public void* GetBufferPointer()
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcBlobUtf8*, void*>)(lpVtbl[3]))((IDxcBlobUtf8*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IDxcBlob.GetBufferSize" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public nuint GetBufferSize()
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcBlobUtf8*, nuint>)(lpVtbl[4]))((IDxcBlobUtf8*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IDxcBlobEncoding.GetEncoding" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult GetEncoding(Bool32* pKnown, DxcCp* pCodePage)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcBlobUtf8*, Bool32*, DxcCp*, int>)(lpVtbl[5]))((IDxcBlobUtf8*)Unsafe.AsPointer(ref this), pKnown, pCodePage);
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public sbyte* GetStringPointer()
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcBlobUtf8*, sbyte*>)(lpVtbl[6]))((IDxcBlobUtf8*)Unsafe.AsPointer(ref this));
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public nuint GetStringLength()
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcBlobUtf8*, nuint>)(lpVtbl[7]))((IDxcBlobUtf8*)Unsafe.AsPointer(ref this));
+	}
+}
+

src/Vortice.Win32.Dxc/Generated/IDxcCompiler.cs

@@ -0,0 +1,97 @@
+// ------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+// ------------------------------------------------------------------------------
+
+namespace Win32.Graphics.Direct3D.Dxc;
+
+/// <unmanaged>IDxcCompiler</unmanaged>
+[Guid("8c210bf3-011f-4422-8d70-6f9acb8db617")]
+[NativeTypeName("struct IDxcCompiler : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcCompiler : INativeGuid
+{
+	public static ref readonly Guid IID_IDxcCompiler
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> 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<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+#if NET6_0_OR_GREATER
+	static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcCompiler));
+#else
+	public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcCompiler));
+#endif
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(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]<IDxcCompiler*, IDxcBlob*, ushort*, ushort*, ushort*, ushort**, uint, DxcDefine*, uint, IDxcIncludeHandler*, IDxcOperationResult**, int>)(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]<IDxcCompiler*, IDxcBlob*, ushort*, ushort**, uint, DxcDefine*, uint, IDxcIncludeHandler*, IDxcOperationResult**, int>)(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]<IDxcCompiler*, IDxcBlob*, IDxcBlobEncoding**, int>)(lpVtbl[5]))((IDxcCompiler*)Unsafe.AsPointer(ref this), pSource, ppDisassembly);
+	}
+}
+

src/Vortice.Win32.Dxc/Generated/IDxcCompiler2.cs

@@ -0,0 +1,107 @@
+// ------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+// ------------------------------------------------------------------------------
+
+namespace Win32.Graphics.Direct3D.Dxc;
+
+/// <unmanaged>IDxcCompiler2</unmanaged>
+[Guid("a005a9d9-b8bb-4594-b5c9-0e633bec4d37")]
+[NativeTypeName("struct IDxcCompiler2 : IDxcCompiler")]
+[NativeInheritance("IDxcCompiler")]
+public unsafe partial struct IDxcCompiler2 : INativeGuid
+{
+	public static ref readonly Guid IID_IDxcCompiler2
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> 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<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+#if NET6_0_OR_GREATER
+	static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcCompiler2));
+#else
+	public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcCompiler2));
+#endif
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IDxcCompiler.Compile" />
+	[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]<IDxcCompiler2*, IDxcBlob*, ushort*, ushort*, ushort*, ushort**, uint, DxcDefine*, uint, IDxcIncludeHandler*, IDxcOperationResult**, int>)(lpVtbl[3]))((IDxcCompiler2*)Unsafe.AsPointer(ref this), pSource, pSourceName, pEntryPoint, pTargetProfile, pArguments, argCount, pDefines, defineCount, pIncludeHandler, ppResult);
+	}
+
+	/// <inheritdoc cref="IDxcCompiler.Preprocess" />
+	[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]<IDxcCompiler2*, IDxcBlob*, ushort*, ushort**, uint, DxcDefine*, uint, IDxcIncludeHandler*, IDxcOperationResult**, int>)(lpVtbl[4]))((IDxcCompiler2*)Unsafe.AsPointer(ref this), pSource, pSourceName, pArguments, argCount, pDefines, defineCount, pIncludeHandler, ppResult);
+	}
+
+	/// <inheritdoc cref="IDxcCompiler.Disassemble" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult Disassemble(IDxcBlob* pSource, IDxcBlobEncoding** ppDisassembly)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcCompiler2*, IDxcBlob*, IDxcBlobEncoding**, int>)(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]<IDxcCompiler2*, IDxcBlob*, ushort*, ushort*, ushort*, ushort**, uint, DxcDefine*, uint, IDxcIncludeHandler*, IDxcOperationResult**, ushort**, IDxcBlob**, int>)(lpVtbl[6]))((IDxcCompiler2*)Unsafe.AsPointer(ref this), pSource, pSourceName, pEntryPoint, pTargetProfile, pArguments, argCount, pDefines, defineCount, pIncludeHandler, ppResult, ppDebugBlobName, ppDebugBlob);
+	}
+}
+

src/Vortice.Win32.Dxc/Generated/IDxcCompiler3.cs

@@ -0,0 +1,90 @@
+// ------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+// ------------------------------------------------------------------------------
+
+namespace Win32.Graphics.Direct3D.Dxc;
+
+/// <unmanaged>IDxcCompiler3</unmanaged>
+[Guid("228b4687-5a6a-4730-900c-9702b2203f54")]
+[NativeTypeName("struct IDxcCompiler3 : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcCompiler3 : INativeGuid
+{
+	public static ref readonly Guid IID_IDxcCompiler3
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> 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<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+#if NET6_0_OR_GREATER
+	static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcCompiler3));
+#else
+	public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcCompiler3));
+#endif
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(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]<IDxcCompiler3*, DxcBuffer*, ushort**, uint, IDxcIncludeHandler*, Guid*, void**, int>)(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]<IDxcCompiler3*, DxcBuffer*, Guid*, void**, int>)(lpVtbl[4]))((IDxcCompiler3*)Unsafe.AsPointer(ref this), pObject, riid, ppResult);
+	}
+}
+

src/Vortice.Win32.Dxc/Generated/IDxcCompilerArgs.cs

@@ -0,0 +1,111 @@
+// ------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+// ------------------------------------------------------------------------------
+
+namespace Win32.Graphics.Direct3D.Dxc;
+
+/// <unmanaged>IDxcCompilerArgs</unmanaged>
+[Guid("73effe2a-70dc-45f8-9690-eff64c02429d")]
+[NativeTypeName("struct IDxcCompilerArgs : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcCompilerArgs : INativeGuid
+{
+	public static ref readonly Guid IID_IDxcCompilerArgs
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> 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<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+#if NET6_0_OR_GREATER
+	static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcCompilerArgs));
+#else
+	public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcCompilerArgs));
+#endif
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public ushort** GetArguments()
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcCompilerArgs*, ushort**>)(lpVtbl[3]))((IDxcCompilerArgs*)Unsafe.AsPointer(ref this));
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public uint GetCount()
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcCompilerArgs*, uint>)(lpVtbl[4]))((IDxcCompilerArgs*)Unsafe.AsPointer(ref this));
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult AddArguments(ushort** pArguments, uint argCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcCompilerArgs*, ushort**, uint, int>)(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]<IDxcCompilerArgs*, sbyte**, uint, int>)(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]<IDxcCompilerArgs*, DxcDefine*, uint, int>)(lpVtbl[7]))((IDxcCompilerArgs*)Unsafe.AsPointer(ref this), pDefines, defineCount);
+	}
+}
+

src/Vortice.Win32.Dxc/Generated/IDxcContainerBuilder.cs

@@ -0,0 +1,104 @@
+// ------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+// ------------------------------------------------------------------------------
+
+namespace Win32.Graphics.Direct3D.Dxc;
+
+/// <unmanaged>IDxcContainerBuilder</unmanaged>
+[Guid("334b1f50-2292-4b35-99a1-25588d8c17fe")]
+[NativeTypeName("struct IDxcContainerBuilder : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcContainerBuilder : INativeGuid
+{
+	public static ref readonly Guid IID_IDxcContainerBuilder
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> 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<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+#if NET6_0_OR_GREATER
+	static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcContainerBuilder));
+#else
+	public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcContainerBuilder));
+#endif
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult Load(IDxcBlob* pDxilContainerHeader)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcContainerBuilder*, IDxcBlob*, int>)(lpVtbl[3]))((IDxcContainerBuilder*)Unsafe.AsPointer(ref this), pDxilContainerHeader);
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult AddPart(uint fourCC, IDxcBlob* pSource)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcContainerBuilder*, uint, IDxcBlob*, int>)(lpVtbl[4]))((IDxcContainerBuilder*)Unsafe.AsPointer(ref this), fourCC, pSource);
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult RemovePart(uint fourCC)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcContainerBuilder*, uint, int>)(lpVtbl[5]))((IDxcContainerBuilder*)Unsafe.AsPointer(ref this), fourCC);
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult SerializeContainer(IDxcOperationResult** ppResult)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcContainerBuilder*, IDxcOperationResult**, int>)(lpVtbl[6]))((IDxcContainerBuilder*)Unsafe.AsPointer(ref this), ppResult);
+	}
+}
+

src/Vortice.Win32.Dxc/Generated/IDxcContainerReflection.cs

@@ -0,0 +1,118 @@
+// ------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+// ------------------------------------------------------------------------------
+
+namespace Win32.Graphics.Direct3D.Dxc;
+
+/// <unmanaged>IDxcContainerReflection</unmanaged>
+[Guid("d2c21b26-8350-4bdc-976a-331ce6f4c54c")]
+[NativeTypeName("struct IDxcContainerReflection : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcContainerReflection : INativeGuid
+{
+	public static ref readonly Guid IID_IDxcContainerReflection
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> 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<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+#if NET6_0_OR_GREATER
+	static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcContainerReflection));
+#else
+	public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcContainerReflection));
+#endif
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult Load(IDxcBlob* pContainer)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcContainerReflection*, IDxcBlob*, int>)(lpVtbl[3]))((IDxcContainerReflection*)Unsafe.AsPointer(ref this), pContainer);
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult GetPartCount(uint* pResult)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcContainerReflection*, uint*, int>)(lpVtbl[4]))((IDxcContainerReflection*)Unsafe.AsPointer(ref this), pResult);
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult GetPartKind(uint idx, uint* pResult)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcContainerReflection*, uint, uint*, int>)(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]<IDxcContainerReflection*, uint, IDxcBlob**, int>)(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]<IDxcContainerReflection*, uint, uint*, int>)(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]<IDxcContainerReflection*, uint, Guid*, void**, int>)(lpVtbl[8]))((IDxcContainerReflection*)Unsafe.AsPointer(ref this), idx, iid, ppvObject);
+	}
+}
+

src/Vortice.Win32.Dxc/Generated/IDxcExtraOutputs.cs

@@ -0,0 +1,90 @@
+// ------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+// ------------------------------------------------------------------------------
+
+namespace Win32.Graphics.Direct3D.Dxc;
+
+/// <unmanaged>IDxcExtraOutputs</unmanaged>
+[Guid("319b37a2-a5c2-494a-a5de-4801b2faf989")]
+[NativeTypeName("struct IDxcExtraOutputs : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcExtraOutputs : INativeGuid
+{
+	public static ref readonly Guid IID_IDxcExtraOutputs
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> 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<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+#if NET6_0_OR_GREATER
+	static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcExtraOutputs));
+#else
+	public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcExtraOutputs));
+#endif
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public uint GetOutputCount()
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcExtraOutputs*, uint>)(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]<IDxcExtraOutputs*, uint, Guid*, void**, IDxcBlobUtf16**, IDxcBlobUtf16**, int>)(lpVtbl[4]))((IDxcExtraOutputs*)Unsafe.AsPointer(ref this), uIndex, iid, ppvObject, ppOutputType, ppOutputName);
+	}
+}
+

src/Vortice.Win32.Dxc/Generated/IDxcIncludeHandler.cs

@@ -0,0 +1,83 @@
+// ------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+// ------------------------------------------------------------------------------
+
+namespace Win32.Graphics.Direct3D.Dxc;
+
+/// <unmanaged>IDxcIncludeHandler</unmanaged>
+[Guid("7f61fc7d-950d-467f-b3e3-3c02fb49187c")]
+[NativeTypeName("struct IDxcIncludeHandler : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcIncludeHandler : INativeGuid
+{
+	public static ref readonly Guid IID_IDxcIncludeHandler
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> 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<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+#if NET6_0_OR_GREATER
+	static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcIncludeHandler));
+#else
+	public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcIncludeHandler));
+#endif
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult LoadSource(ushort* pFilename, IDxcBlob** ppIncludeSource)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcIncludeHandler*, ushort*, IDxcBlob**, int>)(lpVtbl[3]))((IDxcIncludeHandler*)Unsafe.AsPointer(ref this), pFilename, ppIncludeSource);
+	}
+}
+

src/Vortice.Win32.Dxc/Generated/IDxcLibrary.cs

@@ -0,0 +1,146 @@
+// ------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+// ------------------------------------------------------------------------------
+
+namespace Win32.Graphics.Direct3D.Dxc;
+
+/// <unmanaged>IDxcLibrary</unmanaged>
+[Guid("e5204dc7-d18c-4c3c-bdfb-851673980fe7")]
+[NativeTypeName("struct IDxcLibrary : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcLibrary : INativeGuid
+{
+	public static ref readonly Guid IID_IDxcLibrary
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> 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<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+#if NET6_0_OR_GREATER
+	static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcLibrary));
+#else
+	public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcLibrary));
+#endif
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult SetMalloc(Com.IMalloc* pMalloc)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcLibrary*, Com.IMalloc*, int>)(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]<IDxcLibrary*, IDxcBlob*, uint, uint, IDxcBlob**, int>)(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]<IDxcLibrary*, ushort*, DxcCp*, IDxcBlobEncoding**, int>)(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]<IDxcLibrary*, void*, uint, DxcCp, IDxcBlobEncoding**, int>)(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]<IDxcLibrary*, void*, uint, DxcCp, IDxcBlobEncoding**, int>)(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]<IDxcLibrary*, void*, Com.IMalloc*, uint, DxcCp, IDxcBlobEncoding**, int>)(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]<IDxcLibrary*, IDxcIncludeHandler**, int>)(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]<IDxcLibrary*, IDxcBlob*, Com.IStream**, int>)(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]<IDxcLibrary*, IDxcBlob*, IDxcBlobEncoding**, int>)(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]<IDxcLibrary*, IDxcBlob*, IDxcBlobEncoding**, int>)(lpVtbl[12]))((IDxcLibrary*)Unsafe.AsPointer(ref this), pBlob, pBlobEncoding);
+	}
+}
+

src/Vortice.Win32.Dxc/Generated/IDxcLinker.cs

@@ -0,0 +1,90 @@
+// ------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+// ------------------------------------------------------------------------------
+
+namespace Win32.Graphics.Direct3D.Dxc;
+
+/// <unmanaged>IDxcLinker</unmanaged>
+[Guid("f1b5be2a-62dd-4327-a1c2-42ac1e1e78e6")]
+[NativeTypeName("struct IDxcLinker : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcLinker : INativeGuid
+{
+	public static ref readonly Guid IID_IDxcLinker
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> 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<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+#if NET6_0_OR_GREATER
+	static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcLinker));
+#else
+	public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcLinker));
+#endif
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult RegisterLibrary(ushort* pLibName, IDxcBlob* pLib)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcLinker*, ushort*, IDxcBlob*, int>)(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]<IDxcLinker*, ushort*, ushort*, ushort**, uint, ushort**, uint, IDxcOperationResult**, int>)(lpVtbl[4]))((IDxcLinker*)Unsafe.AsPointer(ref this), pEntryName, pTargetProfile, pLibNames, libCount, pArguments, argCount, ppResult);
+	}
+}
+

src/Vortice.Win32.Dxc/Generated/IDxcOperationResult.cs

@@ -0,0 +1,97 @@
+// ------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+// ------------------------------------------------------------------------------
+
+namespace Win32.Graphics.Direct3D.Dxc;
+
+/// <unmanaged>IDxcOperationResult</unmanaged>
+[Guid("cedb484a-d4e9-445a-b991-ca21ca157dc2")]
+[NativeTypeName("struct IDxcOperationResult : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcOperationResult : INativeGuid
+{
+	public static ref readonly Guid IID_IDxcOperationResult
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> 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<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+#if NET6_0_OR_GREATER
+	static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcOperationResult));
+#else
+	public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcOperationResult));
+#endif
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult GetStatus(HResult* pStatus)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcOperationResult*, HResult*, int>)(lpVtbl[3]))((IDxcOperationResult*)Unsafe.AsPointer(ref this), pStatus);
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult GetResult(IDxcBlob** ppResult)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcOperationResult*, IDxcBlob**, int>)(lpVtbl[4]))((IDxcOperationResult*)Unsafe.AsPointer(ref this), ppResult);
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult GetErrorBuffer(IDxcBlobEncoding** ppErrors)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcOperationResult*, IDxcBlobEncoding**, int>)(lpVtbl[5]))((IDxcOperationResult*)Unsafe.AsPointer(ref this), ppErrors);
+	}
+}
+

src/Vortice.Win32.Dxc/Generated/IDxcOptimizer.cs

@@ -0,0 +1,97 @@
+// ------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+// ------------------------------------------------------------------------------
+
+namespace Win32.Graphics.Direct3D.Dxc;
+
+/// <unmanaged>IDxcOptimizer</unmanaged>
+[Guid("25740e2e-9cba-401b-9119-4fb42f39f270")]
+[NativeTypeName("struct IDxcOptimizer : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcOptimizer : INativeGuid
+{
+	public static ref readonly Guid IID_IDxcOptimizer
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> 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<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+#if NET6_0_OR_GREATER
+	static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcOptimizer));
+#else
+	public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcOptimizer));
+#endif
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult GetAvailablePassCount(uint* pCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcOptimizer*, uint*, int>)(lpVtbl[3]))((IDxcOptimizer*)Unsafe.AsPointer(ref this), pCount);
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult GetAvailablePass(uint index, IDxcOptimizerPass** ppResult)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcOptimizer*, uint, IDxcOptimizerPass**, int>)(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]<IDxcOptimizer*, IDxcBlob*, ushort**, uint, IDxcBlob**, IDxcBlobEncoding**, int>)(lpVtbl[5]))((IDxcOptimizer*)Unsafe.AsPointer(ref this), pBlob, ppOptions, optionCount, pOutputModule, ppOutputText);
+	}
+}
+

src/Vortice.Win32.Dxc/Generated/IDxcOptimizerPass.cs

@@ -0,0 +1,111 @@
+// ------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+// ------------------------------------------------------------------------------
+
+namespace Win32.Graphics.Direct3D.Dxc;
+
+/// <unmanaged>IDxcOptimizerPass</unmanaged>
+[Guid("ae2cd79f-cc22-453f-9b6b-b124e7a5204c")]
+[NativeTypeName("struct IDxcOptimizerPass : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcOptimizerPass : INativeGuid
+{
+	public static ref readonly Guid IID_IDxcOptimizerPass
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> 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<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+#if NET6_0_OR_GREATER
+	static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcOptimizerPass));
+#else
+	public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcOptimizerPass));
+#endif
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult GetOptionName(ushort** ppResult)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcOptimizerPass*, ushort**, int>)(lpVtbl[3]))((IDxcOptimizerPass*)Unsafe.AsPointer(ref this), ppResult);
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult GetDescription(ushort** ppResult)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcOptimizerPass*, ushort**, int>)(lpVtbl[4]))((IDxcOptimizerPass*)Unsafe.AsPointer(ref this), ppResult);
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult GetOptionArgCount(uint* pCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcOptimizerPass*, uint*, int>)(lpVtbl[5]))((IDxcOptimizerPass*)Unsafe.AsPointer(ref this), pCount);
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public HResult GetOptionArgName(uint argIndex, ushort** ppResult)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcOptimizerPass*, uint, ushort**, int>)(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]<IDxcOptimizerPass*, uint, ushort**, int>)(lpVtbl[7]))((IDxcOptimizerPass*)Unsafe.AsPointer(ref this), argIndex, ppResult);
+	}
+}
+

src/Vortice.Win32.Dxc/Generated/IDxcPdbUtils.cs

@@ -0,0 +1,244 @@
+// ------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+// ------------------------------------------------------------------------------
+
+namespace Win32.Graphics.Direct3D.Dxc;
+
+/// <unmanaged>IDxcPdbUtils</unmanaged>
+[Guid("e6c9647e-9d6a-4c3b-b94c-524b5a6c343d")]
+[NativeTypeName("struct IDxcPdbUtils : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcPdbUtils : INativeGuid
+{
+	public static ref readonly Guid IID_IDxcPdbUtils
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> 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<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+#if NET6_0_OR_GREATER
+	static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcPdbUtils));
+#else
+	public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcPdbUtils));
+#endif
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult Load(IDxcBlob* pPdbOrDxil)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcPdbUtils*, IDxcBlob*, int>)(lpVtbl[3]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), pPdbOrDxil);
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult GetSourceCount(uint* pCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcPdbUtils*, uint*, int>)(lpVtbl[4]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), pCount);
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult GetSource(uint uIndex, IDxcBlobEncoding** ppResult)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcPdbUtils*, uint, IDxcBlobEncoding**, int>)(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]<IDxcPdbUtils*, uint, char**, int>)(lpVtbl[6]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), uIndex, pResult);
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(7)]
+	public HResult GetFlagCount(uint* pCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcPdbUtils*, uint*, int>)(lpVtbl[7]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), pCount);
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public HResult GetFlag(uint uIndex, char** pResult)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcPdbUtils*, uint, char**, int>)(lpVtbl[8]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), uIndex, pResult);
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult GetArgCount(uint* pCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcPdbUtils*, uint*, int>)(lpVtbl[9]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), pCount);
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public HResult GetArg(uint uIndex, char** pResult)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcPdbUtils*, uint, char**, int>)(lpVtbl[10]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), uIndex, pResult);
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(11)]
+	public HResult GetArgPairCount(uint* pCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcPdbUtils*, uint*, int>)(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]<IDxcPdbUtils*, uint, char**, char**, int>)(lpVtbl[12]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), uIndex, pName, pValue);
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(13)]
+	public HResult GetDefineCount(uint* pCount)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcPdbUtils*, uint*, int>)(lpVtbl[13]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), pCount);
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(14)]
+	public HResult GetDefine(uint uIndex, char** pResult)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcPdbUtils*, uint, char**, int>)(lpVtbl[14]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), uIndex, pResult);
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(15)]
+	public HResult GetTargetProfile(char** pResult)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcPdbUtils*, char**, int>)(lpVtbl[15]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), pResult);
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(16)]
+	public HResult GetEntryPoint(char** pResult)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcPdbUtils*, char**, int>)(lpVtbl[16]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), pResult);
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(17)]
+	public HResult GetMainFileName(char** pResult)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcPdbUtils*, char**, int>)(lpVtbl[17]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), pResult);
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(18)]
+	public HResult GetHash(IDxcBlob** ppResult)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcPdbUtils*, IDxcBlob**, int>)(lpVtbl[18]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), ppResult);
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(19)]
+	public HResult GetName(char** pResult)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcPdbUtils*, char**, int>)(lpVtbl[19]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), pResult);
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(20)]
+	public Bool32 IsFullPDB()
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcPdbUtils*, Bool32>)(lpVtbl[20]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this));
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(21)]
+	public HResult GetFullPDB(IDxcBlob** ppFullPDB)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcPdbUtils*, IDxcBlob**, int>)(lpVtbl[21]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), ppFullPDB);
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(22)]
+	public HResult GetVersionInfo(IDxcVersionInfo** ppVersionInfo)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcPdbUtils*, IDxcVersionInfo**, int>)(lpVtbl[22]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), ppVersionInfo);
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(23)]
+	public HResult SetCompiler(IDxcCompiler3* pCompiler)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcPdbUtils*, IDxcCompiler3*, int>)(lpVtbl[23]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), pCompiler);
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(24)]
+	public HResult CompileForFullPDB(IDxcResult** ppResult)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcPdbUtils*, IDxcResult**, int>)(lpVtbl[24]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), ppResult);
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(25)]
+	public HResult OverrideArgs(DxcArgPair* pArgPairs, uint uNumArgPairs)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcPdbUtils*, DxcArgPair*, uint, int>)(lpVtbl[25]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), pArgPairs, uNumArgPairs);
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(26)]
+	public HResult OverrideRootSignature(ushort* pRootSignature)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcPdbUtils*, ushort*, int>)(lpVtbl[26]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), pRootSignature);
+	}
+}
+

src/Vortice.Win32.Dxc/Generated/IDxcResult.cs

@@ -0,0 +1,135 @@
+// ------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+// ------------------------------------------------------------------------------
+
+namespace Win32.Graphics.Direct3D.Dxc;
+
+/// <unmanaged>IDxcResult</unmanaged>
+[Guid("58346cda-dde7-4497-9461-6f87af5e0659")]
+[NativeTypeName("struct IDxcResult : IDxcOperationResult")]
+[NativeInheritance("IDxcOperationResult")]
+public unsafe partial struct IDxcResult : INativeGuid
+{
+	public static ref readonly Guid IID_IDxcResult
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> 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<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+#if NET6_0_OR_GREATER
+	static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcResult));
+#else
+	public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcResult));
+#endif
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IDxcOperationResult.GetStatus" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult GetStatus(HResult* pStatus)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcResult*, HResult*, int>)(lpVtbl[3]))((IDxcResult*)Unsafe.AsPointer(ref this), pStatus);
+	}
+
+	/// <inheritdoc cref="IDxcOperationResult.GetResult" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult GetResult(IDxcBlob** ppResult)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcResult*, IDxcBlob**, int>)(lpVtbl[4]))((IDxcResult*)Unsafe.AsPointer(ref this), ppResult);
+	}
+
+	/// <inheritdoc cref="IDxcOperationResult.GetErrorBuffer" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult GetErrorBuffer(IDxcBlobEncoding** ppErrors)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcResult*, IDxcBlobEncoding**, int>)(lpVtbl[5]))((IDxcResult*)Unsafe.AsPointer(ref this), ppErrors);
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(6)]
+	public Bool32 HasOutput(DxcOutKind dxcOutKind)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcResult*, DxcOutKind, Bool32>)(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]<IDxcResult*, DxcOutKind, Guid*, void**, IDxcBlobUtf16**, int>)(lpVtbl[7]))((IDxcResult*)Unsafe.AsPointer(ref this), dxcOutKind, iid, ppvObject, ppOutputName);
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(8)]
+	public uint GetNumOutputs()
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcResult*, uint>)(lpVtbl[8]))((IDxcResult*)Unsafe.AsPointer(ref this));
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public DxcOutKind GetOutputByIndex(uint Index)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcResult*, uint, DxcOutKind>)(lpVtbl[9]))((IDxcResult*)Unsafe.AsPointer(ref this), Index);
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public DxcOutKind PrimaryOutput()
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcResult*, DxcOutKind>)(lpVtbl[10]))((IDxcResult*)Unsafe.AsPointer(ref this));
+	}
+}
+

src/Vortice.Win32.Dxc/Generated/IDxcUtils.cs

@@ -0,0 +1,167 @@
+// ------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+// ------------------------------------------------------------------------------
+
+namespace Win32.Graphics.Direct3D.Dxc;
+
+/// <unmanaged>IDxcUtils</unmanaged>
+[Guid("4605c4cb-2019-492a-ada4-65f20bb7d67f")]
+[NativeTypeName("struct IDxcUtils : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcUtils : INativeGuid
+{
+	public static ref readonly Guid IID_IDxcUtils
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> 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<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+#if NET6_0_OR_GREATER
+	static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcUtils));
+#else
+	public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcUtils));
+#endif
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(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]<IDxcUtils*, IDxcBlob*, uint, uint, IDxcBlob**, int>)(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]<IDxcUtils*, void*, uint, DxcCp, IDxcBlobEncoding**, int>)(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]<IDxcUtils*, void*, Com.IMalloc*, uint, DxcCp, IDxcBlobEncoding**, int>)(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]<IDxcUtils*, void*, uint, DxcCp, IDxcBlobEncoding**, int>)(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]<IDxcUtils*, ushort*, DxcCp*, IDxcBlobEncoding**, int>)(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]<IDxcUtils*, IDxcBlob*, Com.IStream**, int>)(lpVtbl[8]))((IDxcUtils*)Unsafe.AsPointer(ref this), pBlob, ppStream);
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(9)]
+	public HResult CreateDefaultIncludeHandler(IDxcIncludeHandler** ppResult)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcUtils*, IDxcIncludeHandler**, int>)(lpVtbl[9]))((IDxcUtils*)Unsafe.AsPointer(ref this), ppResult);
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(10)]
+	public HResult GetBlobAsUtf8(IDxcBlob* pBlob, IDxcBlobUtf8** pBlobEncoding)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcUtils*, IDxcBlob*, IDxcBlobUtf8**, int>)(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]<IDxcUtils*, IDxcBlob*, IDxcBlobUtf16**, int>)(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]<IDxcUtils*, DxcBuffer*, uint, void**, uint*, int>)(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]<IDxcUtils*, DxcBuffer*, Guid*, void**, int>)(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]<IDxcUtils*, ushort*, ushort*, ushort*, ushort**, uint, DxcDefine*, uint, IDxcCompilerArgs**, int>)(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]<IDxcUtils*, IDxcBlob*, IDxcBlob**, IDxcBlob**, int>)(lpVtbl[15]))((IDxcUtils*)Unsafe.AsPointer(ref this), pPDBBlob, ppHash, ppContainer);
+	}
+}
+

src/Vortice.Win32.Dxc/Generated/IDxcValidator.cs

@@ -0,0 +1,83 @@
+// ------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+// ------------------------------------------------------------------------------
+
+namespace Win32.Graphics.Direct3D.Dxc;
+
+/// <unmanaged>IDxcValidator</unmanaged>
+[Guid("a6e82bd2-1fd7-4826-9811-2857e797f49a")]
+[NativeTypeName("struct IDxcValidator : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcValidator : INativeGuid
+{
+	public static ref readonly Guid IID_IDxcValidator
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> 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<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+#if NET6_0_OR_GREATER
+	static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcValidator));
+#else
+	public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcValidator));
+#endif
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult Validate(IDxcBlob* pShader, DxcValidatorFlags Flags, IDxcOperationResult** ppResult)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcValidator*, IDxcBlob*, DxcValidatorFlags, IDxcOperationResult**, int>)(lpVtbl[3]))((IDxcValidator*)Unsafe.AsPointer(ref this), pShader, Flags, ppResult);
+	}
+}
+

src/Vortice.Win32.Dxc/Generated/IDxcValidator2.cs

@@ -0,0 +1,91 @@
+// ------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+// ------------------------------------------------------------------------------
+
+namespace Win32.Graphics.Direct3D.Dxc;
+
+/// <unmanaged>IDxcValidator2</unmanaged>
+[Guid("458e1fd1-b1b2-4750-a6e1-9c10f03bed92")]
+[NativeTypeName("struct IDxcValidator2 : IDxcValidator")]
+[NativeInheritance("IDxcValidator")]
+public unsafe partial struct IDxcValidator2 : INativeGuid
+{
+	public static ref readonly Guid IID_IDxcValidator2
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> 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<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+#if NET6_0_OR_GREATER
+	static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcValidator2));
+#else
+	public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcValidator2));
+#endif
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IDxcValidator.Validate" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult Validate(IDxcBlob* pShader, DxcValidatorFlags Flags, IDxcOperationResult** ppResult)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcValidator2*, IDxcBlob*, DxcValidatorFlags, IDxcOperationResult**, int>)(lpVtbl[3]))((IDxcValidator2*)Unsafe.AsPointer(ref this), pShader, Flags, ppResult);
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult ValidateWithDebug(IDxcBlob* pShader, DxcValidatorFlags Flags, DxcBuffer* pOptDebugBitcode, IDxcOperationResult** ppResult)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcValidator2*, IDxcBlob*, DxcValidatorFlags, DxcBuffer*, IDxcOperationResult**, int>)(lpVtbl[4]))((IDxcValidator2*)Unsafe.AsPointer(ref this), pShader, Flags, pOptDebugBitcode, ppResult);
+	}
+}
+

src/Vortice.Win32.Dxc/Generated/IDxcVersionInfo.cs

@@ -0,0 +1,90 @@
+// ------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+// ------------------------------------------------------------------------------
+
+namespace Win32.Graphics.Direct3D.Dxc;
+
+/// <unmanaged>IDxcVersionInfo</unmanaged>
+[Guid("b04f5b50-2059-4f12-a8ff-a1e0cde1cc7e")]
+[NativeTypeName("struct IDxcVersionInfo : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcVersionInfo : INativeGuid
+{
+	public static ref readonly Guid IID_IDxcVersionInfo
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> 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<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+#if NET6_0_OR_GREATER
+	static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcVersionInfo));
+#else
+	public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcVersionInfo));
+#endif
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult GetVersion(uint* pMajor, uint* pMinor)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcVersionInfo*, uint*, uint*, int>)(lpVtbl[3]))((IDxcVersionInfo*)Unsafe.AsPointer(ref this), pMajor, pMinor);
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult GetFlags(DxcVersionInfoFlags* pFlags)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcVersionInfo*, DxcVersionInfoFlags*, int>)(lpVtbl[4]))((IDxcVersionInfo*)Unsafe.AsPointer(ref this), pFlags);
+	}
+}
+

src/Vortice.Win32.Dxc/Generated/IDxcVersionInfo2.cs

@@ -0,0 +1,99 @@
+// ------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+// ------------------------------------------------------------------------------
+
+namespace Win32.Graphics.Direct3D.Dxc;
+
+/// <unmanaged>IDxcVersionInfo2</unmanaged>
+[Guid("fb6904c4-42f0-4b62-9c46-983af7da7c83")]
+[NativeTypeName("struct IDxcVersionInfo2 : IDxcVersionInfo")]
+[NativeInheritance("IDxcVersionInfo")]
+public unsafe partial struct IDxcVersionInfo2 : INativeGuid
+{
+	public static ref readonly Guid IID_IDxcVersionInfo2
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> 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<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+#if NET6_0_OR_GREATER
+	static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcVersionInfo2));
+#else
+	public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcVersionInfo2));
+#endif
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IDxcVersionInfo.GetVersion" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult GetVersion(uint* pMajor, uint* pMinor)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcVersionInfo2*, uint*, uint*, int>)(lpVtbl[3]))((IDxcVersionInfo2*)Unsafe.AsPointer(ref this), pMajor, pMinor);
+	}
+
+	/// <inheritdoc cref="IDxcVersionInfo.GetFlags" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(4)]
+	public HResult GetFlags(DxcVersionInfoFlags* pFlags)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcVersionInfo2*, DxcVersionInfoFlags*, int>)(lpVtbl[4]))((IDxcVersionInfo2*)Unsafe.AsPointer(ref this), pFlags);
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(5)]
+	public HResult GetCommitInfo(uint* pCommitCount, sbyte** pCommitHash)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcVersionInfo2*, uint*, sbyte**, int>)(lpVtbl[5]))((IDxcVersionInfo2*)Unsafe.AsPointer(ref this), pCommitCount, pCommitHash);
+	}
+}
+

src/Vortice.Win32.Dxc/Generated/IDxcVersionInfo3.cs

@@ -0,0 +1,83 @@
+// ------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+// ------------------------------------------------------------------------------
+
+namespace Win32.Graphics.Direct3D.Dxc;
+
+/// <unmanaged>IDxcVersionInfo3</unmanaged>
+[Guid("5e13e843-9d25-473c-9ad2-03b2d0b44b1e")]
+[NativeTypeName("struct IDxcVersionInfo3 : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcVersionInfo3 : INativeGuid
+{
+	public static ref readonly Guid IID_IDxcVersionInfo3
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			ReadOnlySpan<byte> 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<Guid>());
+			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+		}
+	}
+
+#if NET6_0_OR_GREATER
+	static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcVersionInfo3));
+#else
+	public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDxcVersionInfo3));
+#endif
+
+	public void** lpVtbl;
+
+	/// <inheritdoc cref="IUnknown.QueryInterface" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(0)]
+	public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, Guid*, void**, int>)(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject);
+	}
+
+	/// <inheritdoc cref="IUnknown.AddRef" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(1)]
+	[return: NativeTypeName("ULONG")]
+	public uint AddRef()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	/// <inheritdoc cref="IUnknown.Release" />
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(2)]
+	[return: NativeTypeName("ULONG")]
+	public uint Release()
+	{
+		return ((delegate* unmanaged[Stdcall]<IUnknown*, uint>)(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this));
+	}
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	[VtblIndex(3)]
+	public HResult GetCustomVersionString(sbyte** pVersionString)
+	{
+		return ((delegate* unmanaged[Stdcall]<IDxcVersionInfo3*, sbyte**, int>)(lpVtbl[3]))((IDxcVersionInfo3*)Unsafe.AsPointer(ref this), pVersionString);
+	}
+}
+