feat(shader): refactor and enhance shader compilation

Refactored shader compilation and resource management systems:
- Introduced `DXCShaderCompiler` for HLSL compilation and reflection.
- Added `BuildFinalShaderCode` method for robust shader code generation.
- Replaced raw strings with `ShaderEntryPoint` struct for shader paths.
- Updated `RenderContext` and `RenderGraphContext` for new pipeline methods.
- Added thread-safe resource management methods in `ResourceManager`.
- Introduced `DXCShaderReflectionData` for shader reflection handling.
- Removed redundant code and simplified `ShaderPropertiesRegistry`.

BREAKING CHANGE: Updated shader and resource APIs to use new structures and methods.

src/Editor/Ghost.DSL/Generator/ShaderStructGenerator.cs

@@ -1,3 +1,4 @@
+using Ghost.Core.Graphics;
 using Misaki.HighPerformance.Mathematics;
 using System.Numerics;
 using System.Reflection;
@@ -7,25 +8,6 @@ using System.Text.RegularExpressions;
 
 namespace Ghost.DSL.Generator;
 
-public enum PackingRules
-{
-    Exact,
-    Aligned,
-}
-
-[AttributeUsage(AttributeTargets.Struct | AttributeTargets.Enum)]
-public class GenerateHLSLAttribute : Attribute
-{
-    private readonly PackingRules _packingRules;
-    private readonly string? _outputSource;
-
-    public GenerateHLSLAttribute(PackingRules packingRules, string? outputSource)
-    {
-        _packingRules = packingRules;
-        _outputSource = outputSource;
-    }
-}
-
 internal static partial class ShaderStructGenerator
 {
     private struct ShaderFieldInfo

src/Editor/Ghost.DSL/ShaderCompiler/DSLShaderCompiler.cs

@@ -1,6 +1,7 @@
 using Ghost.Core;
 using Ghost.Core.Graphics;
 using Ghost.DSL.ShaderParser;
+using Misaki.HighPerformance.Utilities;
 using System.IO.Hashing;
 using System.Runtime.InteropServices;
 using System.Text;
@@ -43,51 +44,121 @@ internal static class DSLShaderCompiler
         };
     }
 
+    private static Result<string> BuildFinalShaderCode(string shaderPath, ReadOnlySpan<string> includes, string? injectedCode, string? properties)
+    {
+        string shaderCode;
+        if (shaderPath == "hlsl_block")
+        {
+            if (string.IsNullOrEmpty(injectedCode))
+            {
+                return Result.Failure("Shader code is empty. Either provide a valid shader path or inject shader code directly.");
+            }
+
+            shaderCode = string.Empty;
+        }
+        else
+        {
+            if (!File.Exists(shaderPath))
+            {
+                return Result.Failure("Shader file not found: " + shaderPath);
+            }
+
+            shaderCode = File.ReadAllText(shaderPath);
+        }
+
+        var sb = new StringBuilder();
+        foreach (var includePath in includes)
+        {
+            sb.AppendLine($"#include \"{includePath}\"");
+        }
+
+        if (!string.IsNullOrEmpty(properties))
+        {
+            sb.AppendLine($"#line 0 \"properties\"");
+            sb.AppendLine(properties);
+        }
+
+        if (!string.IsNullOrEmpty(injectedCode))
+        {
+            sb.AppendLine($"#line 0 \"injected_code\"");
+            sb.AppendLine(injectedCode);
+        }
+
+        if (!string.IsNullOrEmpty(shaderCode))
+        {
+            sb.AppendLine($"#line 0 \"{shaderPath}\"");
+            sb.AppendLine(shaderCode);
+        }
+
+        return sb.ToString();
+    }
+
     // TODO: Implement shader inheritance resolution, including property and pass merging.
     // Currently, we just ignore inheritance.
     public static Result<GraphicsShaderDescriptor> ResolveShader(DSLShaderSemantics semantics)
     {
+        if (!ShaderPropertiesRegistry.TryGetInfo(semantics.name, out var propertyInfo))
+        {
+            propertyInfo = default;
+        }
+
+        var passes = semantics.passes == null ? Array.Empty<PassDescriptor>() : new PassDescriptor[semantics.passes.Count];
+        for (var i = 0; i < passes.Length; i++)
+        {
+            var pass = semantics.passes![i];
+            var localPipeline = MeragePipeline(pass.localPipeline, PipelineState.Default);
+
+            var result = BuildFinalShaderCode(pass.amplificationShader.shaderPath, pass.includes.AsSpan(), pass.hlsl, propertyInfo.code);
+            if (result.IsFailure)
+            {
+                return Result.Failure($"Failed to build shader code for pass '{pass.name}': {result.Message}");
+            }
+
+            var amplificationShaderCode = new ShaderCode { code = result.Value, entryPoint = pass.amplificationShader.entry };
+
+            result = BuildFinalShaderCode(pass.meshShader.shaderPath, pass.includes.AsSpan(), pass.hlsl, propertyInfo.code);
+            if (result.IsFailure)
+            {
+                return Result.Failure($"Failed to build shader code for pass '{pass.name}': {result.Message}");
+            }
+
+            var meshShaderCode = new ShaderCode { code = result.Value, entryPoint = pass.meshShader.entry };
+
+            result = BuildFinalShaderCode(pass.pixelShader.shaderPath, pass.includes.AsSpan(), pass.hlsl, propertyInfo.code);
+            if (result.IsFailure)
+            {
+                return Result.Failure($"Failed to build shader code for pass '{pass.name}': {result.Message}");
+            }
+
+            var pixelShaderCode = new ShaderCode { code = result.Value, entryPoint = pass.pixelShader.entry };
+
+            passes[i] = new PassDescriptor
+            {
+                identifier = GetPassUniqueId(semantics, pass),
+                name = pass.name,
+
+                amplificationShaderCode = amplificationShaderCode,
+                meshShaderCode = meshShaderCode,
+                pixelShaderCode = pixelShaderCode,
+
+                localPipeline = localPipeline,
+                defines = pass.defines?.ToArray() ?? Array.Empty<string>(),
+                keywords = pass.keywords?.ToArray() ?? Array.Empty<KeywordsGroup>()
+            };
+        }
+
         var descriptor = new GraphicsShaderDescriptor
         {
             name = semantics.name,
+            propertyBufferSize = propertyInfo.size,
+
+            shaderModel = semantics.shaderModel,
+            passes = passes
         };
 
-        if (!ShaderPropertiesRegistry.TryGetInfo(semantics.name, out var info))
+        for (int i = 0; i < descriptor.passes.Length; i++)
         {
-            info = default;
-        }
-
-        descriptor.propertiesCode = info.code ?? string.Empty;
-        descriptor.propertyBufferSize = info.size;
-
-        descriptor.shaderModel = semantics.shaderModel;
-
-        if (semantics.passes != null)
-        {
-            descriptor.passes = new PassDescriptor[semantics.passes.Count];
-            for (var i = 0; i < semantics.passes.Count; i++)
-            {
-                var pass = semantics.passes[i];
-                var localPipeline = MeragePipeline(pass.localPipeline, PipelineState.Default);
-                descriptor.passes[i] = new PassDescriptor
-                {
-                    shader = descriptor,
-                    identifier = GetPassUniqueId(semantics, pass),
-                    name = pass.name,
-                    taskShader = pass.taskShader,
-                    meshShader = pass.meshShader,
-                    pixelShader = pass.pixelShader,
-                    localPipeline = localPipeline,
-                    defines = pass.defines?.ToArray() ?? Array.Empty<string>(),
-                    includes = pass.includes?.ToArray() ?? Array.Empty<string>(),
-                    keywords = pass.keywords?.ToArray() ?? Array.Empty<KeywordsGroup>(),
-                    hlsl = pass.hlsl
-                };
-            }
-        }
-        else
-        {
-            descriptor.passes = Array.Empty<PassDescriptor>();
+            descriptor.passes[i].shader = descriptor;
         }
 
         return descriptor;
@@ -199,28 +270,32 @@ internal static class DSLShaderCompiler
 
     public static Result<ComputeShaderDescriptor> ResolveComputeShader(DSLComputeShaderSemantics semantics)
     {
-        var descriptor = new ComputeShaderDescriptor
+        if (!ShaderPropertiesRegistry.TryGetInfo(semantics.name, out var propertyInfo))
+        {
+            propertyInfo = default;
+        }
+
+        var shaderCodes = new ShaderCode[semantics.entryPoints.Count];
+        for (int i = 0; i < shaderCodes.Length; i++)
+        {
+            var result = BuildFinalShaderCode(semantics.entryPoints[i].shaderPath, semantics.includes.AsSpan(), semantics.hlsl, propertyInfo.code);
+            if (result.IsFailure)
+            {
+                return Result.Failure($"Failed to build shader code for entry point '{semantics.entryPoints[i].entry}': {result.Message}");
+            }
+
+            shaderCodes[i] = new ShaderCode { code = result.Value, entryPoint = semantics.entryPoints[i].entry };
+        }
+
+        return new ComputeShaderDescriptor
         {
             identifier = XxHash64.HashToUInt64(MemoryMarshal.AsBytes(semantics.name.AsSpan())),
             name = semantics.name,
+            propertyBufferSize = propertyInfo.size,
+            shaderModel = semantics.shaderModel,
+            shaderCodes = shaderCodes,
+            defines = semantics.defines?.ToArray() ?? Array.Empty<string>(),
+            keywords = semantics.keywords?.ToArray() ?? Array.Empty<KeywordsGroup>()
         };
-
-        if (!ShaderPropertiesRegistry.TryGetInfo(semantics.name, out var info))
-        {
-            info = default;
-        }
-
-        descriptor.propertiesCode = info.code ?? string.Empty;
-        descriptor.propertyBufferSize = info.size;
-
-        descriptor.shaderModel = semantics.shaderModel;
-
-        descriptor.hlsl = semantics.hlsl;
-        descriptor.defines = semantics.defines?.ToArray() ?? Array.Empty<string>();
-        descriptor.includes = semantics.includes?.ToArray() ?? Array.Empty<string>();
-        descriptor.keywords = semantics.keywords?.ToArray() ?? Array.Empty<KeywordsGroup>();
-        descriptor.entryPoints = semantics.entryPoints?.ToArray() ?? Array.Empty<ShaderEntryPoint>();
-
-        return descriptor;
     }
 }

src/Editor/Ghost.DSL/ShaderCompiler/DSLShaderSemantics.cs

@@ -8,6 +8,14 @@ public enum PropertyScope
     Local,
 }
 
+public struct ShaderEntryPoint
+{
+    public string entry;
+    public string shaderPath;
+
+    public readonly bool IsCreated => !string.IsNullOrEmpty(entry) && !string.IsNullOrEmpty(shaderPath);
+}
+
 public class PipelineSemantic
 {
     public ZTest? zTest;
@@ -20,7 +28,7 @@ public class PipelineSemantic
 public class PassSemantic
 {
     public string name = string.Empty;
-    public ShaderEntryPoint taskShader;
+    public ShaderEntryPoint amplificationShader;
     public ShaderEntryPoint meshShader;
     public ShaderEntryPoint pixelShader;
     public string? hlsl;
@@ -46,5 +54,5 @@ public class DSLComputeShaderSemantics
     public List<string>? defines;
     public List<string>? includes;
     public List<KeywordsGroup>? keywords;
-    public List<ShaderEntryPoint>? entryPoints;
+    public List<ShaderEntryPoint> entryPoints = null!;
 }

src/Editor/Ghost.DSL/ShaderParser/AntlrShaderCompiler.cs

@@ -169,7 +169,7 @@ public class AntlrShaderCompiler
                 semantics.entryPoints ??= new List<ShaderEntryPoint>();
                 semantics.entryPoints.Add(new ShaderEntryPoint
                 {
-                    shader = entry.ShaderPath,
+                    shaderPath = entry.ShaderPath,
                     entry = entry.EntryPoint
                 });
             }
@@ -355,7 +355,7 @@ public class AntlrShaderCompiler
             var entryType = entry.EntryType.ToLower();
             var shaderEntry = new ShaderEntryPoint
             {
-                shader = entry.ShaderPath,
+                shaderPath = entry.ShaderPath,
                 entry = entry.EntryPoint
             };
 
@@ -368,7 +368,7 @@ public class AntlrShaderCompiler
                     semantic.pixelShader = shaderEntry;
                     break;
                 case "as":
-                    semantic.taskShader = shaderEntry;
+                    semantic.amplificationShader = shaderEntry;
                     break;
                 default:
                     errors.Add(new DSLShaderError
@@ -381,7 +381,7 @@ public class AntlrShaderCompiler
             }
         }
 
-        if (semantic.meshShader.shader == null || semantic.pixelShader.shader == null)
+        if (semantic.meshShader.shaderPath == null || semantic.pixelShader.shaderPath == null)
         {
             errors.Add(new DSLShaderError
             {

src/Editor/Ghost.DSL/ShaderPropertyRegistry.cs

@@ -1,22 +1,5 @@
-namespace Ghost.Core.Graphics;
+namespace Ghost.DSL;
 
-[AttributeUsage(AttributeTargets.Struct)]
-public class GenerateShaderPropertyAttribute : Attribute
-{
-    public GenerateShaderPropertyAttribute(string shaderName, string? name = null)
-    {
-    }
-}
-
-[AttributeUsage(AttributeTargets.Field)]
-public class GenerateAsHLSLTypeAttribute : Attribute
-{
-    public GenerateAsHLSLTypeAttribute(string hlslTypeName)
-    {
-    }
-}
-
-#if DEBUG || GHOST_EDITOR
 public struct ShaderPropertyInfo
 {
     public string shaderName;
@@ -37,5 +20,4 @@ public static class ShaderPropertiesRegistry
     {
         return s_nameToCode.TryGetValue(name, out info);
     }
-}
-#endif
+}

src/Editor/Ghost.Editor.Core/Ghost.Editor.Core.csproj

@@ -23,6 +23,7 @@
   <ItemGroup>
     <ProjectReference Include="..\..\Runtime\Ghost.Core\Ghost.Core.csproj" />
     <ProjectReference Include="..\..\Runtime\Ghost.Engine\Ghost.Engine.csproj" />
+    <ProjectReference Include="..\..\ThridParty\Ghost.DXC\Ghost.DXC.csproj" />
     <ProjectReference Include="..\..\ThridParty\Ghost.Nvtt\Ghost.Nvtt.csproj" />
   </ItemGroup>
 

src/Editor/Ghost.Editor.Core/Services/DXCShaderCompiler.cs

@@ -0,0 +1,453 @@
+using Ghost.Core;
+using Ghost.Core.Graphics;
+using Ghost.Graphics.D3D12.Utilities;
+using Ghost.Graphics.RHI;
+using Misaki.HighPerformance.LowLevel;
+using Misaki.HighPerformance.LowLevel.Buffer;
+using Misaki.HighPerformance.LowLevel.Collections;
+using Misaki.HighPerformance.Utilities;
+using System.IO.Hashing;
+using System.Runtime.InteropServices;
+using System.Text;
+using Ghost.DXC;
+
+using static Ghost.DXC.UUID;
+using System.Runtime.CompilerServices;
+
+namespace Ghost.Graphics.Core;
+
+internal sealed partial class DXCShaderCompiler
+{
+    private static string GetProfileString(ShaderStage stage, ShaderModel version)
+    {
+        return (stage, version) switch
+        {
+            (ShaderStage.TaskShader, ShaderModel.SM_6_6) => "as_6_6",
+            (ShaderStage.PixelShader, ShaderModel.SM_6_6) => "ps_6_6",
+            (ShaderStage.MeshShader, ShaderModel.SM_6_6) => "ms_6_6",
+            (ShaderStage.ComputeShader, ShaderModel.SM_6_6) => "cs_6_6",
+            (ShaderStage.TaskShader, ShaderModel.SM_6_7) => "as_6_7",
+            (ShaderStage.PixelShader, ShaderModel.SM_6_7) => "ps_6_7",
+            (ShaderStage.MeshShader, ShaderModel.SM_6_7) => "ms_6_7",
+            (ShaderStage.ComputeShader, ShaderModel.SM_6_7) => "cs_6_7",
+            (ShaderStage.TaskShader, ShaderModel.SM_6_8) => "as_6_8",
+            (ShaderStage.PixelShader, ShaderModel.SM_6_8) => "ps_6_8",
+            (ShaderStage.MeshShader, ShaderModel.SM_6_8) => "ms_6_8",
+            (ShaderStage.ComputeShader, ShaderModel.SM_6_8) => "cs_6_8",
+            _ => throw new ArgumentOutOfRangeException(nameof(stage), "Unsupported shader stage or compiler version")
+        };
+    }
+
+    private static string GetOptimizeLevelString(CompilerOptimizeLevel level)
+    {
+        return level switch
+        {
+            CompilerOptimizeLevel.O0 => "-O0",
+            CompilerOptimizeLevel.O1 => "-O1",
+            CompilerOptimizeLevel.O2 => "-O2",
+            CompilerOptimizeLevel.O3 => "-O3",
+            _ => throw new ArgumentOutOfRangeException(nameof(level), "Unsupported optimization level")
+        };
+    }
+
+    private static List<string> GetCompilerArguments(ref readonly ShaderCompilationConfig config)
+    {
+        var argsArray = new List<string>
+        {
+            "-T", GetProfileString(config.stage, config.model),   // Target profile (ms_6_6, ps_6_6)
+            "-E", config.entryPoint,                                    // Entry point
+            "-HV", "2021",                                              // HLSL version 2021
+            "-enable-16bit-types",                                      // Enable 16-bit types
+            GetOptimizeLevelString(config.optimizeLevel),         // Optimization level
+        };
+
+        foreach (var define in config.defines)
+        {
+            argsArray.Add("-D");
+            argsArray.Add(define);
+        }
+
+        if (config.stage == ShaderStage.TaskShader
+            || config.stage == ShaderStage.MeshShader
+            || config.stage == ShaderStage.PixelShader)
+        {
+            argsArray.Add("-D");
+            argsArray.Add("__GRAPHICS__");
+        }
+        else if (config.stage == ShaderStage.ComputeShader)
+        {
+            argsArray.Add("-D");
+            argsArray.Add("__COMPUTE__");
+        }
+
+        if (!config.options.HasFlag(CompilerOption.KeepDebugInfo))
+        {
+            argsArray.Add("-Qstrip_debug");
+        }
+
+        if (!config.options.HasFlag(CompilerOption.KeepReflections))
+        {
+            argsArray.Add("-Qstrip_reflect");
+        }
+
+        if (config.options.HasFlag(CompilerOption.WarnAsError))
+        {
+            argsArray.Add("-WX");
+        }
+
+        if (config.options.HasFlag(CompilerOption.SpirvCrossCompile))
+        {
+            argsArray.Add("-spirv");
+        }
+
+        argsArray.Add("-rootsig-define");
+        argsArray.Add("GLOBAL_BINDLESS_SIG");
+
+        return argsArray;
+    }
+
+    private static Result<string, Error> BuildFinalShaderCode(string shaderPath, ReadOnlySpan<string> includes, string? injectedCode)
+    {
+        string shaderCode;
+        if (shaderPath == "hlsl_block")
+        {
+            if (string.IsNullOrEmpty(injectedCode))
+            {
+                return Error.InvalidArgument;
+            }
+
+            shaderCode = string.Empty;
+        }
+        else
+        {
+            if (!File.Exists(shaderPath))
+            {
+                return Error.NotFound;
+            }
+
+            shaderCode = File.ReadAllText(shaderPath);
+        }
+
+        var sb = new StringBuilder();
+        foreach (var includePath in includes)
+        {
+            sb.AppendLine($"#include \"{includePath}\"");
+        }
+
+        if (!string.IsNullOrEmpty(injectedCode))
+        {
+            sb.AppendLine($"#line 0 \"injected_code\"");
+            sb.AppendLine(injectedCode);
+        }
+
+        if (!string.IsNullOrEmpty(shaderCode))
+        {
+            sb.AppendLine($"#line 0 \"{shaderPath}\"");
+            sb.AppendLine(shaderCode);
+        }
+
+        return sb.ToString();
+    }
+}
+
+internal sealed unsafe partial class DXCShaderCompiler : IShaderCompiler
+{
+    private UniquePtr<IDxcCompiler3> _compiler;
+    private UniquePtr<IDxcUtils> _utils;
+
+    // NOTE: This is just a temporary cache for compiled shader code. We will implement a proper disk cache later.
+    private readonly Dictionary<Key64<ShaderCompileResult>, ShaderCompileResult> _compiledResults;
+
+    private bool _disposed;
+
+    public DXCShaderCompiler()
+    {
+        IDxcCompiler3* pCompiler = default;
+        IDxcUtils* pUtils = default;
+        var hr = Api.DxcCreateInstance((Guid*)Unsafe.AsPointer(in Api.CLSID_DxcCompiler), __uuidof(pCompiler), (void**)&pCompiler);
+        if (hr < 0)
+        {
+            throw new InvalidOperationException($"Failed to create DXC compiler instance. HRESULT: 0x{hr:X8}");
+        }
+
+        hr = Api.DxcCreateInstance((Guid*)Unsafe.AsPointer(in Api.CLSID_DxcUtils), __uuidof(pUtils), (void**)&pUtils);
+        if (hr < 0)
+        {
+            pCompiler->Release();
+            throw new InvalidOperationException($"Failed to create DXC utils instance. HRESULT: 0x{hr:X8}");
+        }
+
+        _compiler.Attach(pCompiler);
+        _utils.Attach(pUtils);
+
+        _compiledResults = new Dictionary<Key64<ShaderCompileResult>, ShaderCompileResult>();
+    }
+
+    ~DXCShaderCompiler()
+    {
+        Dispose();
+    }
+
+    public Result<Key64<ShaderCompileResult>> Compile(ref readonly ShaderCompilationConfig config)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+
+        IDxcIncludeHandler* includeHandler = default;
+        IDxcBlobEncoding* sourceBlob = default;
+        try
+        {
+            var hr = _utils.Get()->CreateDefaultIncludeHandler(&includeHandler);
+            if (hr < 0)
+            {
+                return Result.Failure($"Failed to create default include handler. HRESULT: 0x{hr:X8}");
+            }
+
+            fixed (byte* pCode = Encoding.UTF8.GetBytes(config.shaderCode))
+            {
+                var sizeInBytes = Encoding.UTF8.GetByteCount(config.shaderCode);
+                hr = _utils.Get()->CreateBlobFromPinned(pCode, (uint)sizeInBytes, Api.DXC_CP_UTF8, &sourceBlob);
+                if (hr < 0)
+                {
+                    return Result.Failure($"Failed to create blob from shader code. HRESULT: 0x{hr:X8}");
+                }
+            }
+
+            var argsArray = GetCompilerArguments(in config);
+            var argPtrs = stackalloc char*[argsArray.Count];
+            for (var i = 0; i < argsArray.Count; i++)
+            {
+                argPtrs[i] = (char*)Marshal.StringToHGlobalUni(argsArray[i]);
+            }
+
+            IDxcResult* result = default;
+            IDxcBlob* bytecodeBlob = default;
+            
+            try
+            {
+                // Compile shader
+                var buffer = new DxcBuffer
+                {
+                    Ptr = sourceBlob->GetBufferPointer(),
+                    Size = sourceBlob->GetBufferSize(),
+                    Encoding = Api.DXC_CP_UTF8
+                };
+
+                hr = _compiler.Get()->Compile(&buffer, argPtrs, (uint)argsArray.Count, includeHandler, __uuidof(result), (void**)&result);
+                if (hr < 0)
+                {
+                    return Result.Failure($"Failed to compile shader. HRESULT: 0x{hr:X8}");
+                }
+
+                // Check compilation result
+                int hrStatus;
+                result->GetStatus(&hrStatus);
+                if (hrStatus < 0)
+                {
+                    // Get error messages
+                    IDxcBlobEncoding* pErrorBlob = default;
+                    result->GetErrorBuffer(&pErrorBlob);
+
+                    if (pErrorBlob != null)
+                    {
+                        var errorMessage = Marshal.PtrToStringUTF8((IntPtr)pErrorBlob->GetBufferPointer());
+                        pErrorBlob->Release();
+
+                        return Result.Failure($"DXC shader compilation failed:\n{errorMessage}");
+                    }
+                    else
+                    {
+                        return Result.Failure("DXC shader compilation failed with unknown error.");
+                    }
+                }
+
+                // Get compiled bytecode
+                hr = result->GetResult(&bytecodeBlob);
+                if (hr < 0)
+                {
+                    return Result.Failure($"Failed to get compiled shader bytecode. HRESULT: 0x{hr:X8}");
+                }
+
+                var bytecodeSize = bytecodeBlob->GetBufferSize();
+                var bytecode = new UnsafeArray<byte>((int)bytecodeSize, Allocator.Persistent);
+
+                NativeMemory.Copy(bytecodeBlob->GetBufferPointer(), bytecode.GetUnsafePtr(), (nuint)bytecodeSize);
+
+                var compileResult = new ShaderCompileResult
+                {
+                    bytecode = bytecode,
+                    hashCode = XxHash64.HashToUInt64(bytecode)
+                };
+
+                _compiledResults[compileResult.hashCode] = compileResult;
+                return new Key64<ShaderCompileResult>(compileResult.hashCode);
+            }
+            finally
+            {
+                if (result != null)
+                {
+                    result->Release();
+                }
+
+                if (bytecodeBlob != null)
+                {
+                    bytecodeBlob->Release();
+                }
+
+                for (var i = 0; i < argsArray.Count; i++)
+                {
+                    Marshal.FreeHGlobal((nint)argPtrs[i]);
+                }
+            }
+        }
+        finally
+        {
+            if (includeHandler != null)
+            {
+                includeHandler->Release();
+            }
+
+            if (sourceBlob != null)
+            {
+                sourceBlob->Release();
+            }
+        }
+    }
+
+    public Result<GraphicsCompiledResult> CompilePass(ref readonly PassDescriptor descriptor, ref readonly ShaderCompilationConfig additionalConfig, ref readonly LocalKeywordSet keywords)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+
+        string[] fullDefines;
+        var totalDefineCount = descriptor.defines.Length + additionalConfig.defines.Length;
+        if (totalDefineCount == 0)
+        {
+            fullDefines = Array.Empty<string>();
+        }
+        else
+        {
+            fullDefines = new string[totalDefineCount];
+            descriptor.defines.CopyTo(fullDefines);
+            additionalConfig.defines.CopyTo(fullDefines.AsSpan(descriptor.defines.Length));
+        }
+
+        Key64<ShaderCompileResult> tsResult = default;
+        var asCode = descriptor.amplificationShaderCode;
+        if (asCode.IsCreated)
+        {
+            var config = new ShaderCompilationConfig
+            {
+                defines = fullDefines,
+                shaderCode = asCode.code,
+                entryPoint = asCode.entryPoint,
+                stage = ShaderStage.TaskShader,
+                model = additionalConfig.model,
+                optimizeLevel = additionalConfig.optimizeLevel,
+                options = additionalConfig.options,
+            };
+
+            var result = Compile(ref config);
+            if (result.IsFailure)
+            {
+                return Result.Failure(result.Message);
+            }
+
+            tsResult = result.Value;
+        }
+
+        Key64<ShaderCompileResult> msResult;
+        var msCode = descriptor.meshShaderCode;
+        if (msCode.IsCreated)
+        {
+            var config = new ShaderCompilationConfig
+            {
+                defines = fullDefines,
+                shaderCode = msCode.code,
+                entryPoint = msCode.entryPoint,
+                stage = ShaderStage.MeshShader,
+                model = additionalConfig.model,
+                optimizeLevel = additionalConfig.optimizeLevel,
+                options = additionalConfig.options,
+            };
+
+            var result = Compile(ref config);
+            if (result.IsFailure)
+            {
+                return Result.Failure(result.Message);
+            }
+
+            msResult = result.Value;
+        }
+        else
+        {
+            return Result.Failure("Mesh shader expected.");
+        }
+
+        Key64<ShaderCompileResult> psResult;
+        var psCode = descriptor.pixelShaderCode;
+        if (psCode.IsCreated)
+        {
+            var config = new ShaderCompilationConfig
+            {
+                defines = fullDefines,
+                shaderCode = psCode.code,
+                entryPoint = psCode.entryPoint,
+                stage = ShaderStage.PixelShader,
+                model = additionalConfig.model,
+                optimizeLevel = additionalConfig.optimizeLevel,
+                options = additionalConfig.options,
+            };
+
+            var result = Compile(ref config);
+            if (result.IsFailure)
+            {
+                return Result.Failure(result.Message);
+            }
+
+            psResult = result.Value;
+        }
+        else
+        {
+            return Result.Failure("Pixel shader expected.");
+        }
+
+        var compiled = new GraphicsCompiledResult
+        {
+            tsResultHash = tsResult,
+            msResultHash = msResult,
+            psResultHash = psResult,
+        };
+
+        return compiled;
+    }
+
+    public Result<ShaderCompileResult, Error> GetCompiledCache(Key64<ShaderCompileResult> key)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+
+        if (_compiledResults.TryGetValue(key, out var compiledResult))
+        {
+            return compiledResult;
+        }
+
+        return Error.NotFound;
+    }
+
+    public void Dispose()
+    {
+        if (_disposed)
+        {
+            return;
+        }
+
+        foreach (var kvp in _compiledResults)
+        {
+            kvp.Value.Dispose();
+        }
+
+        _compiler.Get()->Release();
+        _utils.Get()->Release();
+
+        _disposed = true;
+        GC.SuppressFinalize(this);
+    }
+}

src/GhostEngine.slnx

@@ -15,6 +15,7 @@
     </Project>
   </Folder>
   <Folder Name="/ThridParty/">
+    <Project Path="ThridParty/Ghost.DXC/Ghost.DXC.csproj" />
     <Project Path="ThridParty/Ghost.FMOD/Ghost.FMOD.csproj" />
     <Project Path="ThridParty/Ghost.MeshOptimizer/Ghost.MeshOptimizer.csproj" />
     <Project Path="ThridParty/Ghost.Nvtt/Ghost.Nvtt.csproj" />

src/Runtime/Ghost.Core/Graphics/GenerateHLSLAttribute.cs

@@ -0,0 +1,36 @@
+namespace Ghost.Core.Graphics;
+
+[AttributeUsage(AttributeTargets.Struct)]
+public class GenerateShaderPropertyAttribute : Attribute
+{
+    public GenerateShaderPropertyAttribute(string shaderName, string? name = null)
+    {
+    }
+}
+
+[AttributeUsage(AttributeTargets.Field)]
+public class GenerateAsHLSLTypeAttribute : Attribute
+{
+    public GenerateAsHLSLTypeAttribute(string hlslTypeName)
+    {
+    }
+}
+
+public enum PackingRules
+{
+    Exact,
+    Aligned,
+}
+
+[AttributeUsage(AttributeTargets.Struct | AttributeTargets.Enum)]
+public class GenerateHLSLAttribute : Attribute
+{
+    private readonly PackingRules _packingRules;
+    private readonly string? _outputSource;
+
+    public GenerateHLSLAttribute(PackingRules packingRules, string? outputSource)
+    {
+        _packingRules = packingRules;
+        _outputSource = outputSource;
+    }
+}

src/Runtime/Ghost.Core/Graphics/ShaderDescriptor.cs

@@ -14,12 +14,12 @@ public enum KeywordSpace
     Global,
 }
 
-public struct ShaderEntryPoint
+public struct ShaderCode
 {
-    public string entry;
-    public string shader;
+    public string code;
+    public string entryPoint;
 
-    public readonly bool IsCreated => !string.IsNullOrEmpty(entry) && !string.IsNullOrEmpty(shader);
+    public readonly bool IsCreated => !string.IsNullOrEmpty(code) && !string.IsNullOrEmpty(entryPoint);
 }
 
 public struct KeywordsGroup
@@ -35,35 +35,29 @@ public struct PassDescriptor
     public ulong identifier;
     public string name;
 
-    public string? hlsl;
-    public ShaderEntryPoint taskShader;
-    public ShaderEntryPoint meshShader;
-    public ShaderEntryPoint pixelShader;
+    public ShaderCode amplificationShaderCode;
+    public ShaderCode meshShaderCode;
+    public ShaderCode pixelShaderCode;
     public string[] defines;
-    public string[] includes;
     public KeywordsGroup[] keywords;
     public PipelineState localPipeline;
 }
 
 public class GraphicsShaderDescriptor
 {
-    public string name = string.Empty;
-    public string propertiesCode = string.Empty;
-    public uint propertyBufferSize;
-    public ShaderModel shaderModel;
-    public PassDescriptor[] passes = Array.Empty<PassDescriptor>();
+    public required string name = string.Empty;
+    public required uint propertyBufferSize;
+    public required ShaderModel shaderModel;
+    public required PassDescriptor[] passes = Array.Empty<PassDescriptor>();
 }
 
 public class ComputeShaderDescriptor
 {
-    public ulong identifier;
-    public string name = string.Empty;
-    public string propertiesCode = string.Empty;
-    public uint propertyBufferSize;
-    public string? hlsl;
-    public ShaderModel shaderModel;
-    public string[] defines = Array.Empty<string>();
-    public string[] includes = Array.Empty<string>();
-    public KeywordsGroup[] keywords = Array.Empty<KeywordsGroup>();
-    public ShaderEntryPoint[] entryPoints = Array.Empty<ShaderEntryPoint>();
+    public required ulong identifier;
+    public required string name = string.Empty;
+    public required uint propertyBufferSize;
+    public required ShaderModel shaderModel;
+    public required ShaderCode[] shaderCodes;
+    public required string[] defines;
+    public required KeywordsGroup[] keywords;
 }

src/Runtime/Ghost.Core/Result.cs

@@ -433,4 +433,41 @@ public static class ResultExtensions
 
         return func(result.Value);
     }
-}
+
+    public static void Match(this Result result, Action onSuccess, Action<string?> onFailure)
+    {
+        if (result.IsSuccess)
+        {
+            onSuccess();
+        }
+        else
+        {
+            onFailure(result.Message);
+        }
+    }
+
+    public static U Match<T, U>(this Result<T> result, Func<T, U> onSuccess, Func<string?, U> onFailure)
+    {
+        if (result.IsSuccess)
+        {
+            return onSuccess(result.Value);
+        }
+        else
+        {
+            return onFailure(result.Message);
+        }
+    }
+
+    public static U Match<T, U, E>(this Result<T, E> result, Func<T, U> onSuccess, Func<E, U> onFailure)
+        where E : struct, Enum
+    {
+        if (result.IsSuccess)
+        {
+            return onSuccess(result.Value);
+        }
+        else
+        {
+            return onFailure(result.Error);
+        }
+    }
+}

src/Runtime/Ghost.Engine/Common.cs

@@ -1,6 +1,6 @@
 namespace Ghost.Engine;
 
-public enum ShadowCastingMode
+public enum ShadowCastingMode : uint
 {
     Off,
     On,

src/Runtime/Ghost.Engine/EngineCore.cs

@@ -1,3 +1,4 @@
+using Ghost.Core.Graphics;
 using Ghost.Entities;
 using Ghost.Graphics;
 using Misaki.HighPerformance.Jobs;

src/Runtime/Ghost.Engine/RenderPipeline/GhostRenderPipeline.cs

@@ -1,12 +1,35 @@
+using Ghost.Core;
 using Ghost.Graphics;
 using Ghost.Graphics.Core;
+using Ghost.Graphics.RenderGraphModule;
+using Ghost.Graphics.RHI;
+using Misaki.HighPerformance.LowLevel.Utilities;
+using Misaki.HighPerformance.Mathematics;
+using System.Diagnostics;
 
 namespace Ghost.Engine.RenderPipeline;
 
 internal class GhostRenderPipeline : IRenderPipeline
 {
+    private struct AddInstanceData
+    {
+        public float4x4 localToWorld;
+        public uint instanceId;
+        public uint meshBuffer;
+        public uint materialPalette;
+        public uint renderingLayerMask;
+        public uint shadowCastingMode;
+    }
+
+    private struct RemoveInstanceData
+    {
+        public uint instanceId;
+        public uint swapWithInstanceId;
+    }
+
     private readonly RenderSystem _renderSystem;
 
+    private readonly RenderGraph _renderGraph;
     private readonly GPUScene _gpuScene;
 
     public GPUScene GPUScene => _gpuScene;
@@ -14,9 +37,90 @@ internal class GhostRenderPipeline : IRenderPipeline
     public GhostRenderPipeline(RenderSystem renderSystem)
     {
         _renderSystem = renderSystem;
+
+        _renderGraph = new RenderGraph(renderSystem.ResourceManager, renderSystem.GraphicsEngine);
         _gpuScene = new GPUScene(renderSystem.GraphicsEngine.ResourceAllocator, renderSystem.GraphicsEngine.ResourceDatabase, 102_400u); // 102.4k objects should be enough for now
     }
 
+    private static unsafe Handle<GPUBuffer> CreateAddInstanceBuffer(GhostRenderPayload ghostPayload, ResourceManager resourceManager, IResourceDatabase resourceDatabase)
+    {
+        if (!ghostPayload.AddRequest.IsEmpty)
+        {
+            var addDesc = new BufferDesc
+            {
+                Size = (nuint)ghostPayload.AddRequest.Count * MemoryUtility.SizeOf<AddInstanceData>(),
+                Stride = (uint)MemoryUtility.SizeOf<AddInstanceData>(),
+                Usage = BufferUsage.Structured | BufferUsage.ShaderResource,
+                HeapType = HeapType.Upload
+            };
+
+            var addBuffer = resourceManager.CreateTransientBuffer(in addDesc, "Add Instance Buffer");
+            var pAddData = (AddInstanceData*)resourceDatabase.MapResource(addBuffer.AsResource(), 0, null);
+
+            var i = 0;
+            while (ghostPayload.AddRequest.TryDequeue(out var addRequest))
+            {
+                var (mesh, error) = resourceManager.GetMeshReference(addRequest.meshInstance.mesh);
+                if (error.IsFailure)
+                {
+                    Debug.Fail($"Failed to get mesh reference for mesh instance with ID {addRequest.instanceId}");
+                    continue;
+                }
+
+                pAddData[i] = new AddInstanceData
+                {
+                    localToWorld = addRequest.localToWorld,
+                    instanceId = addRequest.instanceId,
+                    meshBuffer = resourceDatabase.GetBindlessIndex(mesh.Get().MeshDataBuffer.AsResource()),
+                    materialPalette = (uint)addRequest.meshInstance.materialPalette.Value,
+                    renderingLayerMask = addRequest.meshInstance.renderingLayerMask,
+                    shadowCastingMode = (uint)addRequest.meshInstance.shadowCastingMode
+                };
+
+                i++;
+            }
+
+            resourceDatabase.UnmapResource(addBuffer.AsResource(), 0, null);
+            return addBuffer;
+        }
+
+        return default;
+    }
+
+    private static unsafe Handle<GPUBuffer> CreateRemoveInstanceBuffer(GhostRenderPayload ghostPayload, ResourceManager resourceManager, IResourceDatabase resourceDatabase)
+    {
+        if (!ghostPayload.RemoveRequest.IsEmpty)
+        {
+            var addDesc = new BufferDesc
+            {
+                Size = (nuint)ghostPayload.AddRequest.Count * MemoryUtility.SizeOf<RemoveInstanceData>(),
+                Stride = (uint)MemoryUtility.SizeOf<RemoveInstanceData>(),
+                Usage = BufferUsage.Structured | BufferUsage.ShaderResource,
+                HeapType = HeapType.Upload
+            };
+
+            var removeBuffer = resourceManager.CreateTransientBuffer(in addDesc, "Remove Instance Buffer");
+            var pRemoveData = (RemoveInstanceData*)resourceDatabase.MapResource(removeBuffer.AsResource(), 0, null);
+
+            var i = 0;
+            while (ghostPayload.RemoveRequest.TryDequeue(out var removeRequest))
+            {
+                pRemoveData[i] = new RemoveInstanceData
+                {
+                    instanceId = removeRequest.instanceId,
+                    swapWithInstanceId = removeRequest.swapWithInstanceId
+                };
+
+                i++;
+            }
+
+            resourceDatabase.UnmapResource(removeBuffer.AsResource(), 0, null);
+            return removeBuffer;
+        }
+
+        return default;
+    }
+
     public void Render(RenderContext ctx, int frameIndex, IRenderPayload payload)
     {
         var ghostPayload = (GhostRenderPayload)payload;
@@ -26,15 +130,21 @@ internal class GhostRenderPipeline : IRenderPipeline
 
         foreach (ref readonly var request in ghostPayload.RenderRequests)
         {
-            if (!RenderPipelineUtility.GetViewAndProjectionMatrices(_renderSystem, in request, out var view, out var projection, out var screenSize))
+            if (!RenderPipelineUtility.GetVPMatrices(_renderSystem, in request, out var view, out var projection, out var screenSize))
             {
                 continue;
             }
+
+            var addBuffer = CreateAddInstanceBuffer(ghostPayload, resourceManager, resourceDatabase);
+            var removeBuffer = CreateRemoveInstanceBuffer(ghostPayload, resourceManager, resourceDatabase);
+
+
         }
     }
 
     public void Dispose()
     {
-        throw new NotImplementedException();
+        _renderGraph.Dispose();
+        _gpuScene.Dispose();
     }
 }

src/Runtime/Ghost.Generator/ShaderPropertiesGenerator.cs

@@ -191,7 +191,7 @@ struct {info.Name}
                 codeBuilder.Clear();
 
                 var typeFullName = info.TypeSymbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
-                registerBuilder.AppendLine($@"        global::Ghost.Core.Graphics.ShaderPropertiesRegistry.Register(""{info.ShaderName}"", {typeFullName}.HLSL_SOURCE, (uint)sizeof({typeFullName}));");
+                registerBuilder.AppendLine($@"        global::Ghost.DSL.ShaderPropertiesRegistry.Register(""{info.ShaderName}"", {typeFullName}.HLSL_SOURCE, (uint)sizeof({typeFullName}));");
             }
 
             var registerTypeName = "g_shaderproperty_registeration";

src/Runtime/Ghost.Graphics.D3D12/D3D12GraphicsEngine.cs

@@ -3,44 +3,15 @@
 #endif
 
 using Ghost.Core;
-using Ghost.Graphics.Core;
 using Ghost.Graphics.RHI;
 using Misaki.HighPerformance.Utilities;
 using System.Diagnostics;
 using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Runtime.Loader;
-using TerraFX.Interop.DirectX;
 
 namespace Ghost.Graphics.D3D12;
 
 public static class D3D12GraphicsEngineFactory
 {
-    static D3D12GraphicsEngineFactory()
-    {
-        var currentDir = AppContext.BaseDirectory;
-        var platform = OperatingSystem.IsWindows() ? "win" :
-                       OperatingSystem.IsLinux() ? "linux" :
-                       OperatingSystem.IsMacOS() ? "osx" : "unknown";
-        var arch = Environment.Is64BitProcess ? "x64" : "x86";
-        var nativeDllDir = Path.Combine(currentDir, "runtimes", platform + "-" + arch, "native");
-
-        AssemblyLoadContext.Default.ResolvingUnmanagedDll += (assembly, libraryName) =>
-        {
-            if (libraryName == "dxcompiler")
-            {
-                NativeLibrary.TryLoad(Path.Combine(nativeDllDir, "dxil.dll"), out _);
-
-                if (NativeLibrary.TryLoad(Path.Combine(nativeDllDir, "dxcompiler.dll"), out var dxcHandle))
-                {
-                    return dxcHandle;
-                }
-            }
-
-            return IntPtr.Zero;
-        };
-    }
-
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static IGraphicsEngine Create(GraphicsEngineDesc desc)
     {
@@ -68,7 +39,6 @@ internal class D3D12GraphicsEngine : IGraphicsEngine
     private readonly D3D12DebugLayer _debugLayer;
 #endif
     private readonly D3D12RenderDevice _device;
-    private readonly DXCShaderCompiler _shaderCompiler;
     private readonly D3D12DescriptorAllocator _descriptorAllocator;
     private readonly D3D12ResourceDatabase _resourceDatabase;
     private readonly D3D12PipelineLibrary _pipelineLibrary;
@@ -81,7 +51,6 @@ internal class D3D12GraphicsEngine : IGraphicsEngine
     private bool _disposed;
 
     public IRenderDevice Device => _device;
-    public IShaderCompiler ShaderCompiler => _shaderCompiler;
     public IPipelineLibrary PipelineLibrary => _pipelineLibrary;
     public IResourceDatabase ResourceDatabase => _resourceDatabase;
     public IResourceAllocator ResourceAllocator => _resourceAllocator;
@@ -94,7 +63,6 @@ internal class D3D12GraphicsEngine : IGraphicsEngine
         _debugLayer = new D3D12DebugLayer();
 #endif
         _device = new D3D12RenderDevice();
-        _shaderCompiler = new DXCShaderCompiler();
         _descriptorAllocator = new D3D12DescriptorAllocator(_device);
 
         _resourceDatabase = new D3D12ResourceDatabase(_descriptorAllocator);
@@ -133,7 +101,7 @@ internal class D3D12GraphicsEngine : IGraphicsEngine
     {
         Debug.Assert(!_disposed);
 
-        for (int i = 0; i < _commandBufferPool.Count; i++)
+        for (var i = 0; i < _commandBufferPool.Count; i++)
         {
             if (_commandBufferPool[i].Type == type)
             {
@@ -209,7 +177,6 @@ internal class D3D12GraphicsEngine : IGraphicsEngine
         _resourceDatabase.Dispose();
 
         _descriptorAllocator.Dispose();
-        _shaderCompiler.Dispose();
         _device.Dispose();
 #if ENABLE_DEBUG_LAYER
         _debugLayer.Dispose();

src/Runtime/Ghost.Graphics.D3D12/D3D12PipelineLibrary.cs

@@ -28,7 +28,6 @@ internal struct D3D12PipelineState : IDisposable
 internal unsafe class D3D12PipelineLibrary : D3D12Object<ID3D12PipelineLibrary1>, IPipelineLibrary
 {
     private readonly D3D12RenderDevice _device;
-    private readonly D3D12ResourceDatabase _resourceDatabase;
 
     private UniquePtr<ID3D12RootSignature> _defaultRootSignature;
 
@@ -56,11 +55,10 @@ internal unsafe class D3D12PipelineLibrary : D3D12Object<ID3D12PipelineLibrary1>
         return pLibrary;
     }
 
-    public D3D12PipelineLibrary(D3D12RenderDevice device, D3D12ResourceDatabase resourceDatabase)
+    public D3D12PipelineLibrary(D3D12RenderDevice device)
         : base(CreateLibrary(device, null)) // TODO: we need to path to load the existing library from disk.
     {
         _device = device;
-        _resourceDatabase = resourceDatabase;
 
         _pipelineCache = new UnsafeHashMap<UInt128, D3D12PipelineState>(32, Allocator.Persistent);
 
@@ -82,7 +80,7 @@ internal unsafe class D3D12PipelineLibrary : D3D12Object<ID3D12PipelineLibrary1>
             {
                 ShaderRegister = 0, // b0
                 RegisterSpace = 0,  // space0
-                Num32BitValues = PushConstantsData.NUM_32BITS_VALUE
+                Num32BitValues = PushConstantsData.NUM_32BITS_VALUE // 3
             }
         };
 
@@ -139,32 +137,6 @@ internal unsafe class D3D12PipelineLibrary : D3D12Object<ID3D12PipelineLibrary1>
         fs.Write(buffer.AsSpan());
     }
 
-    private static Result ValidateReflectionData(ShaderReflectionData reflectionData)
-    {
-        if (reflectionData.ResourcesBindings.Count > RootSignatureLayout.ROOT_PARAMETER_COUNT)
-        {
-            return Result.Failure($"Shader uses more root parameters than supported ({RootSignatureLayout.ROOT_PARAMETER_COUNT}).");
-        }
-
-        if (reflectionData.ResourcesBindings.Count == 0)
-        {
-            return Result.Success();
-        }
-
-        var rootConstant = reflectionData.ResourcesBindings[0];
-        if (rootConstant.Type != ShaderInputType.ConstantBuffer)
-        {
-            return Result.Failure($"Root constant parameter must be a constant buffer.");
-        }
-
-        if (rootConstant.Size != sizeof(PushConstantsData))
-        {
-            return Result.Failure($"Root constant buffer size must be {sizeof(PushConstantsData)} bytes.");
-        }
-
-        return Result.Success();
-    }
-
     private static D3D12_DEPTH_STENCIL_DESC BuildDepthStencil(ZTest ztest, ZWrite zwrite)
     {
         var depthEnabled = ztest != ZTest.Disabled;
@@ -185,6 +157,7 @@ internal unsafe class D3D12PipelineLibrary : D3D12Object<ID3D12PipelineLibrary1>
         }
 
         var hr = pNativeObject->LoadPipeline(pKeyStr, pStreamDesc, __uuidof(pPipelineState), (void**)&pPipelineState);
+        
         if (hr == E.E_INVALIDARG)
         {
             // Pipeline not found in the library, create a new one.
@@ -204,34 +177,8 @@ internal unsafe class D3D12PipelineLibrary : D3D12Object<ID3D12PipelineLibrary1>
         return Result.Success();
     }
 
-    public Result<Key128<GraphicsPipeline>> CreateGraphicsPipeline(ref readonly GraphicsPSODescriptor descriptor, ref readonly GraphicsCompiledResult compiled)
+    public Result<Key128<GraphicsPipeline>> CreateGraphicsPipeline(ref readonly GraphicsPSODescriptor descriptor, ReadOnlySpan<byte> asByteCode, ReadOnlySpan<byte> msByteCode, ReadOnlySpan<byte> psByteCode)
     {
-        static Result ValidatePassReflectionData(ref readonly GraphicsCompiledResult compiled)
-        {
-            var msr = ValidateReflectionData(compiled.msResult.reflectionData);
-            if (msr.IsFailure)
-            {
-                return Result.Failure("Validation of mesh shader reflection data failed: " + msr.Message);
-            }
-
-            var psr = ValidateReflectionData(compiled.psResult.reflectionData);
-            if (psr.IsFailure)
-            {
-                return Result.Failure("Validation of pixel shader reflection data failed: " + psr.Message);
-            }
-
-            if (compiled.tsResult.IsCreated)
-            {
-                var tsr = ValidateReflectionData(compiled.tsResult.reflectionData);
-                if (tsr.IsFailure)
-                {
-                    return Result.Failure("Validation of task shader reflection data failed: " + tsr.Message);
-                }
-            }
-
-            return Result.Success();
-        }
-
         AssertNotDisposed();
 
         if (descriptor.RtvFormats.Length > D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT)
@@ -244,98 +191,92 @@ internal unsafe class D3D12PipelineLibrary : D3D12Object<ID3D12PipelineLibrary1>
 
         if (!_pipelineCache.ContainsKey(pipelineKey))
         {
-            var result = ValidatePassReflectionData(in compiled);
-            if (result.IsFailure)
+            fixed (byte* pASByteCode = asByteCode, pMSByteCode = msByteCode, pPSByteCode = psByteCode)
             {
-                return result;
-            }
-
-            var desc = new D3DX12_MESH_SHADER_PIPELINE_STATE_DESC
-            {
-                pRootSignature = _defaultRootSignature.Get(),
-                MS = new D3D12_SHADER_BYTECODE(compiled.msResult.bytecode.GetUnsafePtr(), (nuint)compiled.msResult.bytecode.Count),
-                PS = new D3D12_SHADER_BYTECODE(compiled.psResult.bytecode.GetUnsafePtr(), (nuint)compiled.psResult.bytecode.Count),
-                PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE,
-                SampleMask = UINT32_MAX,
-                SampleDesc = new DXGI_SAMPLE_DESC(1, 0),
-                NumRenderTargets = (uint)descriptor.RtvFormats.Length,
-                DSVFormat = descriptor.DsvFormat.ToDXGIFormat(),
-                DepthStencilState = BuildDepthStencil(descriptor.PipelineOption.ZTest, descriptor.PipelineOption.ZWrite),
-                NodeMask = 0,
-                Flags = D3D12_PIPELINE_STATE_FLAG_NONE,
-
-                BlendState = descriptor.PipelineOption.Blend switch
+                var desc = new D3DX12_MESH_SHADER_PIPELINE_STATE_DESC
                 {
-                    Blend.Opaque => D3D12Utility.D3D12_BLEND_DESC_OPAQUE,
-                    Blend.Alpha => D3D12Utility.D3D12_BLEND_DESC_ALPHA_BLEND,
-                    Blend.Additive => D3D12Utility.D3D12_BLEND_DESC_ADDITIVE,
-                    Blend.Multiply => D3D12Utility.D3D12_BLEND_DESC_MULTIPLY,
-                    Blend.PremultipliedAlpha => D3D12Utility.D3D12_BLEND_DESC_PREMULTIPLIED,
-                    _ => D3D12Utility.D3D12_BLEND_DESC_OPAQUE
-                },
-                RasterizerState = descriptor.PipelineOption.Cull switch
+                    pRootSignature = _defaultRootSignature.Get(),
+                    MS = new D3D12_SHADER_BYTECODE(pMSByteCode, (nuint)msByteCode.Length),
+                    PS = new D3D12_SHADER_BYTECODE(pPSByteCode, (nuint)psByteCode.Length),
+                    PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE,
+                    SampleMask = UINT32_MAX,
+                    SampleDesc = new DXGI_SAMPLE_DESC(1, 0),
+                    NumRenderTargets = (uint)descriptor.RtvFormats.Length,
+                    DSVFormat = descriptor.DsvFormat.ToDXGIFormat(),
+                    DepthStencilState = BuildDepthStencil(descriptor.PipelineOption.ZTest, descriptor.PipelineOption.ZWrite),
+                    NodeMask = 0,
+                    Flags = D3D12_PIPELINE_STATE_FLAG_NONE,
+
+                    BlendState = descriptor.PipelineOption.Blend switch
+                    {
+                        Blend.Opaque => D3D12Utility.D3D12_BLEND_DESC_OPAQUE,
+                        Blend.Alpha => D3D12Utility.D3D12_BLEND_DESC_ALPHA_BLEND,
+                        Blend.Additive => D3D12Utility.D3D12_BLEND_DESC_ADDITIVE,
+                        Blend.Multiply => D3D12Utility.D3D12_BLEND_DESC_MULTIPLY,
+                        Blend.PremultipliedAlpha => D3D12Utility.D3D12_BLEND_DESC_PREMULTIPLIED,
+                        _ => D3D12Utility.D3D12_BLEND_DESC_OPAQUE
+                    },
+                    RasterizerState = descriptor.PipelineOption.Cull switch
+                    {
+                        Cull.Off => D3D12Utility.D3D12_RASTERIZER_DESC_CULL_NONE,
+                        Cull.Front => D3D12Utility.D3D12_RASTERIZER_DESC_CULL_CLOCKWISE,
+                        Cull.Back => D3D12Utility.D3D12_RASTERIZER_DESC_CULL_COUNTER_CLOCKWISE,
+                        _ => D3D12Utility.D3D12_RASTERIZER_DESC_CULL_NONE
+                    },
+                };
+
+                if (asByteCode.Length != 0)
                 {
-                    Cull.Off => D3D12Utility.D3D12_RASTERIZER_DESC_CULL_NONE,
-                    Cull.Front => D3D12Utility.D3D12_RASTERIZER_DESC_CULL_CLOCKWISE,
-                    Cull.Back => D3D12Utility.D3D12_RASTERIZER_DESC_CULL_COUNTER_CLOCKWISE,
-                    _ => D3D12Utility.D3D12_RASTERIZER_DESC_CULL_NONE
-                },
-            };
+                    desc.AS = new D3D12_SHADER_BYTECODE(pASByteCode, (nuint)asByteCode.Length);
+                }
 
-            if (compiled.tsResult.IsCreated)
-            {
-                desc.AS = new D3D12_SHADER_BYTECODE(compiled.tsResult.bytecode.GetUnsafePtr(), (nuint)compiled.tsResult.bytecode.Count);
-            }
+                for (var i = 0; i < descriptor.RtvFormats.Length; i++)
+                {
+                    desc.RTVFormats[i] = descriptor.RtvFormats[i].ToDXGIFormat();
+                    desc.BlendState.RenderTarget[i].RenderTargetWriteMask = (byte)((int)descriptor.PipelineOption.ColorMask & 0x0F);
+                }
 
-            for (var i = 0; i < descriptor.RtvFormats.Length; i++)
-            {
-                desc.RTVFormats[i] = descriptor.RtvFormats[i].ToDXGIFormat();
-                desc.BlendState.RenderTarget[i].RenderTargetWriteMask = (byte)((int)descriptor.PipelineOption.ColorMask & 0x0F);
-            }
+                var meshStream = new CD3DX12_PIPELINE_MESH_STATE_STREAM(in desc);
+                var streamDesc = new D3D12_PIPELINE_STATE_STREAM_DESC
+                {
+                    pPipelineStateSubobjectStream = &meshStream,
+                    SizeInBytes = (nuint)sizeof(CD3DX12_PIPELINE_MESH_STATE_STREAM)
+                };
 
-            var meshStream = new CD3DX12_PIPELINE_MESH_STATE_STREAM(in desc);
-            var streamDesc = new D3D12_PIPELINE_STATE_STREAM_DESC
-            {
-                pPipelineStateSubobjectStream = &meshStream,
-                SizeInBytes = (nuint)sizeof(CD3DX12_PIPELINE_MESH_STATE_STREAM)
-            };
-
-            result = CreatePSO(descriptor.VariantKey, pipelineKey, &streamDesc);
-            if (result.IsFailure)
-            {
-                return result;
+                var result = CreatePSO(descriptor.VariantKey, pipelineKey, &streamDesc);
+                if (result.IsFailure)
+                {
+                    return result;
+                }
             }
         }
 
         return pipelineKey;
     }
 
-    public Result<Key128<ComputePipeline>> CreateComputePipeline(ref readonly ComputePSODescriptor descriptor, ref readonly ShaderCompileResult compiled)
+    public Result<Key128<ComputePipeline>> CreateComputePipeline(ref readonly ComputePSODescriptor descriptor, ReadOnlySpan<byte> csBytecode)
     {
         AssertNotDisposed();
 
-        var pipelineKey = RHIUtility.CreateComputePipelineKey(descriptor.VariantKey, compiled.hashCode);
+        var pipelineKey = RHIUtility.CreateComputePipelineKey(descriptor.VariantKey);
         if (!_pipelineCache.ContainsKey(pipelineKey))
         {
-            var result = ValidateReflectionData(compiled.reflectionData);
-            if (result.IsFailure)
+            fixed (byte* pCSByteCode = csBytecode)
             {
-                return result;
-            }
+                var byteCode = new D3D12_SHADER_BYTECODE(pCSByteCode, (nuint)csBytecode.Length);
+                var desc = new CD3DX12_PIPELINE_STATE_STREAM_CS(in byteCode);
 
-            var byteCode = new D3D12_SHADER_BYTECODE(compiled.bytecode.GetUnsafePtr(), (nuint)compiled.bytecode.Length);
-            var desc = new CD3DX12_PIPELINE_STATE_STREAM_CS(in byteCode);
+                var streamDesc = new D3D12_PIPELINE_STATE_STREAM_DESC
+                {
+                    pPipelineStateSubobjectStream = &desc,
+                    SizeInBytes = (nuint)sizeof(CD3DX12_PIPELINE_STATE_STREAM_CS)
+                };
 
-            var streamDesc = new D3D12_PIPELINE_STATE_STREAM_DESC
-            {
-                pPipelineStateSubobjectStream = &desc,
-                SizeInBytes = (nuint)sizeof(CD3DX12_PIPELINE_STATE_STREAM_CS)
-            };
-
-            result = CreatePSO(descriptor.VariantKey, pipelineKey, &streamDesc);
-            if (result.IsFailure)
-            {
-                return result;
+                var result = CreatePSO(descriptor.VariantKey, pipelineKey, &streamDesc);
+                if (result.IsFailure)
+                {
+                    return result;
+                }
             }
         }
 

src/Runtime/Ghost.Graphics.D3D12/DxcShaderCompiler.cs

@@ -1,548 +0,0 @@
-using Ghost.Core;
-using Ghost.Core.Graphics;
-using Ghost.Graphics.D3D12.Utilities;
-using Ghost.Graphics.RHI;
-using Misaki.HighPerformance.LowLevel;
-using Misaki.HighPerformance.LowLevel.Buffer;
-using Misaki.HighPerformance.LowLevel.Collections;
-using Misaki.HighPerformance.Utilities;
-using System.IO.Hashing;
-using System.Runtime.InteropServices;
-using System.Text;
-using TerraFX.Interop.DirectX;
-using TerraFX.Interop.Windows;
-
-using static TerraFX.Interop.DirectX.DXC;
-
-namespace Ghost.Graphics.Core;
-
-internal sealed partial class DXCShaderCompiler
-{
-    private static string GetProfileString(ShaderStage stage, ShaderModel version)
-    {
-        return (stage, version) switch
-        {
-            (ShaderStage.TaskShader, ShaderModel.SM_6_6) => "as_6_6",
-            (ShaderStage.PixelShader, ShaderModel.SM_6_6) => "ps_6_6",
-            (ShaderStage.MeshShader, ShaderModel.SM_6_6) => "ms_6_6",
-            (ShaderStage.ComputeShader, ShaderModel.SM_6_6) => "cs_6_6",
-            (ShaderStage.TaskShader, ShaderModel.SM_6_7) => "as_6_7",
-            (ShaderStage.PixelShader, ShaderModel.SM_6_7) => "ps_6_7",
-            (ShaderStage.MeshShader, ShaderModel.SM_6_7) => "ms_6_7",
-            (ShaderStage.ComputeShader, ShaderModel.SM_6_7) => "cs_6_7",
-            (ShaderStage.TaskShader, ShaderModel.SM_6_8) => "as_6_8",
-            (ShaderStage.PixelShader, ShaderModel.SM_6_8) => "ps_6_8",
-            (ShaderStage.MeshShader, ShaderModel.SM_6_8) => "ms_6_8",
-            (ShaderStage.ComputeShader, ShaderModel.SM_6_8) => "cs_6_8",
-            _ => throw new ArgumentOutOfRangeException(nameof(stage), "Unsupported shader stage or compiler version")
-        };
-    }
-
-    private static string GetOptimizeLevelString(CompilerOptimizeLevel level)
-    {
-        return level switch
-        {
-            CompilerOptimizeLevel.O0 => DXC_ARG_OPTIMIZATION_LEVEL0,
-            CompilerOptimizeLevel.O1 => DXC_ARG_OPTIMIZATION_LEVEL1,
-            CompilerOptimizeLevel.O2 => DXC_ARG_OPTIMIZATION_LEVEL2,
-            CompilerOptimizeLevel.O3 => DXC_ARG_OPTIMIZATION_LEVEL3,
-            _ => throw new ArgumentOutOfRangeException(nameof(level), "Unsupported optimization level")
-        };
-    }
-
-    private static List<string> GetCompilerArguments(ref readonly ShaderCompilationConfig config)
-    {
-        var argsArray = new List<string>
-        {
-            "-T", GetProfileString(config.stage, config.model),   // Target profile (ms_6_6, ps_6_6)
-            "-E", config.entryPoint,                                    // Entry point
-            "-HV", "2021",                                              // HLSL version 2021
-            "-enable-16bit-types",                                      // Enable 16-bit types
-            GetOptimizeLevelString(config.optimizeLevel),         // Optimization level
-        };
-
-        foreach (var define in config.defines)
-        {
-            argsArray.Add("-D");
-            argsArray.Add(define);
-        }
-
-        if (config.stage == ShaderStage.TaskShader
-            || config.stage == ShaderStage.MeshShader
-            || config.stage == ShaderStage.PixelShader)
-        {
-            argsArray.Add("-D");
-            argsArray.Add("__GRAPHICS__");
-        }
-        else if (config.stage == ShaderStage.ComputeShader)
-        {
-            argsArray.Add("-D");
-            argsArray.Add("__COMPUTE__");
-        }
-
-        if (!config.options.HasFlag(CompilerOption.KeepDebugInfo))
-        {
-            argsArray.Add("-Qstrip_debug");
-        }
-
-        if (!config.options.HasFlag(CompilerOption.KeepReflections))
-        {
-            argsArray.Add("-Qstrip_reflect");
-        }
-
-        if (config.options.HasFlag(CompilerOption.WarnAsError))
-        {
-            argsArray.Add(DXC_ARG_WARNINGS_ARE_ERRORS);
-        }
-
-        if (config.options.HasFlag(CompilerOption.SpirvCrossCompile))
-        {
-            argsArray.Add("-spirv");
-        }
-
-        return argsArray;
-    }
-
-    private static Result<string, Error> BuildFinalShaderCode(string shaderPath, ReadOnlySpan<string> includes, string? injectedCode)
-    {
-        string shaderCode;
-        if (shaderPath == "hlsl_block")
-        {
-            if (string.IsNullOrEmpty(injectedCode))
-            {
-                return Error.InvalidArgument;
-            }
-
-            shaderCode = string.Empty;
-        }
-        else
-        {
-            if (!File.Exists(shaderPath))
-            {
-                return Error.NotFound;
-            }
-
-            shaderCode = File.ReadAllText(shaderPath);
-        }
-
-        var sb = new StringBuilder();
-        foreach (var includePath in includes)
-        {
-            sb.AppendLine($"#include \"{includePath}\"");
-        }
-
-        if (!string.IsNullOrEmpty(injectedCode))
-        {
-            sb.AppendLine($"#line 0 \"injected_code\"");
-            sb.AppendLine(injectedCode);
-        }
-
-        if (!string.IsNullOrEmpty(shaderCode))
-        {
-            sb.AppendLine($"#line 0 \"{shaderPath}\"");
-            sb.AppendLine(shaderCode);
-        }
-
-        return sb.ToString();
-    }
-
-    private static ShaderInputType ToInputType(D3D_SHADER_INPUT_TYPE type)
-    {
-        return type switch
-        {
-            D3D_SHADER_INPUT_TYPE.D3D_SIT_CBUFFER => ShaderInputType.ConstantBuffer,
-            D3D_SHADER_INPUT_TYPE.D3D_SIT_TBUFFER => ShaderInputType.Texture,
-            D3D_SHADER_INPUT_TYPE.D3D_SIT_TEXTURE => ShaderInputType.Texture,
-            D3D_SHADER_INPUT_TYPE.D3D_SIT_SAMPLER => ShaderInputType.Sampler,
-            D3D_SHADER_INPUT_TYPE.D3D_SIT_UAV_RWTYPED => ShaderInputType.UAV,
-            D3D_SHADER_INPUT_TYPE.D3D_SIT_STRUCTURED => ShaderInputType.StructuredBuffer,
-            D3D_SHADER_INPUT_TYPE.D3D_SIT_BYTEADDRESS => ShaderInputType.ByteAddressBuffer,
-            D3D_SHADER_INPUT_TYPE.D3D_SIT_UAV_RWSTRUCTURED => ShaderInputType.RWStructuredBuffer,
-            D3D_SHADER_INPUT_TYPE.D3D_SIT_UAV_RWBYTEADDRESS => ShaderInputType.RWByteAddressBuffer,
-            _ => throw new ArgumentOutOfRangeException(nameof(type), "Unsupported shader input type")
-        };
-    }
-}
-
-internal sealed unsafe partial class DXCShaderCompiler : IShaderCompiler
-{
-    private UniquePtr<IDxcCompiler3> _compiler;
-    private UniquePtr<IDxcUtils> _utils;
-    // NOTE: This is just a temporary cache for compiled shader code. We will implement a proper disk cache later.
-    // TODO: This should be shader variant specific cache instead of pass specific.
-    private readonly Dictionary<ulong, GraphicsCompiledResult> _compiledResults;
-
-    private bool _disposed;
-
-    public DXCShaderCompiler()
-    {
-        // Initialize DXC _compiler.Get() and _utils.Get()
-        var dxccID = CLSID.CLSID_DxcCompiler;
-        var dxcuID = CLSID.CLSID_DxcUtils;
-
-        IDxcCompiler3* pCompiler = default;
-        IDxcUtils* pUtils = default;
-        ThrowIfFailed(DxcCreateInstance(&dxccID, __uuidof(pCompiler), (void**)&pCompiler));
-        ThrowIfFailed(DxcCreateInstance(&dxcuID, __uuidof(pUtils), (void**)&pUtils));
-
-        _compiler.Attach(pCompiler);
-        _utils.Attach(pUtils);
-
-        _compiledResults = new Dictionary<ulong, GraphicsCompiledResult>();
-    }
-
-    ~DXCShaderCompiler()
-    {
-        Dispose();
-    }
-
-    private Result<ShaderReflectionData> PerformDXCReflection(IDxcBlob* pReflectionBlob)
-    {
-        ID3D12ShaderReflection* pReflection = default;
-
-        try
-        {
-            // Create DXC _utils.Get() to parse reflection data
-            var dxcuID = CLSID.CLSID_DxcUtils;
-
-            // Create reflection interface from blob
-            var reflectionBuffer = new DxcBuffer
-            {
-                Ptr = pReflectionBlob->GetBufferPointer(),
-                Size = pReflectionBlob->GetBufferSize(),
-                Encoding = DXC_CP_ACP
-            };
-
-            ThrowIfFailed(_utils.Get()->CreateReflection(&reflectionBuffer, __uuidof(pReflection), (void**)&pReflection));
-
-            D3D12_SHADER_DESC shaderDesc;
-            ThrowIfFailed(pReflection->GetDesc(&shaderDesc));
-
-            var reflectionData = new ShaderReflectionData();
-
-            for (uint i = 0; i < shaderDesc.BoundResources; i++)
-            {
-                D3D12_SHADER_INPUT_BIND_DESC bindDesc;
-                ThrowIfFailed(pReflection->GetResourceBindingDesc(i, &bindDesc));
-
-                var resourceName = Marshal.PtrToStringUTF8((IntPtr)bindDesc.Name);
-                if (resourceName == null)
-                {
-                    return Result.Failure("Failed to get resource name from reflection data.");
-                }
-
-                var info = new ResourceBindingInfo
-                {
-                    Name = resourceName,
-                    Type = ToInputType(bindDesc.Type),
-                    BindPoint = bindDesc.BindPoint,
-                    BindCount = bindDesc.BindCount,
-                    Space = bindDesc.Space
-                };
-
-                switch (bindDesc.Type)
-                {
-                    case D3D_SHADER_INPUT_TYPE.D3D_SIT_CBUFFER:
-                    {
-                        var cbuffer = pReflection->GetConstantBufferByName(bindDesc.Name);
-                        D3D12_SHADER_BUFFER_DESC cbufferDesc;
-                        ThrowIfFailed(cbuffer->GetDesc(&cbufferDesc));
-
-                        var variables = new List<CBufferPropertyInfo>((int)cbufferDesc.Variables);
-
-                        // Now we iterate all variables for *every* cbuffer, not just b3
-                        for (uint j = 0; j < cbufferDesc.Variables; j++)
-                        {
-                            var variable = cbuffer->GetVariableByIndex(j);
-                            D3D12_SHADER_VARIABLE_DESC varDesc;
-                            variable->GetDesc(&varDesc);
-
-                            var variableName = Marshal.PtrToStringUTF8((IntPtr)varDesc.Name);
-                            if (variableName == null)
-                            {
-                                continue;
-                            }
-
-                            variables.Add(new CBufferPropertyInfo
-                            {
-                                Name = variableName,
-                                StartOffset = varDesc.StartOffset,
-                                Size = varDesc.Size
-                            });
-                        }
-
-                        info.Size = cbufferDesc.Size;
-                        info.Properties = variables;
-
-                        break;
-                    }
-
-                    // NOTE: Currently we do not support resource bindings yet, everything access through bindless heaps.
-                }
-
-                reflectionData.ResourcesBindings.Add(info);
-            }
-
-            return reflectionData;
-        }
-        finally
-        {
-            pReflection->Release();
-        }
-    }
-
-    public Result<ShaderCompileResult> Compile(ref readonly ShaderCompilationConfig config, Allocator allocator)
-    {
-        ObjectDisposedException.ThrowIf(_disposed, this);
-
-        using ComPtr<IDxcIncludeHandler> includeHandler = default;
-        using ComPtr<IDxcBlobEncoding> sourceBlob = default;
-
-        ThrowIfFailed(_utils.Get()->CreateDefaultIncludeHandler(includeHandler.GetAddressOf()));
-
-        var finalShaderCodeResult = BuildFinalShaderCode(config.shaderPath, config.includes, config.injectedCode);
-        if (finalShaderCodeResult.IsFailure)
-        {
-            return Result.Failure(finalShaderCodeResult.Error);
-        }
-
-        var finalShaderCode = finalShaderCodeResult.Value;
-        fixed (byte* pCode = System.Text.Encoding.UTF8.GetBytes(finalShaderCode))
-        {
-            var sizeInBytes = System.Text.Encoding.UTF8.GetByteCount(finalShaderCode);
-            ThrowIfFailed(_utils.Get()->CreateBlobFromPinned(pCode, (uint)sizeInBytes, DXC_CP_UTF8, sourceBlob.GetAddressOf()));
-        }
-
-        var argsArray = GetCompilerArguments(in config);
-        var argPtrs = stackalloc char*[argsArray.Count];
-        for (var i = 0; i < argsArray.Count; i++)
-        {
-            argPtrs[i] = (char*)Marshal.StringToHGlobalUni(argsArray[i]);
-        }
-
-        using ComPtr<IDxcResult> result = default;
-
-        try
-        {
-            // Compile shader
-            var buffer = new DxcBuffer
-            {
-                Ptr = sourceBlob.Get()->GetBufferPointer(),
-                Size = sourceBlob.Get()->GetBufferSize(),
-                Encoding = DXC_CP_UTF8
-            };
-
-            ThrowIfFailed(_compiler.Get()->Compile(&buffer, argPtrs, (uint)argsArray.Count, includeHandler, __uuidof(result.Get()), (void**)&result));
-
-            // Check compilation result
-            HRESULT hrStatus;
-            result.Get()->GetStatus(&hrStatus);
-            if (hrStatus.FAILED)
-            {
-                // Get error messages
-                IDxcBlobEncoding* pErrorBlob = default;
-                result.Get()->GetErrorBuffer(&pErrorBlob);
-
-                if (pErrorBlob != null)
-                {
-                    var errorMessage = Marshal.PtrToStringUTF8((IntPtr)pErrorBlob->GetBufferPointer());
-                    pErrorBlob->Release();
-
-                    return Result.Failure($"DXC shader compilation failed:\n{errorMessage}");
-                }
-                else
-                {
-                    return Result.Failure("DXC shader compilation failed with unknown error.");
-                }
-            }
-
-            // Get compiled bytecode
-            using ComPtr<IDxcBlob> bytecodeBlob = default;
-            ThrowIfFailed(result.Get()->GetResult(bytecodeBlob.GetAddressOf()));
-
-            ShaderReflectionData reflectionData = default;
-            if (config.options.HasFlag(CompilerOption.KeepReflections))
-            {
-                using ComPtr<IDxcBlob> reflection = default;
-                if (result.Get()->GetOutput(DXC_OUT_KIND.DXC_OUT_REFLECTION, __uuidof(reflection.Get()), (void**)&reflection, null).SUCCEEDED)
-                {
-                    reflectionData = PerformDXCReflection(reflection).GetValueOrDefault();
-                }
-            }
-
-            var bytecodeSize = bytecodeBlob.Get()->GetBufferSize();
-            var bytecode = new UnsafeArray<byte>((int)bytecodeSize, allocator);
-
-            NativeMemory.Copy(bytecodeBlob.Get()->GetBufferPointer(), bytecode.GetUnsafePtr(), bytecodeSize);
-
-            return new ShaderCompileResult
-            {
-                bytecode = bytecode,
-                reflectionData = reflectionData,
-                hashCode = XxHash64.HashToUInt64(bytecode)
-            };
-        }
-        finally
-        {
-            for (var i = 0; i < argsArray.Count; i++)
-            {
-                Marshal.FreeHGlobal((nint)argPtrs[i]);
-            }
-        }
-    }
-
-    public Result<GraphicsCompiledResult> CompilePass(ref readonly PassDescriptor descriptor, ref readonly ShaderCompilationConfig additionalConfig, ref readonly LocalKeywordSet keywords)
-    {
-        ObjectDisposedException.ThrowIf(_disposed, this);
-
-        string[] fullDefines;
-        var totalDefineCount = descriptor.defines.Length + additionalConfig.defines.Length;
-        if (totalDefineCount == 0)
-        {
-            fullDefines = Array.Empty<string>();
-        }
-        else
-        {
-            fullDefines = new string[totalDefineCount];
-            descriptor.defines.CopyTo(fullDefines);
-            additionalConfig.defines.CopyTo(fullDefines.AsSpan(descriptor.defines.Length));
-        }
-
-        var injectedCodeBuilder = new StringBuilder();
-        injectedCodeBuilder.AppendLine(descriptor.shader.propertiesCode);
-        injectedCodeBuilder.AppendLine(descriptor.hlsl);
-        injectedCodeBuilder.AppendLine(additionalConfig.injectedCode);
-
-        var injectedCode = injectedCodeBuilder.ToString();
-
-        ShaderCompileResult tsResult = default;
-        var tsEntry = descriptor.taskShader;
-        if (tsEntry.IsCreated)
-        {
-            var config = new ShaderCompilationConfig
-            {
-                defines = fullDefines,
-                includes = descriptor.includes,
-                shaderPath = tsEntry.shader,
-                entryPoint = tsEntry.entry,
-                injectedCode = injectedCode,
-                stage = ShaderStage.TaskShader,
-                model = additionalConfig.model,
-                optimizeLevel = additionalConfig.optimizeLevel,
-                options = additionalConfig.options,
-            };
-
-            var result = Compile(ref config, Allocator.Persistent);
-            if (result.IsFailure)
-            {
-                return Result.Failure(result.Message);
-            }
-
-            tsResult = result.Value;
-        }
-
-        ShaderCompileResult msResult;
-        var msEntry = descriptor.meshShader;
-        if (msEntry.IsCreated)
-        {
-            var config = new ShaderCompilationConfig
-            {
-                defines = fullDefines,
-                includes = descriptor.includes,
-                shaderPath = msEntry.shader,
-                entryPoint = msEntry.entry,
-                injectedCode = injectedCode,
-                stage = ShaderStage.MeshShader,
-                model = additionalConfig.model,
-                optimizeLevel = additionalConfig.optimizeLevel,
-                options = additionalConfig.options,
-            };
-
-            var result = Compile(ref config, Allocator.Persistent);
-            if (result.IsFailure)
-            {
-                return Result.Failure(result.Message);
-            }
-
-            msResult = result.Value;
-        }
-        else
-        {
-            return Result.Failure("Mesh shader expected.");
-        }
-
-        ShaderCompileResult psResult;
-        var psEntry = descriptor.pixelShader;
-        if (psEntry.IsCreated)
-        {
-            var config = new ShaderCompilationConfig
-            {
-                defines = fullDefines,
-                includes = descriptor.includes,
-                shaderPath = psEntry.shader,
-                entryPoint = psEntry.entry,
-                injectedCode = injectedCode,
-                stage = ShaderStage.PixelShader,
-                model = additionalConfig.model,
-                optimizeLevel = additionalConfig.optimizeLevel,
-                options = additionalConfig.options,
-            };
-
-            var result = Compile(ref config, Allocator.Persistent);
-            if (result.IsFailure)
-            {
-                return Result.Failure(result.Message);
-            }
-
-            psResult = result.Value;
-        }
-        else
-        {
-            return Result.Failure("Pixel shader expected.");
-        }
-
-        var compiled = new GraphicsCompiledResult
-        {
-            tsResult = tsResult,
-            msResult = msResult,
-            psResult = psResult,
-        };
-
-        var passHash = RHIUtility.CreateShaderPassKey(descriptor.identifier, compiled.HashCode);
-        var variantHash = RHIUtility.CreateShaderVariantKey(passHash, in keywords);
-
-        _compiledResults[variantHash] = compiled;
-        return compiled;
-    }
-
-    public Result<GraphicsCompiledResult, Error> LoadCompiledCache(Key64<ShaderVariant> key)
-    {
-        ObjectDisposedException.ThrowIf(_disposed, this);
-
-        if (_compiledResults.TryGetValue(key, out var compiledResult))
-        {
-            return compiledResult;
-        }
-
-        return Error.NotFound;
-    }
-
-    public void Dispose()
-    {
-        if (_disposed)
-        {
-            return;
-        }
-
-        foreach (var kvp in _compiledResults)
-        {
-            kvp.Value.Dispose();
-        }
-
-        _compiler.Dispose();
-        _utils.Dispose();
-
-        _disposed = true;
-        GC.SuppressFinalize(this);
-    }
-}

src/Runtime/Ghost.Graphics.D3D12/Ghost.Graphics.D3D12.csproj

@@ -16,15 +16,6 @@
     <IsAotCompatible>True</IsAotCompatible>
   </PropertyGroup>
 
-  <ItemGroup>
-    <Content Include="runtimes\win-x64\native\dxcompiler.dll">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </Content>
-    <Content Include="runtimes\win-x64\native\dxil.dll">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </Content>
-  </ItemGroup>
-
   <ItemGroup>
     <PackageReference Include="TerraFX.Interop.D3D12MemoryAllocator" Version="3.1.0" />
   </ItemGroup>

src/Runtime/Ghost.Graphics.RHI/IGraphicsEngine.cs

@@ -17,11 +17,6 @@ public interface IGraphicsEngine : IDisposable
         get;
     }
 
-    IShaderCompiler ShaderCompiler
-    {
-        get;
-    }
-
     IPipelineLibrary PipelineLibrary
     {
         get;

src/Runtime/Ghost.Graphics.RHI/IPipelineLibrary.cs

@@ -6,6 +6,6 @@ public interface IPipelineLibrary : IDisposable
 {
     void SaveLibraryToDisk(string filePath);
     bool HasPipelineStateObject(UInt128 key);
-    Result<Key128<GraphicsPipeline>> CreateGraphicsPipeline(ref readonly GraphicsPSODescriptor descriptor, ref readonly GraphicsCompiledResult compiled);
-    Result<Key128<ComputePipeline>> CreateComputePipeline(ref readonly ComputePSODescriptor descriptor, ref readonly ShaderCompileResult compiled);
+    Result<Key128<GraphicsPipeline>> CreateGraphicsPipeline(ref readonly GraphicsPSODescriptor descriptor, ReadOnlySpan<byte> asByteCode, ReadOnlySpan<byte> msByteCode, ReadOnlySpan<byte> psByteCode);
+    Result<Key128<ComputePipeline>> CreateComputePipeline(ref readonly ComputePSODescriptor descriptor, ReadOnlySpan<byte> csByteCode);
 }

src/Runtime/Ghost.Graphics.RHI/IShaderCompiler.cs

@@ -1,7 +1,6 @@
 using Ghost.Core;
 using Ghost.Core.Graphics;
 using Ghost.Core.Utilities;
-using Misaki.HighPerformance.LowLevel.Buffer;
 using Misaki.HighPerformance.LowLevel.Collections;
 
 namespace Ghost.Graphics.RHI;
@@ -9,7 +8,6 @@ namespace Ghost.Graphics.RHI;
 public struct ShaderCompileResult : IDisposable
 {
     public UnsafeArray<byte> bytecode;
-    public ShaderReflectionData reflectionData;
     public ulong hashCode;
 
     public readonly bool IsCreated => bytecode.IsCreated;
@@ -20,42 +18,36 @@ public struct ShaderCompileResult : IDisposable
     }
 }
 
-public struct GraphicsCompiledResult : IDisposable
+public struct GraphicsCompiledResult
 {
-    private ulong _hashCode;
+    public ulong tsResultHash;
+    public ulong msResultHash;
+    public ulong psResultHash;
 
-    public ShaderCompileResult tsResult;
-    public ShaderCompileResult msResult;
-    public ShaderCompileResult psResult;
+    public readonly ulong HashCode => Hash.Combine64(tsResultHash, msResultHash, psResultHash);
+}
 
-    public Key64<GraphicsCompiledResult> HashCode
+public unsafe struct ComputeCompileResult
+{
+    public fixed ulong resultHash[8];
+    public readonly int count;
+
+    public ulong HashCode
     {
         get
         {
-            if (_hashCode == 0)
-            {
-                _hashCode = Hash.Combine64(tsResult.hashCode, msResult.hashCode, psResult.hashCode);
-            }
-
-            return _hashCode;
+            var a = Hash.Combine64(resultHash[0], resultHash[1], resultHash[2], resultHash[3]);
+            var b = Hash.Combine64(resultHash[4], resultHash[5], resultHash[6], resultHash[7]);
+            return Hash.Combine64(a, b);
         }
     }
-
-    public void Dispose()
-    {
-        tsResult.Dispose();
-        msResult.Dispose();
-        psResult.Dispose();
-    }
 }
 
 public ref struct ShaderCompilationConfig
 {
     public ReadOnlySpan<string> defines;
-    public ReadOnlySpan<string> includes;
-    public string shaderPath;
+    public string shaderCode;
     public string entryPoint;
-    public string? injectedCode;
     public ShaderStage stage;
     public ShaderModel model;
     public CompilerOptimizeLevel optimizeLevel;
@@ -154,7 +146,7 @@ public readonly struct ShaderReflectionData
 
 public interface IShaderCompiler : IDisposable
 {
-    Result<ShaderCompileResult> Compile(ref readonly ShaderCompilationConfig config, Allocator allocator);
+    Result<Key64<ShaderCompileResult>> Compile(ref readonly ShaderCompilationConfig config);
     Result<GraphicsCompiledResult> CompilePass(ref readonly PassDescriptor descriptor, ref readonly ShaderCompilationConfig additionalConfig, ref readonly LocalKeywordSet keywords);
-    Result<GraphicsCompiledResult, Error> LoadCompiledCache(Key64<ShaderVariant> key);
+    Result<ShaderCompileResult, Error> GetCompiledCache(Key64<ShaderCompileResult> key);
 }

src/Runtime/Ghost.Graphics.RHI/RHIUtility.cs

@@ -156,11 +156,10 @@ public static class RHIUtility
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static Key64<ShaderVariant> CreateShaderVariantKey(Key64<ShaderPass> passKey, ref readonly LocalKeywordSet keywords)
+    public static Key64<ShaderVariant> CreateShaderVariantKey(ulong passKey, ref readonly LocalKeywordSet keywords)
     {
-        var passHash = passKey.Value;
         var keywordHash = keywords.GetHash64();
-        return new Key64<ShaderVariant>(Hash.Combine64(passHash, keywordHash));
+        return new Key64<ShaderVariant>(Hash.Combine64(passKey, keywordHash));
     }
 
     public static unsafe Key128<GraphicsPipeline> CreateGraphicsPipelineKey(Key64<ShaderVariant> shaderVariantKey, PipelineState pipelineState, PassPipelineHash passKey)
@@ -192,10 +191,10 @@ public static class RHIUtility
         return new Key128<GraphicsPipeline>(new UInt128(hi, lo));
     }
 
-    public static Key128<ComputePipeline> CreateComputePipelineKey(Key64<ShaderVariant> shaderVariantKey, ulong compiledHash)
+    public static Key128<ComputePipeline> CreateComputePipelineKey(Key64<ShaderVariant> shaderVariantKey)
     {
         var shaderHash = shaderVariantKey.Value;
-        var stateHash = compiledHash;
+        var stateHash = ~shaderVariantKey.Value;
         // Simple XOR mix. Not as robust as the graphics pipeline key, but sufficient for compute shaders which have fewer variants.
         var hi = shaderHash ^ (stateHash + 0x9E3779B97F4A7C15ul) ^ (shaderHash * 0xD6E8FEB86659FD93ul);
         var lo = stateHash ^ (shaderHash + 0xC2B2AE3D27D4EB4Ful) ^ (stateHash * 0x165667B19E3779F9ul);

src/Runtime/Ghost.Graphics/Core/Material.cs

@@ -50,14 +50,14 @@ public struct Material : IResourceReleasable
         public PipelineState options;
     }
 
-    private Identifier<Shader> _shader;
+    private Handle<Shader> _shader;
     private UnsafeArray<PipelineOverride> _passPipelineOverride;
     private bool _isDirty;
 
     internal CBufferCache _cBufferCache;
     internal LocalKeywordSet _keywordMask;
 
-    public readonly Identifier<Shader> Shader => _shader;
+    public readonly Handle<Shader> Shader => _shader;
     public readonly bool IsDirty => _isDirty;
 
     public int ActivePassIndex
@@ -71,7 +71,7 @@ public struct Material : IResourceReleasable
         get; set;
     }
 
-    public Error SetShader(Identifier<Shader> shaderId, ResourceManager resourceManager, IResourceDatabase resourceDatabase, IResourceAllocator resourceAllocator)
+    public Error SetShader(Handle<Shader> shaderId, ResourceManager resourceManager, IResourceDatabase resourceDatabase, IResourceAllocator resourceAllocator)
     {
         if (!shaderId.IsValid)
         {

src/Runtime/Ghost.Graphics/Core/Mesh.cs

@@ -179,7 +179,7 @@ public struct Mesh : IResourceReleasable
     /// <summary>
     /// Gets the handle to the mesh data buffer on the GPU.
     /// </summary>
-    public Handle<GPUBuffer> ObjectDataBuffer
+    public Handle<GPUBuffer> MeshDataBuffer
     {
         get; internal set;
     }
@@ -364,7 +364,7 @@ public struct Mesh : IResourceReleasable
         database.ReleaseResource(MeshLetBuffer.AsResource());
         database.ReleaseResource(MeshletVerticesBuffer.AsResource());
         database.ReleaseResource(MeshletTrianglesBuffer.AsResource());
-        database.ReleaseResource(ObjectDataBuffer.AsResource());
+        database.ReleaseResource(MeshDataBuffer.AsResource());
     }
 }
 

src/Runtime/Ghost.Graphics/Core/RenderContext.cs

@@ -10,22 +10,21 @@ namespace Ghost.Graphics.Core;
 // TODO: Temporary rendering context for heap creation and data upload. We will refactor it later when we have a better understanding of the engine architecture.
 public readonly unsafe ref struct RenderContext
 {
-    private readonly IGraphicsEngine _engine;
     private readonly ResourceManager _resourceManager;
+    private readonly IGraphicsEngine _engine;
     private readonly ICommandBuffer _cmd;
 
     public ICommandBuffer CommandBuffer => _cmd;
 
-    public IShaderCompiler ShaderCompiler => _engine.ShaderCompiler;
     public ResourceManager ResourceManager => _resourceManager;
     public IResourceAllocator ResourceAllocator => _engine.ResourceAllocator;
     public IResourceDatabase ResourceDatabase => _engine.ResourceDatabase;
     public IPipelineLibrary PipelineLibrary => _engine.PipelineLibrary;
 
-    internal RenderContext(IGraphicsEngine engine, ResourceManager resourceManager, ICommandBuffer cmd)
+    internal RenderContext(ResourceManager resourceManager, IGraphicsEngine engine, ICommandBuffer cmd)
     {
-        _engine = engine;
         _resourceManager = resourceManager;
+        _engine = engine;
         _cmd = cmd;
     }
 
@@ -242,10 +241,10 @@ public readonly unsafe ref struct RenderContext
             meshletTrianglesBuffer = _engine.ResourceDatabase.GetBindlessIndex(meshData.MeshletTrianglesBuffer.AsResource()),
         };
 
-        var bufferHandle = meshData.ObjectDataBuffer.AsResource();
+        var bufferHandle = meshData.MeshDataBuffer.AsResource();
 
         TransitionBarrier(bufferHandle, false, BarrierLayout.Undefined, BarrierAccess.CopyDest, BarrierSync.Copy);
-        UploadBuffer(meshData.ObjectDataBuffer, data);
+        UploadBuffer(meshData.MeshDataBuffer, data);
         TransitionBarrier(bufferHandle, false, BarrierLayout.Undefined, BarrierAccess.ShaderResource, BarrierSync.PixelShading | BarrierSync.NonPixelShading);
     }
 

src/Runtime/Ghost.Graphics/Core/RenderRequest.cs

@@ -1,5 +1,4 @@
 using Ghost.Core;
-using Ghost.Graphics.RenderPipeline;
 using Ghost.Graphics.RHI;
 using Misaki.HighPerformance.Mathematics;
 using System.Runtime.CompilerServices;
@@ -179,22 +178,11 @@ public struct RenderView
     public RenderingLayerMask renderingLayerMask;
 }
 
-public struct RenderRequest: IDisposable
+public struct RenderRequest
 {
     public RenderView view;
 
     public int swapChainIndex;
     public Handle<GPUTexture> colorTarget;
     public Handle<GPUTexture> depthTarget;
-
-    public RenderList opaqueRenderList;
-    public RenderList transparentRenderList;
-    public RenderList shadowCasterRenderList;
-
-    public void Dispose()
-    {
-        opaqueRenderList.Dispose();
-        transparentRenderList.Dispose();
-        shadowCasterRenderList.Dispose();
-    }
 }

src/Runtime/Ghost.Graphics/Core/Shader.cs

@@ -87,8 +87,10 @@ public partial struct Shader : IResourceReleasable
     public readonly int PassCount => _shaderPasses.Count;
     public readonly uint PropertyBufferSize => _propertyBufferSize;
 
-    internal Shader(GraphicsShaderDescriptor descriptor, ref readonly GraphicsCompiledResult compiledResult)
+    internal Shader(GraphicsShaderDescriptor descriptor, ReadOnlySpan<GraphicsCompiledResult> compiledResults)
     {
+        Debug.Assert(descriptor.passes.Length == compiledResults.Length);
+
         _propertyBufferSize = descriptor.propertyBufferSize;
         _shaderPasses = new UnsafeArray<ShaderPass>(descriptor.passes.Length, Allocator.Persistent);
         _passIDToLocal = new UnsafeHashMap<int, int>(descriptor.passes.Length, Allocator.Persistent);
@@ -98,7 +100,7 @@ public partial struct Shader : IResourceReleasable
         {
             ref readonly var pass = ref descriptor.passes[i];
 
-            var passKey = RHIUtility.CreateShaderPassKey(pass.identifier, compiledResult.HashCode);
+            var passKey = RHIUtility.CreateShaderPassKey(pass.identifier, compiledResults[i].HashCode);
             var keywords = default(LocalKeywordSet);
 
             if (pass.keywords.Length > 0)
@@ -141,7 +143,7 @@ public partial struct Shader : IResourceReleasable
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    internal readonly int GetLocalKeywordIndex(int globalKeywordID)
+    internal int GetLocalKeywordIndex(int globalKeywordID)
     {
         if (_keywordIDToLocal.TryGetValue(globalKeywordID, out var localIndex))
         {
@@ -152,7 +154,7 @@ public partial struct Shader : IResourceReleasable
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public readonly int GetPassIndex(Identifier<ShaderPass> passID)
+    public int GetPassIndex(Identifier<ShaderPass> passID)
     {
         if (_passIDToLocal.TryGetValue(passID.Value, out var index))
         {
@@ -163,7 +165,7 @@ public partial struct Shader : IResourceReleasable
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public readonly int GetPassIndex(string passName)
+    public int GetPassIndex(string passName)
     {
         if (_passIDToLocal.TryGetValue(GetPassID(passName), out var index))
         {
@@ -174,13 +176,13 @@ public partial struct Shader : IResourceReleasable
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public readonly ref ShaderPass GetPassReference(int index)
+    public ref ShaderPass GetPassReference(int index)
     {
         return ref _shaderPasses[index];
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public readonly Result<ShaderPass, Error> TryGetPass(Identifier<ShaderPass> passID, out int passIndex)
+    public Result<ShaderPass, Error> TryGetPass(Identifier<ShaderPass> passID, out int passIndex)
     {
         if (_passIDToLocal.TryGetValue(passID.Value, out var index))
         {
@@ -200,25 +202,52 @@ public partial struct Shader : IResourceReleasable
     }
 }
 
-
-public unsafe partial struct ComputeShader
+public unsafe partial struct ComputeShader : IResourceReleasable
 {
     private fixed ulong _entryHash[8];
     private readonly int _entryPointCount;
     private readonly uint _propertyBufferSize;
 
+    private LocalKeywordSet _localKeywordSet;
+    private UnsafeHashMap<int, int> _keywordIDToLocal;
+
     public readonly uint PropertyBufferSize => _propertyBufferSize;
 
     internal ComputeShader(ComputeShaderDescriptor descriptor, ReadOnlySpan<ShaderCompileResult> compiledResults)
     {
-        Debug.Assert(descriptor.entryPoints.Length == compiledResults.Length);
+        Debug.Assert(descriptor.shaderCodes.Length == compiledResults.Length);
 
         _propertyBufferSize = descriptor.propertyBufferSize;
-        _entryPointCount = descriptor.entryPoints.Length;
-        for (var i = 0; i < descriptor.entryPoints.Length; i++)
+        _entryPointCount = descriptor.shaderCodes.Length;
+
+        _keywordIDToLocal = new UnsafeHashMap<int, int>(32, Allocator.Persistent);
+
+        for (var i = 0; i < descriptor.shaderCodes.Length; i++)
         {
             _entryHash[i] = Hash.Combine64(descriptor.identifier, compiledResults[i].hashCode);
         }
+
+        var localKeywordIndex = 0;
+        for (var i = 0; i < descriptor.keywords.Length; i++)
+        {
+            var group = descriptor.keywords[i];
+            if (group.keywords == null)
+            {
+                continue;
+            }
+
+            if (group.space == KeywordSpace.Local)
+            {
+                foreach (var kw in group.keywords)
+                {
+                    var kwID = Shader.GetKeywordID(kw);
+                    var idx = localKeywordIndex++;
+
+                    _localKeywordSet.SetKeyword(idx, true);
+                    _keywordIDToLocal.TryAdd(kwID, idx);
+                }
+            }
+        }
     }
 
     public ulong GetEntryHash(int entryPointIndex)
@@ -226,4 +255,20 @@ public unsafe partial struct ComputeShader
         Debug.Assert(entryPointIndex >= 0 && entryPointIndex < _entryPointCount);
         return _entryHash[entryPointIndex];
     }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    internal int GetLocalKeywordIndex(int globalKeywordID)
+    {
+        if (_keywordIDToLocal.TryGetValue(globalKeywordID, out var localIndex))
+        {
+            return localIndex;
+        }
+
+        return -1;
+    }
+
+    public void ReleaseResource(IResourceDatabase database)
+    {
+        _keywordIDToLocal.Dispose();
+    }
 }

src/Runtime/Ghost.Graphics/RenderGraphModule/RenderGraph.cs

@@ -71,6 +71,11 @@ public sealed class RenderGraph : IDisposable
         _blackboard = new RenderGraphBlackboard();
     }
 
+    public RenderGraph(ResourceManager resourceManager, IGraphicsEngine graphicsEngine)
+        : this(resourceManager, graphicsEngine.ResourceAllocator, graphicsEngine.ResourceDatabase, graphicsEngine.PipelineLibrary, graphicsEngine.ShaderCompiler)
+    {
+    }
+
     /// <summary>
     /// Resets the render graph for a new frame.
     /// </summary>

src/Runtime/Ghost.Graphics/RenderGraphModule/RenderGraphContext.cs

@@ -36,6 +36,7 @@ public interface IRasterRenderContext : IRenderGraphContext
 
 public interface IComputeRenderContext : IRenderGraphContext
 {
+    void SetActiveCompute(Handle<ComputeShader> computeShader, uint entryIndex);
     void DispatchCompute(uint3 threadGroupCount);
 }
 
@@ -141,8 +142,7 @@ internal sealed class RenderGraphContext : IUnsafeRenderContext
         var r = _resourceManager.GetMaterialReference(material);
         if (r.IsFailure)
         {
-            _activePerMaterialData = Handle<GPUBuffer>.Invalid;
-            return;
+            throw new InvalidOperationException($"Failed to get material reference for material handle {material}.");
         }
 
         ref readonly var mat = ref r.Value;
@@ -158,8 +158,8 @@ internal sealed class RenderGraphContext : IUnsafeRenderContext
             return;
         }
 
-        ref readonly var shader = ref shaderResult.Value;
-        ref readonly var pass = ref shader.GetPassReference(material.ActivePassIndex);
+        ref var shader = ref shaderResult.Value;
+        ref var pass = ref shader.GetPassReference(material.ActivePassIndex);
 
         var passPipelineHash = new PassPipelineHash(_rtvFormats, _dsvFormat);
         var materialPipeline = material.GetPassPipelineOverride(material.ActivePassIndex);
@@ -169,9 +169,9 @@ internal sealed class RenderGraphContext : IUnsafeRenderContext
         var shaderVariantKey = RHIUtility.CreateShaderVariantKey(pass.Key, in variantMask);
         var pipelineKey = RHIUtility.CreateGraphicsPipelineKey(shaderVariantKey, materialPipeline, passPipelineHash);
 
-        if (!_pipelineLibrary.HasPipeline(pipelineKey))
+        if (!_pipelineLibrary.HasPipelineStateObject(pipelineKey))
         {
-            var compiledCacheResult = _shaderCompiler.LoadCompiledCache(shaderVariantKey);
+            var compiledCacheResult = _shaderCompiler.GetCompiledCache(shaderVariantKey);
             if (compiledCacheResult.IsFailure)
             {
                 throw new InvalidOperationException("Failed to load compiled shader cache for pipeline state object creation.");
@@ -199,9 +199,7 @@ internal sealed class RenderGraphContext : IUnsafeRenderContext
         var r = _resourceManager.GetMeshReference(mesh);
         if (r.IsFailure)
         {
-            _activePerMeshData = Handle<GPUBuffer>.Invalid;
-            _activeMeshIndexCount = 0;
-            return;
+            throw new InvalidOperationException($"Failed to get mesh reference for mesh handle {mesh}.");
         }
 
         ref readonly var meshRef = ref r.Value;
@@ -210,7 +208,7 @@ internal sealed class RenderGraphContext : IUnsafeRenderContext
 
     public void SetActiveMesh(ref readonly Mesh mesh)
     {
-        _activePerMeshData = mesh.ObjectDataBuffer;
+        _activePerMeshData = mesh.MeshDataBuffer;
         _activeMeshIndexCount = mesh.IndexCount;
     }
 
@@ -239,12 +237,41 @@ internal sealed class RenderGraphContext : IUnsafeRenderContext
         _commandBuffer.DispatchMesh(threadGroupCount.x, threadGroupCount.y, threadGroupCount.z);
     }
 
+    public void SetActiveCompute(Handle<ComputeShader> computeShader, uint entryIndex)
+    {
+        var r = _resourceManager.GetComputeShaderReference(computeShader);
+        if (r.IsFailure)
+        {
+            throw new InvalidOperationException($"Failed to get compute shader reference for handle {computeShader}.");
+        }
+
+        ref var shader = ref r.Value;
+        var entryHash = shader.GetEntryHash((int)entryIndex);
+        var keywordSet = new LocalKeywordSet(); // TODO: Support keywords in compute shader.
+        var variantKey = RHIUtility.CreateShaderVariantKey(entryHash, in keywordSet);
+        var pipelineKey = RHIUtility.CreateComputePipelineKey(variantKey);
+
+        if (!_pipelineLibrary.HasPipelineStateObject(pipelineKey))
+        {
+            var compiledCacheResult = _shaderCompiler.GetCompiledCache(variantKey);
+            if (compiledCacheResult.IsFailure)
+            {
+                throw new InvalidOperationException("Failed to load compiled shader cache for pipeline state object creation.");
+            }
+            var psoDes = new ComputePSODescriptor
+            {
+                VariantKey = variantKey,
+            };
+            var compiled = compiledCacheResult.Value;
+            _pipelineLibrary.CreateComputePipeline(in psoDes, in compiled).GetValueOrThrow();
+        }
+    }
+
     public void DispatchCompute(uint3 threadGroupCount)
     {
         throw new NotImplementedException();
     }
 
-
     public ICommandBuffer GetCommandBufferUnsafe()
     {
         return _commandBuffer;

src/Runtime/Ghost.Graphics/RenderPipeline.cs

@@ -24,10 +24,9 @@ public interface IRenderPipeline : IDisposable
     void Render(RenderContext ctx, int frameIndex, IRenderPayload payload);
 }
 
-
 public static class RenderPipelineUtility
 {
-    public static bool GetViewAndProjectionMatrices(RenderSystem renderSystem, ref readonly RenderRequest request, out float4x4 view, out float4x4 projection, out uint2 screenSize)
+    public static bool GetVPMatrices(RenderSystem renderSystem, ref readonly RenderRequest request, out float4x4 view, out float4x4 projection, out uint2 screenSize)
     {
         Handle<GPUTexture> rtHandle;
         if (request.swapChainIndex < 0)

src/Runtime/Ghost.Graphics/RenderSystem.cs

@@ -2,6 +2,7 @@ using Ghost.Core;
 using Ghost.Graphics.Core;
 using Ghost.Graphics.D3D12;
 using Ghost.Graphics.RHI;
+using Ghost.Graphics.Services;
 using Misaki.HighPerformance.Mathematics;
 using System.Collections.Concurrent;
 using System.Diagnostics;
@@ -280,7 +281,7 @@ public class RenderSystem : IDisposable
                 {
                     cmd.Begin(frameResource.CommandAllocator);
 
-                    var ctx = new RenderContext(_graphicsEngine, _resourceManager, cmd);
+                    var ctx = new RenderContext(_resourceManager, _graphicsEngine, cmd);
 
                     _renderPipeline.Render(ctx, frameIndex, frameResource.RenderPayload);
                     _swapChainManager.TransitionToPresent(cmd);

src/Runtime/Ghost.Graphics/Services/ResourceManager.cs

@@ -5,7 +5,6 @@ using Ghost.Graphics.RHI;
 using Misaki.HighPerformance.LowLevel.Buffer;
 using Misaki.HighPerformance.LowLevel.Collections;
 using System.Diagnostics;
-using System.Numerics;
 
 namespace Ghost.Graphics;
 
@@ -29,11 +28,13 @@ public sealed partial class ResourceManager : IDisposable
 
     private UnsafeSlotMap<Mesh> _meshes;
     private UnsafeSlotMap<Material> _materials;
-    private UnsafeList<Shader> _shaders; // TODO: Use SlotMap?
+    private UnsafeSlotMap<Shader> _shaders;
+    private UnsafeSlotMap<ComputeShader> _computeShaders;
 
     private readonly MaterialPaletteStore _materialPalettes;
 
     private ulong _submittedFrame;
+    private int _writeLock;
 
     private bool _disposed;
 
@@ -45,7 +46,8 @@ public sealed partial class ResourceManager : IDisposable
 
         _meshes = new UnsafeSlotMap<Mesh>(64, Allocator.Persistent);
         _materials = new UnsafeSlotMap<Material>(64, Allocator.Persistent);
-        _shaders = new UnsafeList<Shader>(16, Allocator.Persistent);
+        _shaders = new UnsafeSlotMap<Shader>(16, Allocator.Persistent);
+        _computeShaders = new UnsafeSlotMap<ComputeShader>(16, Allocator.Persistent);
 
         _materialPalettes = new MaterialPaletteStore();
     }
@@ -67,6 +69,18 @@ public sealed partial class ResourceManager : IDisposable
         EndFramePool(completedFrame);
     }
 
+    public void EnterParallelRead()
+    {
+        Debug.Assert(!_disposed);
+        Volatile.Write(ref _writeLock, 1);
+    }
+
+    public void ExitParallelRead()
+    {
+        Debug.Assert(!_disposed);
+        Volatile.Write(ref _writeLock, 0);
+    }
+
     /// <summary>
     /// Creates a new mesh from the specified vertex and index data.
     /// </summary>
@@ -77,80 +91,139 @@ public sealed partial class ResourceManager : IDisposable
     {
         Debug.Assert(!_disposed);
 
-        var vertexBufferDesc = new BufferDesc
+        var spinner = new SpinWait();
+        while (Interlocked.CompareExchange(ref _writeLock, 1, 0) != 0)
         {
-            Size = (uint)(vertices.Count * sizeof(Vertex)),
-            Stride = (uint)sizeof(Vertex),
-            Usage = BufferUsage.Vertex | BufferUsage.ShaderResource | BufferUsage.Raw,
-            HeapType = HeapType.Default,
-        };
+            spinner.SpinOnce();
+        }
 
-        var indexBufferDesc = new BufferDesc
+        try
         {
-            Size = (uint)(indices.Count * sizeof(uint)),
-            Stride = sizeof(uint),
-            Usage = BufferUsage.Index | BufferUsage.ShaderResource | BufferUsage.Raw,
-            HeapType = HeapType.Default,
-        };
+            var vertexBufferDesc = new BufferDesc
+            {
+                Size = (uint)(vertices.Count * sizeof(Vertex)),
+                Stride = (uint)sizeof(Vertex),
+                Usage = BufferUsage.Vertex | BufferUsage.ShaderResource | BufferUsage.Raw,
+                HeapType = HeapType.Default,
+            };
 
-        var objectBufferDesc = new BufferDesc
+            var indexBufferDesc = new BufferDesc
+            {
+                Size = (uint)(indices.Count * sizeof(uint)),
+                Stride = sizeof(uint),
+                Usage = BufferUsage.Index | BufferUsage.ShaderResource | BufferUsage.Raw,
+                HeapType = HeapType.Default,
+            };
+
+            var objectBufferDesc = new BufferDesc
+            {
+                Size = (uint)sizeof(MeshData),
+                Stride = (uint)sizeof(MeshData),
+                Usage = BufferUsage.Raw | BufferUsage.ShaderResource,
+                HeapType = HeapType.Default,
+            };
+
+            var vertexBuffer = _resourceAllocator.CreateBuffer(in vertexBufferDesc, "VertexBuffer");
+            var indexBuffer = _resourceAllocator.CreateBuffer(in indexBufferDesc, "IndexBuffer");
+            var objectBuffer = _resourceAllocator.CreateBuffer(in objectBufferDesc, "ObjectBuffer");
+
+            var mesh = new Mesh
+            {
+                Vertices = vertices,
+                Indices = indices,
+                VertexBuffer = vertexBuffer,
+                IndexBuffer = indexBuffer,
+                MeshDataBuffer = objectBuffer,
+            };
+
+            var id = _meshes.Add(mesh, out var generation);
+            return new Handle<Mesh>(id, generation);
+        }
+        finally
         {
-            Size = (uint)sizeof(MeshData),
-            Stride = (uint)sizeof(MeshData),
-            Usage = BufferUsage.Raw | BufferUsage.ShaderResource,
-            HeapType = HeapType.Default,
-        };
-
-        var vertexBuffer = _resourceAllocator.CreateBuffer(in vertexBufferDesc, "VertexBuffer");
-        var indexBuffer = _resourceAllocator.CreateBuffer(in indexBufferDesc, "IndexBuffer");
-        var objectBuffer = _resourceAllocator.CreateBuffer(in objectBufferDesc, "ObjectBuffer");
-
-        var mesh = new Mesh
-        {
-            Vertices = vertices,
-            Indices = indices,
-            VertexBuffer = vertexBuffer,
-            IndexBuffer = indexBuffer,
-            ObjectDataBuffer = objectBuffer,
-        };
-
-        var id = _meshes.Add(mesh, out var generation);
-        return new Handle<Mesh>(id, generation);
+            Volatile.Write(ref _writeLock, 0);
+        }
     }
 
     /// <summary>
     /// Creates a new material instance using the specified shader.
     /// </summary>
     /// <param name="shader">The identifier of the shader to associate with the new material.</param>
-    /// <returns>An <see cref="Identifier{Material}"/> representing the newly created material.</returns>
-    public Handle<Material> CreateMaterial(Identifier<Shader> shader)
+    /// <returns>An <see cref="Handle{Material}"/> representing the newly created material.</returns>
+    public Handle<Material> CreateMaterial(Handle<Shader> shader)
     {
         Debug.Assert(!_disposed);
 
-        var material = new Material();
-        if (material.SetShader(shader, this, _resourceDatabase, _resourceAllocator) != Error.None)
+        var spinner = new SpinWait();
+        while (Interlocked.CompareExchange(ref _writeLock, 1, 0) != 0)
         {
-            return Handle<Material>.Invalid;
+            spinner.SpinOnce();
         }
 
-        var id = _materials.Add(material, out var generation);
-        return new Handle<Material>(id, generation);
+        try
+        {
+            var material = new Material();
+            if (material.SetShader(shader, this, _resourceDatabase, _resourceAllocator) != Error.None)
+            {
+                return Handle<Material>.Invalid;
+            }
+
+            var id = _materials.Add(material, out var generation);
+            return new Handle<Material>(id, generation);
+        }
+        finally
+        {
+            Volatile.Write(ref _writeLock, 0);
+        }
     }
 
     /// <summary>
     /// Creates a new shader and returns its unique identifier.
     /// </summary>
-    /// <returns>An <see cref="Identifier{Shader}"/> representing the newly created shader.</returns>
+    /// <returns>An <see cref="Handle{Shader}"/> representing the newly created shader.</returns>
     /// <param name="descriptor">The viewGroup containing the shader's properties and passes.</param>
-    public Identifier<Shader> CreateGraphicsShader(GraphicsShaderDescriptor descriptor, ref readonly GraphicsCompiledResult compiledResult)
+    public Handle<Shader> CreateGraphicsShader(GraphicsShaderDescriptor descriptor, ReadOnlySpan<GraphicsCompiledResult> compiledResults)
     {
         Debug.Assert(!_disposed);
 
-        var shader = new Shader(descriptor, in compiledResult);
+        var spinner = new SpinWait();
+        while (Interlocked.CompareExchange(ref _writeLock, 1, 0) != 0)
+        {
+            spinner.SpinOnce();
+        }
 
-        var id = _shaders.Count;
-        _shaders.Add(shader);
-        return new Identifier<Shader>(id);
+        try
+        {
+            var shader = new Shader(descriptor, compiledResults);
+
+            var id = _shaders.Add(shader, out var generation);
+            return new Handle<Shader>(id, generation);
+        }
+        finally
+        {
+            Volatile.Write(ref _writeLock, 0);
+        }
+    }
+
+    public Handle<ComputeShader> CreateComputeShader(ComputeShaderDescriptor descriptor, ReadOnlySpan<ShaderCompileResult> compiledResults)
+    {
+        Debug.Assert(!_disposed);
+        var spinner = new SpinWait();
+        while (Interlocked.CompareExchange(ref _writeLock, 1, 0) != 0)
+        {
+            spinner.SpinOnce();
+        }
+
+        try
+        {
+            var computeShader = new ComputeShader(descriptor, compiledResults);
+            var id = _computeShaders.Add(computeShader, out var generation);
+            return new Handle<ComputeShader>(id, generation);
+        }
+        finally
+        {
+            Volatile.Write(ref _writeLock, 0);
+        }
     }
 
     /// <summary>
@@ -309,44 +382,91 @@ public sealed partial class ResourceManager : IDisposable
     /// </summary>
     /// <param name="id">The identifier of the shader to check for existence.</param>
     /// <returns>true if a shader with the specified identifier exists; otherwise, false.</returns>
-    public bool HasShader(Identifier<Shader> id)
+    public bool HasShader(Handle<Shader> id)
     {
         Debug.Assert(!_disposed);
-        return id.Value >= 0 && id.Value < _shaders.Count;
+        return _shaders.Contains(id.ID, id.Generation);
     }
 
     /// <summary>
     /// Returns a reference to the shader associated with the specified identifier.
     /// </summary>
-    /// <param name="id">The identifier of the shader to retrieve. Must refer to a valid shader.</param>
+    /// <param name="handle">The identifier of the shader to retrieve. Must refer to a valid shader.</param>
     /// <returns>A result containing a reference to the shader corresponding to the specified identifier, or an error status if the identifier is invalid.</returns>
-    public RefResult<Shader, Error> GetShaderReference(Identifier<Shader> id)
+    public RefResult<Shader, Error> GetShaderReference(Handle<Shader> handle)
     {
-        if (!HasShader(id))
+        ref var shader = ref _shaders.GetElementReferenceAt(handle.ID, handle.Generation, out var exist);
+        if (!exist)
         {
             return Error.NotFound;
         }
 
-        return RefResult<Shader, Error>.Success(ref _shaders[id.Value]);
+        return RefResult<Shader, Error>.Success(ref shader);
     }
 
     /// <summary>
     /// Releases the shader associated with the specified identifier, freeing any resources allocated to it.
     /// </summary>
-    /// <param name="id">The identifier of the shader to release. Must refer to a valid, previously created shader.</param>
-    public void ReleaseShader(Identifier<Shader> id)
+    /// <param name="handle">The identifier of the shader to release. Must refer to a valid, previously created shader.</param>
+    public void ReleaseShader(Handle<Shader> handle)
     {
         Debug.Assert(!_disposed);
 
-        if (!HasShader(id))
+        ref var shader = ref _shaders.GetElementReferenceAt(handle.ID, handle.Generation, out var exist);
+        if (!exist)
         {
             return;
         }
 
-        ref var shader = ref _shaders[id.Value];
+        _shaders.Remove(handle.ID, handle.Generation);
         shader.ReleaseResource(_resourceDatabase);
     }
 
+    /// <summary>
+    /// Determines whether a compute shader with the specified identifier exists in the collection.
+    /// </summary>
+    /// <param name="id">The identifier of the compute shader to check for existence.</param>
+    /// <returns>true if a compute shader with the specified identifier exists; otherwise, false.</returns>
+    public bool HasComputeShader(Handle<ComputeShader> id)
+    {
+        Debug.Assert(!_disposed);
+        return _computeShaders.Contains(id.ID, id.Generation);
+    }
+
+    /// <summary>
+    /// Returns a reference to the compute shader associated with the specified identifier.
+    /// </summary>
+    /// <param name="handle">The identifier of the compute shader to retrieve. Must refer to a valid ComputeShader.</param>
+    /// <returns>A result containing a reference to the compute shader corresponding to the specified identifier, or an error status if the identifier is invalid.</returns>
+    public RefResult<ComputeShader, Error> GetComputeShaderReference(Handle<ComputeShader> handle)
+    {
+        ref var computeShader = ref _computeShaders.GetElementReferenceAt(handle.ID, handle.Generation, out var exist);
+        if (!exist)
+        {
+            return Error.NotFound;
+        }
+
+        return RefResult<ComputeShader, Error>.Success(ref computeShader);
+    }
+
+    /// <summary>
+    /// Releases the compute shader associated with the specified identifier, freeing any resources allocated to it.
+    /// </summary>
+    /// <param name="handle">The identifier of the compute shader to release. Must refer to a valid, previously created ComputeShader.</param>
+    public void ReleaseComputeShader(Handle<ComputeShader> handle)
+    {
+        Debug.Assert(!_disposed);
+
+        ref var computeShader = ref _computeShaders.GetElementReferenceAt(handle.ID, handle.Generation, out var exist);
+        if (!exist)
+        {
+            return;
+        }
+
+        _computeShaders.Remove(handle.ID, handle.Generation);
+        computeShader.ReleaseResource(_resourceDatabase);
+    }
+
     public void Dispose()
     {
         if (_disposed)

src/Runtime/Ghost.Graphics/Services/ResourceUploadBatch.cs

@@ -1,7 +1,7 @@
 using Ghost.Core;
 using Ghost.Graphics.RHI;
 
-namespace Ghost.Graphics;
+namespace Ghost.Graphics.Services;
 
 public class ResourceUploadBatch
 {

src/Runtime/Ghost.Graphics/Services/ShaderLibrary.cs

@@ -0,0 +1,11 @@
+namespace Ghost.Graphics.Services;
+
+public class ShaderLibrary : IDisposable
+{
+
+
+    public void Dispose()
+    {
+        throw new NotImplementedException();
+    }
+}

src/Runtime/Ghost.Graphics/Services/SwapChainManager.cs

@@ -1,7 +1,7 @@
 using Ghost.Graphics.RHI;
 using System.Diagnostics.CodeAnalysis;
 
-namespace Ghost.Graphics;
+namespace Ghost.Graphics.Services;
 
 internal sealed class SwapChainRecord
 {

src/Runtime/Ghost.Graphics/Shaders/Includes/Properties.hlsl

@@ -3,6 +3,12 @@
 
 #include "F:/csharp/GhostEngine/src/Runtime/Ghost.Graphics/Shaders/Includes/Common.hlsl"
 
+#define GLOBAL_BINDLESS_SIG \
+    "RootFlags(ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT | " \
+    "CBV_SRV_UAV_HEAP_DIRECTLY_INDEXED | " \
+    "SAMPLER_HEAP_DIRECTLY_INDEXED), " \
+    "RootConstants(num32BitConstants=3, b0, space=0)"
+
 // TODO: This should be auto generated to match the c# side.
 
 struct GraphicsPushConstantData
@@ -59,6 +65,9 @@ struct MeshData
 GraphicsPushConstantData g_PushConstantData : register(b0);
 #elif defined(__COMPUTE__)
 ComputePushConstantData g_PushConstantData : register(b0);
+#elif defined(__WORK_GRAPH__)
+#define WorkGraphPushConstantData ComputePushConstantData
+WorkGraphPushConstantData g_PushConstantData : register(b0);
 #endif
 
 #endif // GHOST_PROPERTIES_HLSL

src/Test/Ghost.Graphics.Test/RenderPipeline/TestRenderPipeline.cs

@@ -24,7 +24,7 @@ public unsafe partial class TestRenderPipeline : IRenderPipeline
     private readonly RenderSystem _renderSystem;
 
     private readonly RenderGraph _renderGraph;
-    private Identifier<Shader> _meshletShader;
+    private Handle<Shader> _meshletShader;
     private Handle<Material> _meshletMaterial;
 
     private bool _disposed;
@@ -57,7 +57,7 @@ public unsafe partial class TestRenderPipeline : IRenderPipeline
         var emptyKeywords = new LocalKeywordSet();
         var compiled = renderSystem.GraphicsEngine.ShaderCompiler.CompilePass(in pass, in config, in emptyKeywords).GetValueOrThrow();
         
-        _meshletShader = renderSystem.ResourceManager.CreateGraphicsShader(shaderDescriptor, in compiled);
+        _meshletShader = renderSystem.ResourceManager.CreateGraphicsShader(shaderDescriptor, [compiled]);
         _meshletMaterial = renderSystem.ResourceManager.CreateMaterial(_meshletShader);
     }
 
@@ -236,7 +236,7 @@ public unsafe partial class TestRenderPipeline : IRenderPipeline
                     instanceDataArray[instanceIdx++] = new InstanceData
                     {
                         localToWorld = record.localToWorld,
-                        meshBuffer = resourceDatabase.GetBindlessIndex(mesh.Get().ObjectDataBuffer.AsResource()),
+                        meshBuffer = resourceDatabase.GetBindlessIndex(mesh.Get().MeshDataBuffer.AsResource()),
                         materialBuffer = resourceDatabase.GetBindlessIndex(mat.Get()._cBufferCache.GpuResource.AsResource())
                     };
                 }

src/Test/Ghost.Graphics.Test/Windows/GraphicsTestWindow.xaml.cs

@@ -110,7 +110,7 @@ public sealed partial class GraphicsTestWindow : Window
 
         // TODO: Put this to the beginning of the frame without creating another command buffer?
         using var directCmd = _renderSystem.GraphicsEngine.CreateCommandBuffer(CommandBufferType.Graphics);
-        var ctx = new RenderContext(_renderSystem.GraphicsEngine, _renderSystem.ResourceManager, directCmd);
+        var ctx = new RenderContext(_renderSystem.ResourceManager, _renderSystem.GraphicsEngine, directCmd);
 
         using var cmdAllocator = _renderSystem.GraphicsEngine.CreateCommandAllocator(CommandBufferType.Graphics);
         directCmd.Begin(cmdAllocator);

src/ThridParty/Ghost.DXC/Api.cs

@@ -0,0 +1,28 @@
+using System.Reflection;
+using System.Runtime.InteropServices;
+
+namespace Ghost.DXC;
+
+public partial class Api
+{
+    static Api()
+    {
+        NativeLibrary.SetDllImportResolver(typeof(Api).Assembly, DxcDllImportResolver);
+    }
+
+    private static nint DxcDllImportResolver(string libraryName, Assembly assembly, DllImportSearchPath? searchPath)
+    {
+        // NOTE: Currently only support Windows.
+        if (libraryName == "dxcompiler")
+        {
+            NativeLibrary.TryLoad("runtimes/win-x64/native/dxil.dll", out _);
+
+            if (NativeLibrary.TryLoad("runtimes/win-x64/native/dxcompiler.dll", out var dxcHandle))
+            {
+                return dxcHandle;
+            }
+        }
+
+        return IntPtr.Zero;
+    }
+}

src/ThridParty/Ghost.DXC/Generated/DXC_OUT_KIND.cs

@@ -0,0 +1,56 @@
+namespace Ghost.DXC;
+
+/// <include file='DXC_OUT_KIND.xml' path='doc/member[@name="DXC_OUT_KIND"]/*' />
+public enum DXC_OUT_KIND
+{
+    /// <include file='DXC_OUT_KIND.xml' path='doc/member[@name="DXC_OUT_KIND.DXC_OUT_NONE"]/*' />
+    DXC_OUT_NONE = 0,
+
+    /// <include file='DXC_OUT_KIND.xml' path='doc/member[@name="DXC_OUT_KIND.DXC_OUT_OBJECT"]/*' />
+    DXC_OUT_OBJECT = 1,
+
+    /// <include file='DXC_OUT_KIND.xml' path='doc/member[@name="DXC_OUT_KIND.DXC_OUT_ERRORS"]/*' />
+    DXC_OUT_ERRORS = 2,
+
+    /// <include file='DXC_OUT_KIND.xml' path='doc/member[@name="DXC_OUT_KIND.DXC_OUT_PDB"]/*' />
+    DXC_OUT_PDB = 3,
+
+    /// <include file='DXC_OUT_KIND.xml' path='doc/member[@name="DXC_OUT_KIND.DXC_OUT_SHADER_HASH"]/*' />
+    DXC_OUT_SHADER_HASH = 4,
+
+    /// <include file='DXC_OUT_KIND.xml' path='doc/member[@name="DXC_OUT_KIND.DXC_OUT_DISASSEMBLY"]/*' />
+    DXC_OUT_DISASSEMBLY = 5,
+
+    /// <include file='DXC_OUT_KIND.xml' path='doc/member[@name="DXC_OUT_KIND.DXC_OUT_HLSL"]/*' />
+    DXC_OUT_HLSL = 6,
+
+    /// <include file='DXC_OUT_KIND.xml' path='doc/member[@name="DXC_OUT_KIND.DXC_OUT_TEXT"]/*' />
+    DXC_OUT_TEXT = 7,
+
+    /// <include file='DXC_OUT_KIND.xml' path='doc/member[@name="DXC_OUT_KIND.DXC_OUT_REFLECTION"]/*' />
+    DXC_OUT_REFLECTION = 8,
+
+    /// <include file='DXC_OUT_KIND.xml' path='doc/member[@name="DXC_OUT_KIND.DXC_OUT_ROOT_SIGNATURE"]/*' />
+    DXC_OUT_ROOT_SIGNATURE = 9,
+
+    /// <include file='DXC_OUT_KIND.xml' path='doc/member[@name="DXC_OUT_KIND.DXC_OUT_EXTRA_OUTPUTS"]/*' />
+    DXC_OUT_EXTRA_OUTPUTS = 10,
+
+    /// <include file='DXC_OUT_KIND.xml' path='doc/member[@name="DXC_OUT_KIND.DXC_OUT_REMARKS"]/*' />
+    DXC_OUT_REMARKS = 11,
+
+    /// <include file='DXC_OUT_KIND.xml' path='doc/member[@name="DXC_OUT_KIND.DXC_OUT_TIME_REPORT"]/*' />
+    DXC_OUT_TIME_REPORT = 12,
+
+    /// <include file='DXC_OUT_KIND.xml' path='doc/member[@name="DXC_OUT_KIND.DXC_OUT_TIME_TRACE"]/*' />
+    DXC_OUT_TIME_TRACE = 13,
+
+    /// <include file='DXC_OUT_KIND.xml' path='doc/member[@name="DXC_OUT_KIND.DXC_OUT_LAST"]/*' />
+    DXC_OUT_LAST = DXC_OUT_TIME_TRACE,
+
+    /// <include file='DXC_OUT_KIND.xml' path='doc/member[@name="DXC_OUT_KIND.DXC_OUT_NUM_ENUMS"]/*' />
+    DXC_OUT_NUM_ENUMS,
+
+    /// <include file='DXC_OUT_KIND.xml' path='doc/member[@name="DXC_OUT_KIND.DXC_OUT_FORCE_DWORD"]/*' />
+    DXC_OUT_FORCE_DWORD = unchecked((int)(0xFFFFFFFF)),
+}

src/ThridParty/Ghost.DXC/Generated/DisableRuntimeMarshalling.cs

@@ -0,0 +1,3 @@
+using System.Runtime.CompilerServices;
+
+[assembly: DisableRuntimeMarshalling]

src/ThridParty/Ghost.DXC/Generated/DxcArgPair.cs

@@ -0,0 +1,13 @@
+namespace Ghost.DXC;
+
+/// <include file='DxcArgPair.xml' path='doc/member[@name="DxcArgPair"]/*' />
+public unsafe partial struct DxcArgPair
+{
+    /// <include file='DxcArgPair.xml' path='doc/member[@name="DxcArgPair.pName"]/*' />
+    [NativeTypeName("const WCHAR *")]
+    public char* pName;
+
+    /// <include file='DxcArgPair.xml' path='doc/member[@name="DxcArgPair.pValue"]/*' />
+    [NativeTypeName("const WCHAR *")]
+    public char* pValue;
+}

src/ThridParty/Ghost.DXC/Generated/DxcBuffer.cs

@@ -0,0 +1,16 @@
+namespace Ghost.DXC;
+
+/// <include file='DxcBuffer.xml' path='doc/member[@name="DxcBuffer"]/*' />
+public unsafe partial struct DxcBuffer
+{
+    /// <include file='DxcBuffer.xml' path='doc/member[@name="DxcBuffer.Ptr"]/*' />
+    [NativeTypeName("LPCVOID")]
+    public void* Ptr;
+
+    /// <include file='DxcBuffer.xml' path='doc/member[@name="DxcBuffer.Size"]/*' />
+    [NativeTypeName("SIZE_T")]
+    public ulong Size;
+
+    /// <include file='DxcBuffer.xml' path='doc/member[@name="DxcBuffer.Encoding"]/*' />
+    public uint Encoding;
+}

src/ThridParty/Ghost.DXC/Generated/DxcCodeCompleteFlags.cs

@@ -0,0 +1,17 @@
+namespace Ghost.DXC;
+
+/// <include file='DxcCodeCompleteFlags.xml' path='doc/member[@name="DxcCodeCompleteFlags"]/*' />
+public enum DxcCodeCompleteFlags
+{
+    /// <include file='DxcCodeCompleteFlags.xml' path='doc/member[@name="DxcCodeCompleteFlags.DxcCodeCompleteFlags_None"]/*' />
+    DxcCodeCompleteFlags_None = 0,
+
+    /// <include file='DxcCodeCompleteFlags.xml' path='doc/member[@name="DxcCodeCompleteFlags.DxcCodeCompleteFlags_IncludeMacros"]/*' />
+    DxcCodeCompleteFlags_IncludeMacros = 0x1,
+
+    /// <include file='DxcCodeCompleteFlags.xml' path='doc/member[@name="DxcCodeCompleteFlags.DxcCodeCompleteFlags_IncludeCodePatterns"]/*' />
+    DxcCodeCompleteFlags_IncludeCodePatterns = 0x2,
+
+    /// <include file='DxcCodeCompleteFlags.xml' path='doc/member[@name="DxcCodeCompleteFlags.DxcCodeCompleteFlags_IncludeBriefComments"]/*' />
+    DxcCodeCompleteFlags_IncludeBriefComments = 0x4,
+}

src/ThridParty/Ghost.DXC/Generated/DxcCompletionChunkKind.cs

@@ -0,0 +1,68 @@
+namespace Ghost.DXC;
+
+/// <include file='DxcCompletionChunkKind.xml' path='doc/member[@name="DxcCompletionChunkKind"]/*' />
+public enum DxcCompletionChunkKind
+{
+    /// <include file='DxcCompletionChunkKind.xml' path='doc/member[@name="DxcCompletionChunkKind.DxcCompletionChunk_Optional"]/*' />
+    DxcCompletionChunk_Optional = 0,
+
+    /// <include file='DxcCompletionChunkKind.xml' path='doc/member[@name="DxcCompletionChunkKind.DxcCompletionChunk_TypedText"]/*' />
+    DxcCompletionChunk_TypedText = 1,
+
+    /// <include file='DxcCompletionChunkKind.xml' path='doc/member[@name="DxcCompletionChunkKind.DxcCompletionChunk_Text"]/*' />
+    DxcCompletionChunk_Text = 2,
+
+    /// <include file='DxcCompletionChunkKind.xml' path='doc/member[@name="DxcCompletionChunkKind.DxcCompletionChunk_Placeholder"]/*' />
+    DxcCompletionChunk_Placeholder = 3,
+
+    /// <include file='DxcCompletionChunkKind.xml' path='doc/member[@name="DxcCompletionChunkKind.DxcCompletionChunk_Informative"]/*' />
+    DxcCompletionChunk_Informative = 4,
+
+    /// <include file='DxcCompletionChunkKind.xml' path='doc/member[@name="DxcCompletionChunkKind.DxcCompletionChunk_CurrentParameter"]/*' />
+    DxcCompletionChunk_CurrentParameter = 5,
+
+    /// <include file='DxcCompletionChunkKind.xml' path='doc/member[@name="DxcCompletionChunkKind.DxcCompletionChunk_LeftParen"]/*' />
+    DxcCompletionChunk_LeftParen = 6,
+
+    /// <include file='DxcCompletionChunkKind.xml' path='doc/member[@name="DxcCompletionChunkKind.DxcCompletionChunk_RightParen"]/*' />
+    DxcCompletionChunk_RightParen = 7,
+
+    /// <include file='DxcCompletionChunkKind.xml' path='doc/member[@name="DxcCompletionChunkKind.DxcCompletionChunk_LeftBracket"]/*' />
+    DxcCompletionChunk_LeftBracket = 8,
+
+    /// <include file='DxcCompletionChunkKind.xml' path='doc/member[@name="DxcCompletionChunkKind.DxcCompletionChunk_RightBracket"]/*' />
+    DxcCompletionChunk_RightBracket = 9,
+
+    /// <include file='DxcCompletionChunkKind.xml' path='doc/member[@name="DxcCompletionChunkKind.DxcCompletionChunk_LeftBrace"]/*' />
+    DxcCompletionChunk_LeftBrace = 10,
+
+    /// <include file='DxcCompletionChunkKind.xml' path='doc/member[@name="DxcCompletionChunkKind.DxcCompletionChunk_RightBrace"]/*' />
+    DxcCompletionChunk_RightBrace = 11,
+
+    /// <include file='DxcCompletionChunkKind.xml' path='doc/member[@name="DxcCompletionChunkKind.DxcCompletionChunk_LeftAngle"]/*' />
+    DxcCompletionChunk_LeftAngle = 12,
+
+    /// <include file='DxcCompletionChunkKind.xml' path='doc/member[@name="DxcCompletionChunkKind.DxcCompletionChunk_RightAngle"]/*' />
+    DxcCompletionChunk_RightAngle = 13,
+
+    /// <include file='DxcCompletionChunkKind.xml' path='doc/member[@name="DxcCompletionChunkKind.DxcCompletionChunk_Comma"]/*' />
+    DxcCompletionChunk_Comma = 14,
+
+    /// <include file='DxcCompletionChunkKind.xml' path='doc/member[@name="DxcCompletionChunkKind.DxcCompletionChunk_ResultType"]/*' />
+    DxcCompletionChunk_ResultType = 15,
+
+    /// <include file='DxcCompletionChunkKind.xml' path='doc/member[@name="DxcCompletionChunkKind.DxcCompletionChunk_Colon"]/*' />
+    DxcCompletionChunk_Colon = 16,
+
+    /// <include file='DxcCompletionChunkKind.xml' path='doc/member[@name="DxcCompletionChunkKind.DxcCompletionChunk_SemiColon"]/*' />
+    DxcCompletionChunk_SemiColon = 17,
+
+    /// <include file='DxcCompletionChunkKind.xml' path='doc/member[@name="DxcCompletionChunkKind.DxcCompletionChunk_Equal"]/*' />
+    DxcCompletionChunk_Equal = 18,
+
+    /// <include file='DxcCompletionChunkKind.xml' path='doc/member[@name="DxcCompletionChunkKind.DxcCompletionChunk_HorizontalSpace"]/*' />
+    DxcCompletionChunk_HorizontalSpace = 19,
+
+    /// <include file='DxcCompletionChunkKind.xml' path='doc/member[@name="DxcCompletionChunkKind.DxcCompletionChunk_VerticalSpace"]/*' />
+    DxcCompletionChunk_VerticalSpace = 20,
+}

src/ThridParty/Ghost.DXC/Generated/DxcCursorFormatting.cs

@@ -0,0 +1,20 @@
+namespace Ghost.DXC;
+
+/// <include file='DxcCursorFormatting.xml' path='doc/member[@name="DxcCursorFormatting"]/*' />
+public enum DxcCursorFormatting
+{
+    /// <include file='DxcCursorFormatting.xml' path='doc/member[@name="DxcCursorFormatting.DxcCursorFormatting_Default"]/*' />
+    DxcCursorFormatting_Default = 0x0,
+
+    /// <include file='DxcCursorFormatting.xml' path='doc/member[@name="DxcCursorFormatting.DxcCursorFormatting_UseLanguageOptions"]/*' />
+    DxcCursorFormatting_UseLanguageOptions = 0x1,
+
+    /// <include file='DxcCursorFormatting.xml' path='doc/member[@name="DxcCursorFormatting.DxcCursorFormatting_SuppressSpecifiers"]/*' />
+    DxcCursorFormatting_SuppressSpecifiers = 0x2,
+
+    /// <include file='DxcCursorFormatting.xml' path='doc/member[@name="DxcCursorFormatting.DxcCursorFormatting_SuppressTagKeyword"]/*' />
+    DxcCursorFormatting_SuppressTagKeyword = 0x4,
+
+    /// <include file='DxcCursorFormatting.xml' path='doc/member[@name="DxcCursorFormatting.DxcCursorFormatting_IncludeNamespaceKeyword"]/*' />
+    DxcCursorFormatting_IncludeNamespaceKeyword = 0x8,
+}

src/ThridParty/Ghost.DXC/Generated/DxcCursorKind.cs

@@ -0,0 +1,602 @@
+namespace Ghost.DXC;
+
+/// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind"]/*' />
+public enum DxcCursorKind
+{
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_UnexposedDecl"]/*' />
+    DxcCursor_UnexposedDecl = 1,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_StructDecl"]/*' />
+    DxcCursor_StructDecl = 2,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_UnionDecl"]/*' />
+    DxcCursor_UnionDecl = 3,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_ClassDecl"]/*' />
+    DxcCursor_ClassDecl = 4,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_EnumDecl"]/*' />
+    DxcCursor_EnumDecl = 5,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_FieldDecl"]/*' />
+    DxcCursor_FieldDecl = 6,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_EnumConstantDecl"]/*' />
+    DxcCursor_EnumConstantDecl = 7,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_FunctionDecl"]/*' />
+    DxcCursor_FunctionDecl = 8,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_VarDecl"]/*' />
+    DxcCursor_VarDecl = 9,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_ParmDecl"]/*' />
+    DxcCursor_ParmDecl = 10,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_ObjCInterfaceDecl"]/*' />
+    DxcCursor_ObjCInterfaceDecl = 11,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_ObjCCategoryDecl"]/*' />
+    DxcCursor_ObjCCategoryDecl = 12,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_ObjCProtocolDecl"]/*' />
+    DxcCursor_ObjCProtocolDecl = 13,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_ObjCPropertyDecl"]/*' />
+    DxcCursor_ObjCPropertyDecl = 14,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_ObjCIvarDecl"]/*' />
+    DxcCursor_ObjCIvarDecl = 15,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_ObjCInstanceMethodDecl"]/*' />
+    DxcCursor_ObjCInstanceMethodDecl = 16,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_ObjCClassMethodDecl"]/*' />
+    DxcCursor_ObjCClassMethodDecl = 17,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_ObjCImplementationDecl"]/*' />
+    DxcCursor_ObjCImplementationDecl = 18,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_ObjCCategoryImplDecl"]/*' />
+    DxcCursor_ObjCCategoryImplDecl = 19,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_TypedefDecl"]/*' />
+    DxcCursor_TypedefDecl = 20,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_CXXMethod"]/*' />
+    DxcCursor_CXXMethod = 21,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_Namespace"]/*' />
+    DxcCursor_Namespace = 22,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_LinkageSpec"]/*' />
+    DxcCursor_LinkageSpec = 23,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_Constructor"]/*' />
+    DxcCursor_Constructor = 24,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_Destructor"]/*' />
+    DxcCursor_Destructor = 25,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_ConversionFunction"]/*' />
+    DxcCursor_ConversionFunction = 26,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_TemplateTypeParameter"]/*' />
+    DxcCursor_TemplateTypeParameter = 27,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_NonTypeTemplateParameter"]/*' />
+    DxcCursor_NonTypeTemplateParameter = 28,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_TemplateTemplateParameter"]/*' />
+    DxcCursor_TemplateTemplateParameter = 29,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_FunctionTemplate"]/*' />
+    DxcCursor_FunctionTemplate = 30,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_ClassTemplate"]/*' />
+    DxcCursor_ClassTemplate = 31,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_ClassTemplatePartialSpecialization"]/*' />
+    DxcCursor_ClassTemplatePartialSpecialization = 32,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_NamespaceAlias"]/*' />
+    DxcCursor_NamespaceAlias = 33,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_UsingDirective"]/*' />
+    DxcCursor_UsingDirective = 34,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_UsingDeclaration"]/*' />
+    DxcCursor_UsingDeclaration = 35,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_TypeAliasDecl"]/*' />
+    DxcCursor_TypeAliasDecl = 36,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_ObjCSynthesizeDecl"]/*' />
+    DxcCursor_ObjCSynthesizeDecl = 37,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_ObjCDynamicDecl"]/*' />
+    DxcCursor_ObjCDynamicDecl = 38,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_CXXAccessSpecifier"]/*' />
+    DxcCursor_CXXAccessSpecifier = 39,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_FirstDecl"]/*' />
+    DxcCursor_FirstDecl = DxcCursor_UnexposedDecl,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_LastDecl"]/*' />
+    DxcCursor_LastDecl = DxcCursor_CXXAccessSpecifier,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_FirstRef"]/*' />
+    DxcCursor_FirstRef = 40,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_ObjCSuperClassRef"]/*' />
+    DxcCursor_ObjCSuperClassRef = 40,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_ObjCProtocolRef"]/*' />
+    DxcCursor_ObjCProtocolRef = 41,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_ObjCClassRef"]/*' />
+    DxcCursor_ObjCClassRef = 42,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_TypeRef"]/*' />
+    DxcCursor_TypeRef = 43,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_CXXBaseSpecifier"]/*' />
+    DxcCursor_CXXBaseSpecifier = 44,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_TemplateRef"]/*' />
+    DxcCursor_TemplateRef = 45,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_NamespaceRef"]/*' />
+    DxcCursor_NamespaceRef = 46,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_MemberRef"]/*' />
+    DxcCursor_MemberRef = 47,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_LabelRef"]/*' />
+    DxcCursor_LabelRef = 48,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_OverloadedDeclRef"]/*' />
+    DxcCursor_OverloadedDeclRef = 49,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_VariableRef"]/*' />
+    DxcCursor_VariableRef = 50,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_LastRef"]/*' />
+    DxcCursor_LastRef = DxcCursor_VariableRef,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_FirstInvalid"]/*' />
+    DxcCursor_FirstInvalid = 70,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_InvalidFile"]/*' />
+    DxcCursor_InvalidFile = 70,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_NoDeclFound"]/*' />
+    DxcCursor_NoDeclFound = 71,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_NotImplemented"]/*' />
+    DxcCursor_NotImplemented = 72,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_InvalidCode"]/*' />
+    DxcCursor_InvalidCode = 73,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_LastInvalid"]/*' />
+    DxcCursor_LastInvalid = DxcCursor_InvalidCode,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_FirstExpr"]/*' />
+    DxcCursor_FirstExpr = 100,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_UnexposedExpr"]/*' />
+    DxcCursor_UnexposedExpr = 100,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_DeclRefExpr"]/*' />
+    DxcCursor_DeclRefExpr = 101,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_MemberRefExpr"]/*' />
+    DxcCursor_MemberRefExpr = 102,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_CallExpr"]/*' />
+    DxcCursor_CallExpr = 103,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_ObjCMessageExpr"]/*' />
+    DxcCursor_ObjCMessageExpr = 104,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_BlockExpr"]/*' />
+    DxcCursor_BlockExpr = 105,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_IntegerLiteral"]/*' />
+    DxcCursor_IntegerLiteral = 106,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_FloatingLiteral"]/*' />
+    DxcCursor_FloatingLiteral = 107,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_ImaginaryLiteral"]/*' />
+    DxcCursor_ImaginaryLiteral = 108,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_StringLiteral"]/*' />
+    DxcCursor_StringLiteral = 109,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_CharacterLiteral"]/*' />
+    DxcCursor_CharacterLiteral = 110,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_ParenExpr"]/*' />
+    DxcCursor_ParenExpr = 111,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_UnaryOperator"]/*' />
+    DxcCursor_UnaryOperator = 112,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_ArraySubscriptExpr"]/*' />
+    DxcCursor_ArraySubscriptExpr = 113,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_BinaryOperator"]/*' />
+    DxcCursor_BinaryOperator = 114,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_CompoundAssignOperator"]/*' />
+    DxcCursor_CompoundAssignOperator = 115,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_ConditionalOperator"]/*' />
+    DxcCursor_ConditionalOperator = 116,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_CStyleCastExpr"]/*' />
+    DxcCursor_CStyleCastExpr = 117,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_CompoundLiteralExpr"]/*' />
+    DxcCursor_CompoundLiteralExpr = 118,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_InitListExpr"]/*' />
+    DxcCursor_InitListExpr = 119,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_AddrLabelExpr"]/*' />
+    DxcCursor_AddrLabelExpr = 120,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_StmtExpr"]/*' />
+    DxcCursor_StmtExpr = 121,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_GenericSelectionExpr"]/*' />
+    DxcCursor_GenericSelectionExpr = 122,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_GNUNullExpr"]/*' />
+    DxcCursor_GNUNullExpr = 123,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_CXXStaticCastExpr"]/*' />
+    DxcCursor_CXXStaticCastExpr = 124,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_CXXDynamicCastExpr"]/*' />
+    DxcCursor_CXXDynamicCastExpr = 125,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_CXXReinterpretCastExpr"]/*' />
+    DxcCursor_CXXReinterpretCastExpr = 126,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_CXXConstCastExpr"]/*' />
+    DxcCursor_CXXConstCastExpr = 127,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_CXXFunctionalCastExpr"]/*' />
+    DxcCursor_CXXFunctionalCastExpr = 128,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_CXXTypeidExpr"]/*' />
+    DxcCursor_CXXTypeidExpr = 129,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_CXXBoolLiteralExpr"]/*' />
+    DxcCursor_CXXBoolLiteralExpr = 130,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_CXXNullPtrLiteralExpr"]/*' />
+    DxcCursor_CXXNullPtrLiteralExpr = 131,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_CXXThisExpr"]/*' />
+    DxcCursor_CXXThisExpr = 132,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_CXXThrowExpr"]/*' />
+    DxcCursor_CXXThrowExpr = 133,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_CXXNewExpr"]/*' />
+    DxcCursor_CXXNewExpr = 134,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_CXXDeleteExpr"]/*' />
+    DxcCursor_CXXDeleteExpr = 135,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_UnaryExpr"]/*' />
+    DxcCursor_UnaryExpr = 136,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_ObjCStringLiteral"]/*' />
+    DxcCursor_ObjCStringLiteral = 137,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_ObjCEncodeExpr"]/*' />
+    DxcCursor_ObjCEncodeExpr = 138,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_ObjCSelectorExpr"]/*' />
+    DxcCursor_ObjCSelectorExpr = 139,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_ObjCProtocolExpr"]/*' />
+    DxcCursor_ObjCProtocolExpr = 140,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_ObjCBridgedCastExpr"]/*' />
+    DxcCursor_ObjCBridgedCastExpr = 141,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_PackExpansionExpr"]/*' />
+    DxcCursor_PackExpansionExpr = 142,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_SizeOfPackExpr"]/*' />
+    DxcCursor_SizeOfPackExpr = 143,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_LambdaExpr"]/*' />
+    DxcCursor_LambdaExpr = 144,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_ObjCBoolLiteralExpr"]/*' />
+    DxcCursor_ObjCBoolLiteralExpr = 145,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_ObjCSelfExpr"]/*' />
+    DxcCursor_ObjCSelfExpr = 146,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_LastExpr"]/*' />
+    DxcCursor_LastExpr = DxcCursor_ObjCSelfExpr,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_FirstStmt"]/*' />
+    DxcCursor_FirstStmt = 200,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_UnexposedStmt"]/*' />
+    DxcCursor_UnexposedStmt = 200,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_LabelStmt"]/*' />
+    DxcCursor_LabelStmt = 201,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_CompoundStmt"]/*' />
+    DxcCursor_CompoundStmt = 202,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_CaseStmt"]/*' />
+    DxcCursor_CaseStmt = 203,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_DefaultStmt"]/*' />
+    DxcCursor_DefaultStmt = 204,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_IfStmt"]/*' />
+    DxcCursor_IfStmt = 205,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_SwitchStmt"]/*' />
+    DxcCursor_SwitchStmt = 206,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_WhileStmt"]/*' />
+    DxcCursor_WhileStmt = 207,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_DoStmt"]/*' />
+    DxcCursor_DoStmt = 208,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_ForStmt"]/*' />
+    DxcCursor_ForStmt = 209,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_GotoStmt"]/*' />
+    DxcCursor_GotoStmt = 210,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_IndirectGotoStmt"]/*' />
+    DxcCursor_IndirectGotoStmt = 211,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_ContinueStmt"]/*' />
+    DxcCursor_ContinueStmt = 212,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_BreakStmt"]/*' />
+    DxcCursor_BreakStmt = 213,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_ReturnStmt"]/*' />
+    DxcCursor_ReturnStmt = 214,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_GCCAsmStmt"]/*' />
+    DxcCursor_GCCAsmStmt = 215,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_AsmStmt"]/*' />
+    DxcCursor_AsmStmt = DxcCursor_GCCAsmStmt,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_ObjCAtTryStmt"]/*' />
+    DxcCursor_ObjCAtTryStmt = 216,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_ObjCAtCatchStmt"]/*' />
+    DxcCursor_ObjCAtCatchStmt = 217,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_ObjCAtFinallyStmt"]/*' />
+    DxcCursor_ObjCAtFinallyStmt = 218,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_ObjCAtThrowStmt"]/*' />
+    DxcCursor_ObjCAtThrowStmt = 219,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_ObjCAtSynchronizedStmt"]/*' />
+    DxcCursor_ObjCAtSynchronizedStmt = 220,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_ObjCAutoreleasePoolStmt"]/*' />
+    DxcCursor_ObjCAutoreleasePoolStmt = 221,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_ObjCForCollectionStmt"]/*' />
+    DxcCursor_ObjCForCollectionStmt = 222,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_CXXCatchStmt"]/*' />
+    DxcCursor_CXXCatchStmt = 223,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_CXXTryStmt"]/*' />
+    DxcCursor_CXXTryStmt = 224,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_CXXForRangeStmt"]/*' />
+    DxcCursor_CXXForRangeStmt = 225,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_SEHTryStmt"]/*' />
+    DxcCursor_SEHTryStmt = 226,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_SEHExceptStmt"]/*' />
+    DxcCursor_SEHExceptStmt = 227,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_SEHFinallyStmt"]/*' />
+    DxcCursor_SEHFinallyStmt = 228,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_MSAsmStmt"]/*' />
+    DxcCursor_MSAsmStmt = 229,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_NullStmt"]/*' />
+    DxcCursor_NullStmt = 230,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_DeclStmt"]/*' />
+    DxcCursor_DeclStmt = 231,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_OMPParallelDirective"]/*' />
+    DxcCursor_OMPParallelDirective = 232,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_OMPSimdDirective"]/*' />
+    DxcCursor_OMPSimdDirective = 233,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_OMPForDirective"]/*' />
+    DxcCursor_OMPForDirective = 234,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_OMPSectionsDirective"]/*' />
+    DxcCursor_OMPSectionsDirective = 235,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_OMPSectionDirective"]/*' />
+    DxcCursor_OMPSectionDirective = 236,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_OMPSingleDirective"]/*' />
+    DxcCursor_OMPSingleDirective = 237,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_OMPParallelForDirective"]/*' />
+    DxcCursor_OMPParallelForDirective = 238,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_OMPParallelSectionsDirective"]/*' />
+    DxcCursor_OMPParallelSectionsDirective = 239,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_OMPTaskDirective"]/*' />
+    DxcCursor_OMPTaskDirective = 240,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_OMPMasterDirective"]/*' />
+    DxcCursor_OMPMasterDirective = 241,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_OMPCriticalDirective"]/*' />
+    DxcCursor_OMPCriticalDirective = 242,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_OMPTaskyieldDirective"]/*' />
+    DxcCursor_OMPTaskyieldDirective = 243,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_OMPBarrierDirective"]/*' />
+    DxcCursor_OMPBarrierDirective = 244,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_OMPTaskwaitDirective"]/*' />
+    DxcCursor_OMPTaskwaitDirective = 245,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_OMPFlushDirective"]/*' />
+    DxcCursor_OMPFlushDirective = 246,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_SEHLeaveStmt"]/*' />
+    DxcCursor_SEHLeaveStmt = 247,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_OMPOrderedDirective"]/*' />
+    DxcCursor_OMPOrderedDirective = 248,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_OMPAtomicDirective"]/*' />
+    DxcCursor_OMPAtomicDirective = 249,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_OMPForSimdDirective"]/*' />
+    DxcCursor_OMPForSimdDirective = 250,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_OMPParallelForSimdDirective"]/*' />
+    DxcCursor_OMPParallelForSimdDirective = 251,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_OMPTargetDirective"]/*' />
+    DxcCursor_OMPTargetDirective = 252,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_OMPTeamsDirective"]/*' />
+    DxcCursor_OMPTeamsDirective = 253,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_OMPTaskgroupDirective"]/*' />
+    DxcCursor_OMPTaskgroupDirective = 254,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_OMPCancellationPointDirective"]/*' />
+    DxcCursor_OMPCancellationPointDirective = 255,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_OMPCancelDirective"]/*' />
+    DxcCursor_OMPCancelDirective = 256,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_LastStmt"]/*' />
+    DxcCursor_LastStmt = DxcCursor_OMPCancelDirective,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_TranslationUnit"]/*' />
+    DxcCursor_TranslationUnit = 300,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_FirstAttr"]/*' />
+    DxcCursor_FirstAttr = 400,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_UnexposedAttr"]/*' />
+    DxcCursor_UnexposedAttr = 400,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_IBActionAttr"]/*' />
+    DxcCursor_IBActionAttr = 401,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_IBOutletAttr"]/*' />
+    DxcCursor_IBOutletAttr = 402,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_IBOutletCollectionAttr"]/*' />
+    DxcCursor_IBOutletCollectionAttr = 403,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_CXXFinalAttr"]/*' />
+    DxcCursor_CXXFinalAttr = 404,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_CXXOverrideAttr"]/*' />
+    DxcCursor_CXXOverrideAttr = 405,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_AnnotateAttr"]/*' />
+    DxcCursor_AnnotateAttr = 406,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_AsmLabelAttr"]/*' />
+    DxcCursor_AsmLabelAttr = 407,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_PackedAttr"]/*' />
+    DxcCursor_PackedAttr = 408,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_PureAttr"]/*' />
+    DxcCursor_PureAttr = 409,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_ConstAttr"]/*' />
+    DxcCursor_ConstAttr = 410,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_NoDuplicateAttr"]/*' />
+    DxcCursor_NoDuplicateAttr = 411,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_CUDAConstantAttr"]/*' />
+    DxcCursor_CUDAConstantAttr = 412,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_CUDADeviceAttr"]/*' />
+    DxcCursor_CUDADeviceAttr = 413,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_CUDAGlobalAttr"]/*' />
+    DxcCursor_CUDAGlobalAttr = 414,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_CUDAHostAttr"]/*' />
+    DxcCursor_CUDAHostAttr = 415,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_CUDASharedAttr"]/*' />
+    DxcCursor_CUDASharedAttr = 416,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_LastAttr"]/*' />
+    DxcCursor_LastAttr = DxcCursor_CUDASharedAttr,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_PreprocessingDirective"]/*' />
+    DxcCursor_PreprocessingDirective = 500,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_MacroDefinition"]/*' />
+    DxcCursor_MacroDefinition = 501,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_MacroExpansion"]/*' />
+    DxcCursor_MacroExpansion = 502,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_MacroInstantiation"]/*' />
+    DxcCursor_MacroInstantiation = DxcCursor_MacroExpansion,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_InclusionDirective"]/*' />
+    DxcCursor_InclusionDirective = 503,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_FirstPreprocessing"]/*' />
+    DxcCursor_FirstPreprocessing = DxcCursor_PreprocessingDirective,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_LastPreprocessing"]/*' />
+    DxcCursor_LastPreprocessing = DxcCursor_InclusionDirective,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_ModuleImportDecl"]/*' />
+    DxcCursor_ModuleImportDecl = 600,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_FirstExtraDecl"]/*' />
+    DxcCursor_FirstExtraDecl = DxcCursor_ModuleImportDecl,
+
+    /// <include file='DxcCursorKind.xml' path='doc/member[@name="DxcCursorKind.DxcCursor_LastExtraDecl"]/*' />
+    DxcCursor_LastExtraDecl = DxcCursor_ModuleImportDecl,
+}

src/ThridParty/Ghost.DXC/Generated/DxcCursorKindFlags.cs

@@ -0,0 +1,35 @@
+namespace Ghost.DXC;
+
+/// <include file='DxcCursorKindFlags.xml' path='doc/member[@name="DxcCursorKindFlags"]/*' />
+public enum DxcCursorKindFlags
+{
+    /// <include file='DxcCursorKindFlags.xml' path='doc/member[@name="DxcCursorKindFlags.DxcCursorKind_None"]/*' />
+    DxcCursorKind_None = 0,
+
+    /// <include file='DxcCursorKindFlags.xml' path='doc/member[@name="DxcCursorKindFlags.DxcCursorKind_Declaration"]/*' />
+    DxcCursorKind_Declaration = 0x1,
+
+    /// <include file='DxcCursorKindFlags.xml' path='doc/member[@name="DxcCursorKindFlags.DxcCursorKind_Reference"]/*' />
+    DxcCursorKind_Reference = 0x2,
+
+    /// <include file='DxcCursorKindFlags.xml' path='doc/member[@name="DxcCursorKindFlags.DxcCursorKind_Expression"]/*' />
+    DxcCursorKind_Expression = 0x4,
+
+    /// <include file='DxcCursorKindFlags.xml' path='doc/member[@name="DxcCursorKindFlags.DxcCursorKind_Statement"]/*' />
+    DxcCursorKind_Statement = 0x8,
+
+    /// <include file='DxcCursorKindFlags.xml' path='doc/member[@name="DxcCursorKindFlags.DxcCursorKind_Attribute"]/*' />
+    DxcCursorKind_Attribute = 0x10,
+
+    /// <include file='DxcCursorKindFlags.xml' path='doc/member[@name="DxcCursorKindFlags.DxcCursorKind_Invalid"]/*' />
+    DxcCursorKind_Invalid = 0x20,
+
+    /// <include file='DxcCursorKindFlags.xml' path='doc/member[@name="DxcCursorKindFlags.DxcCursorKind_TranslationUnit"]/*' />
+    DxcCursorKind_TranslationUnit = 0x40,
+
+    /// <include file='DxcCursorKindFlags.xml' path='doc/member[@name="DxcCursorKindFlags.DxcCursorKind_Preprocessing"]/*' />
+    DxcCursorKind_Preprocessing = 0x80,
+
+    /// <include file='DxcCursorKindFlags.xml' path='doc/member[@name="DxcCursorKindFlags.DxcCursorKind_Unexposed"]/*' />
+    DxcCursorKind_Unexposed = 0x100,
+}

src/ThridParty/Ghost.DXC/Generated/DxcDefine.cs

@@ -0,0 +1,13 @@
+namespace Ghost.DXC;
+
+/// <include file='DxcDefine.xml' path='doc/member[@name="DxcDefine"]/*' />
+public unsafe partial struct DxcDefine
+{
+    /// <include file='DxcDefine.xml' path='doc/member[@name="DxcDefine.Name"]/*' />
+    [NativeTypeName("LPCWSTR")]
+    public char* Name;
+
+    /// <include file='DxcDefine.xml' path='doc/member[@name="DxcDefine.Value"]/*' />
+    [NativeTypeName("LPCWSTR")]
+    public char* Value;
+}

src/ThridParty/Ghost.DXC/Generated/DxcDiagnosticDisplayOptions.cs

@@ -0,0 +1,26 @@
+namespace Ghost.DXC;
+
+/// <include file='DxcDiagnosticDisplayOptions.xml' path='doc/member[@name="DxcDiagnosticDisplayOptions"]/*' />
+public enum DxcDiagnosticDisplayOptions
+{
+    /// <include file='DxcDiagnosticDisplayOptions.xml' path='doc/member[@name="DxcDiagnosticDisplayOptions.DxcDiagnostic_DisplaySourceLocation"]/*' />
+    DxcDiagnostic_DisplaySourceLocation = 0x01,
+
+    /// <include file='DxcDiagnosticDisplayOptions.xml' path='doc/member[@name="DxcDiagnosticDisplayOptions.DxcDiagnostic_DisplayColumn"]/*' />
+    DxcDiagnostic_DisplayColumn = 0x02,
+
+    /// <include file='DxcDiagnosticDisplayOptions.xml' path='doc/member[@name="DxcDiagnosticDisplayOptions.DxcDiagnostic_DisplaySourceRanges"]/*' />
+    DxcDiagnostic_DisplaySourceRanges = 0x04,
+
+    /// <include file='DxcDiagnosticDisplayOptions.xml' path='doc/member[@name="DxcDiagnosticDisplayOptions.DxcDiagnostic_DisplayOption"]/*' />
+    DxcDiagnostic_DisplayOption = 0x08,
+
+    /// <include file='DxcDiagnosticDisplayOptions.xml' path='doc/member[@name="DxcDiagnosticDisplayOptions.DxcDiagnostic_DisplayCategoryId"]/*' />
+    DxcDiagnostic_DisplayCategoryId = 0x10,
+
+    /// <include file='DxcDiagnosticDisplayOptions.xml' path='doc/member[@name="DxcDiagnosticDisplayOptions.DxcDiagnostic_DisplayCategoryName"]/*' />
+    DxcDiagnostic_DisplayCategoryName = 0x20,
+
+    /// <include file='DxcDiagnosticDisplayOptions.xml' path='doc/member[@name="DxcDiagnosticDisplayOptions.DxcDiagnostic_DisplaySeverity"]/*' />
+    DxcDiagnostic_DisplaySeverity = 0x200,
+}

src/ThridParty/Ghost.DXC/Generated/DxcDiagnosticSeverity.cs

@@ -0,0 +1,20 @@
+namespace Ghost.DXC;
+
+/// <include file='DxcDiagnosticSeverity.xml' path='doc/member[@name="DxcDiagnosticSeverity"]/*' />
+public enum DxcDiagnosticSeverity
+{
+    /// <include file='DxcDiagnosticSeverity.xml' path='doc/member[@name="DxcDiagnosticSeverity.DxcDiagnostic_Ignored"]/*' />
+    DxcDiagnostic_Ignored = 0,
+
+    /// <include file='DxcDiagnosticSeverity.xml' path='doc/member[@name="DxcDiagnosticSeverity.DxcDiagnostic_Note"]/*' />
+    DxcDiagnostic_Note = 1,
+
+    /// <include file='DxcDiagnosticSeverity.xml' path='doc/member[@name="DxcDiagnosticSeverity.DxcDiagnostic_Warning"]/*' />
+    DxcDiagnostic_Warning = 2,
+
+    /// <include file='DxcDiagnosticSeverity.xml' path='doc/member[@name="DxcDiagnosticSeverity.DxcDiagnostic_Error"]/*' />
+    DxcDiagnostic_Error = 3,
+
+    /// <include file='DxcDiagnosticSeverity.xml' path='doc/member[@name="DxcDiagnosticSeverity.DxcDiagnostic_Fatal"]/*' />
+    DxcDiagnostic_Fatal = 4,
+}

src/ThridParty/Ghost.DXC/Generated/DxcGlobalOptions.cs

@@ -0,0 +1,17 @@
+namespace Ghost.DXC;
+
+/// <include file='DxcGlobalOptions.xml' path='doc/member[@name="DxcGlobalOptions"]/*' />
+public enum DxcGlobalOptions
+{
+    /// <include file='DxcGlobalOptions.xml' path='doc/member[@name="DxcGlobalOptions.DxcGlobalOpt_None"]/*' />
+    DxcGlobalOpt_None = 0x0,
+
+    /// <include file='DxcGlobalOptions.xml' path='doc/member[@name="DxcGlobalOptions.DxcGlobalOpt_ThreadBackgroundPriorityForIndexing"]/*' />
+    DxcGlobalOpt_ThreadBackgroundPriorityForIndexing = 0x1,
+
+    /// <include file='DxcGlobalOptions.xml' path='doc/member[@name="DxcGlobalOptions.DxcGlobalOpt_ThreadBackgroundPriorityForEditing"]/*' />
+    DxcGlobalOpt_ThreadBackgroundPriorityForEditing = 0x2,
+
+    /// <include file='DxcGlobalOptions.xml' path='doc/member[@name="DxcGlobalOptions.DxcGlobalOpt_ThreadBackgroundPriorityForAll"]/*' />
+    DxcGlobalOpt_ThreadBackgroundPriorityForAll = DxcGlobalOpt_ThreadBackgroundPriorityForIndexing | DxcGlobalOpt_ThreadBackgroundPriorityForEditing,
+}

src/ThridParty/Ghost.DXC/Generated/DxcShaderHash.cs

@@ -0,0 +1,22 @@
+using System.Runtime.CompilerServices;
+
+namespace Ghost.DXC;
+
+/// <include file='DxcShaderHash.xml' path='doc/member[@name="DxcShaderHash"]/*' />
+public partial struct DxcShaderHash
+{
+    /// <include file='DxcShaderHash.xml' path='doc/member[@name="DxcShaderHash.Flags"]/*' />
+    [NativeTypeName("UINT32")]
+    public uint Flags;
+
+    /// <include file='DxcShaderHash.xml' path='doc/member[@name="DxcShaderHash.HashDigest"]/*' />
+    [NativeTypeName("BYTE[16]")]
+    public _HashDigest_e__FixedBuffer HashDigest;
+
+    /// <include file='_HashDigest_e__FixedBuffer.xml' path='doc/member[@name="_HashDigest_e__FixedBuffer"]/*' />
+    [InlineArray(16)]
+    public partial struct _HashDigest_e__FixedBuffer
+    {
+        public byte e0;
+    }
+}

src/ThridParty/Ghost.DXC/Generated/DxcTokenKind.cs

@@ -0,0 +1,26 @@
+namespace Ghost.DXC;
+
+/// <include file='DxcTokenKind.xml' path='doc/member[@name="DxcTokenKind"]/*' />
+public enum DxcTokenKind
+{
+    /// <include file='DxcTokenKind.xml' path='doc/member[@name="DxcTokenKind.DxcTokenKind_Punctuation"]/*' />
+    DxcTokenKind_Punctuation = 0,
+
+    /// <include file='DxcTokenKind.xml' path='doc/member[@name="DxcTokenKind.DxcTokenKind_Keyword"]/*' />
+    DxcTokenKind_Keyword = 1,
+
+    /// <include file='DxcTokenKind.xml' path='doc/member[@name="DxcTokenKind.DxcTokenKind_Identifier"]/*' />
+    DxcTokenKind_Identifier = 2,
+
+    /// <include file='DxcTokenKind.xml' path='doc/member[@name="DxcTokenKind.DxcTokenKind_Literal"]/*' />
+    DxcTokenKind_Literal = 3,
+
+    /// <include file='DxcTokenKind.xml' path='doc/member[@name="DxcTokenKind.DxcTokenKind_Comment"]/*' />
+    DxcTokenKind_Comment = 4,
+
+    /// <include file='DxcTokenKind.xml' path='doc/member[@name="DxcTokenKind.DxcTokenKind_Unknown"]/*' />
+    DxcTokenKind_Unknown = 5,
+
+    /// <include file='DxcTokenKind.xml' path='doc/member[@name="DxcTokenKind.DxcTokenKind_BuiltInType"]/*' />
+    DxcTokenKind_BuiltInType = 6,
+}

src/ThridParty/Ghost.DXC/Generated/DxcTranslationUnitFlags.cs

@@ -0,0 +1,35 @@
+namespace Ghost.DXC;
+
+/// <include file='DxcTranslationUnitFlags.xml' path='doc/member[@name="DxcTranslationUnitFlags"]/*' />
+public enum DxcTranslationUnitFlags
+{
+    /// <include file='DxcTranslationUnitFlags.xml' path='doc/member[@name="DxcTranslationUnitFlags.DxcTranslationUnitFlags_None"]/*' />
+    DxcTranslationUnitFlags_None = 0x0,
+
+    /// <include file='DxcTranslationUnitFlags.xml' path='doc/member[@name="DxcTranslationUnitFlags.DxcTranslationUnitFlags_DetailedPreprocessingRecord"]/*' />
+    DxcTranslationUnitFlags_DetailedPreprocessingRecord = 0x01,
+
+    /// <include file='DxcTranslationUnitFlags.xml' path='doc/member[@name="DxcTranslationUnitFlags.DxcTranslationUnitFlags_Incomplete"]/*' />
+    DxcTranslationUnitFlags_Incomplete = 0x02,
+
+    /// <include file='DxcTranslationUnitFlags.xml' path='doc/member[@name="DxcTranslationUnitFlags.DxcTranslationUnitFlags_PrecompiledPreamble"]/*' />
+    DxcTranslationUnitFlags_PrecompiledPreamble = 0x04,
+
+    /// <include file='DxcTranslationUnitFlags.xml' path='doc/member[@name="DxcTranslationUnitFlags.DxcTranslationUnitFlags_CacheCompletionResults"]/*' />
+    DxcTranslationUnitFlags_CacheCompletionResults = 0x08,
+
+    /// <include file='DxcTranslationUnitFlags.xml' path='doc/member[@name="DxcTranslationUnitFlags.DxcTranslationUnitFlags_ForSerialization"]/*' />
+    DxcTranslationUnitFlags_ForSerialization = 0x10,
+
+    /// <include file='DxcTranslationUnitFlags.xml' path='doc/member[@name="DxcTranslationUnitFlags.DxcTranslationUnitFlags_CXXChainedPCH"]/*' />
+    DxcTranslationUnitFlags_CXXChainedPCH = 0x20,
+
+    /// <include file='DxcTranslationUnitFlags.xml' path='doc/member[@name="DxcTranslationUnitFlags.DxcTranslationUnitFlags_SkipFunctionBodies"]/*' />
+    DxcTranslationUnitFlags_SkipFunctionBodies = 0x40,
+
+    /// <include file='DxcTranslationUnitFlags.xml' path='doc/member[@name="DxcTranslationUnitFlags.DxcTranslationUnitFlags_IncludeBriefCommentsInCodeCompletion"]/*' />
+    DxcTranslationUnitFlags_IncludeBriefCommentsInCodeCompletion = 0x80,
+
+    /// <include file='DxcTranslationUnitFlags.xml' path='doc/member[@name="DxcTranslationUnitFlags.DxcTranslationUnitFlags_UseCallerThread"]/*' />
+    DxcTranslationUnitFlags_UseCallerThread = 0x800,
+}

src/ThridParty/Ghost.DXC/Generated/DxcTypeKind.cs

@@ -0,0 +1,155 @@
+namespace Ghost.DXC;
+
+/// <include file='DxcTypeKind.xml' path='doc/member[@name="DxcTypeKind"]/*' />
+public enum DxcTypeKind
+{
+    /// <include file='DxcTypeKind.xml' path='doc/member[@name="DxcTypeKind.DxcTypeKind_Invalid"]/*' />
+    DxcTypeKind_Invalid = 0,
+
+    /// <include file='DxcTypeKind.xml' path='doc/member[@name="DxcTypeKind.DxcTypeKind_Unexposed"]/*' />
+    DxcTypeKind_Unexposed = 1,
+
+    /// <include file='DxcTypeKind.xml' path='doc/member[@name="DxcTypeKind.DxcTypeKind_Void"]/*' />
+    DxcTypeKind_Void = 2,
+
+    /// <include file='DxcTypeKind.xml' path='doc/member[@name="DxcTypeKind.DxcTypeKind_Bool"]/*' />
+    DxcTypeKind_Bool = 3,
+
+    /// <include file='DxcTypeKind.xml' path='doc/member[@name="DxcTypeKind.DxcTypeKind_Char_U"]/*' />
+    DxcTypeKind_Char_U = 4,
+
+    /// <include file='DxcTypeKind.xml' path='doc/member[@name="DxcTypeKind.DxcTypeKind_UChar"]/*' />
+    DxcTypeKind_UChar = 5,
+
+    /// <include file='DxcTypeKind.xml' path='doc/member[@name="DxcTypeKind.DxcTypeKind_Char16"]/*' />
+    DxcTypeKind_Char16 = 6,
+
+    /// <include file='DxcTypeKind.xml' path='doc/member[@name="DxcTypeKind.DxcTypeKind_Char32"]/*' />
+    DxcTypeKind_Char32 = 7,
+
+    /// <include file='DxcTypeKind.xml' path='doc/member[@name="DxcTypeKind.DxcTypeKind_UShort"]/*' />
+    DxcTypeKind_UShort = 8,
+
+    /// <include file='DxcTypeKind.xml' path='doc/member[@name="DxcTypeKind.DxcTypeKind_UInt"]/*' />
+    DxcTypeKind_UInt = 9,
+
+    /// <include file='DxcTypeKind.xml' path='doc/member[@name="DxcTypeKind.DxcTypeKind_ULong"]/*' />
+    DxcTypeKind_ULong = 10,
+
+    /// <include file='DxcTypeKind.xml' path='doc/member[@name="DxcTypeKind.DxcTypeKind_ULongLong"]/*' />
+    DxcTypeKind_ULongLong = 11,
+
+    /// <include file='DxcTypeKind.xml' path='doc/member[@name="DxcTypeKind.DxcTypeKind_UInt128"]/*' />
+    DxcTypeKind_UInt128 = 12,
+
+    /// <include file='DxcTypeKind.xml' path='doc/member[@name="DxcTypeKind.DxcTypeKind_Char_S"]/*' />
+    DxcTypeKind_Char_S = 13,
+
+    /// <include file='DxcTypeKind.xml' path='doc/member[@name="DxcTypeKind.DxcTypeKind_SChar"]/*' />
+    DxcTypeKind_SChar = 14,
+
+    /// <include file='DxcTypeKind.xml' path='doc/member[@name="DxcTypeKind.DxcTypeKind_WChar"]/*' />
+    DxcTypeKind_WChar = 15,
+
+    /// <include file='DxcTypeKind.xml' path='doc/member[@name="DxcTypeKind.DxcTypeKind_Short"]/*' />
+    DxcTypeKind_Short = 16,
+
+    /// <include file='DxcTypeKind.xml' path='doc/member[@name="DxcTypeKind.DxcTypeKind_Int"]/*' />
+    DxcTypeKind_Int = 17,
+
+    /// <include file='DxcTypeKind.xml' path='doc/member[@name="DxcTypeKind.DxcTypeKind_Long"]/*' />
+    DxcTypeKind_Long = 18,
+
+    /// <include file='DxcTypeKind.xml' path='doc/member[@name="DxcTypeKind.DxcTypeKind_LongLong"]/*' />
+    DxcTypeKind_LongLong = 19,
+
+    /// <include file='DxcTypeKind.xml' path='doc/member[@name="DxcTypeKind.DxcTypeKind_Int128"]/*' />
+    DxcTypeKind_Int128 = 20,
+
+    /// <include file='DxcTypeKind.xml' path='doc/member[@name="DxcTypeKind.DxcTypeKind_Float"]/*' />
+    DxcTypeKind_Float = 21,
+
+    /// <include file='DxcTypeKind.xml' path='doc/member[@name="DxcTypeKind.DxcTypeKind_Double"]/*' />
+    DxcTypeKind_Double = 22,
+
+    /// <include file='DxcTypeKind.xml' path='doc/member[@name="DxcTypeKind.DxcTypeKind_LongDouble"]/*' />
+    DxcTypeKind_LongDouble = 23,
+
+    /// <include file='DxcTypeKind.xml' path='doc/member[@name="DxcTypeKind.DxcTypeKind_NullPtr"]/*' />
+    DxcTypeKind_NullPtr = 24,
+
+    /// <include file='DxcTypeKind.xml' path='doc/member[@name="DxcTypeKind.DxcTypeKind_Overload"]/*' />
+    DxcTypeKind_Overload = 25,
+
+    /// <include file='DxcTypeKind.xml' path='doc/member[@name="DxcTypeKind.DxcTypeKind_Dependent"]/*' />
+    DxcTypeKind_Dependent = 26,
+
+    /// <include file='DxcTypeKind.xml' path='doc/member[@name="DxcTypeKind.DxcTypeKind_ObjCId"]/*' />
+    DxcTypeKind_ObjCId = 27,
+
+    /// <include file='DxcTypeKind.xml' path='doc/member[@name="DxcTypeKind.DxcTypeKind_ObjCClass"]/*' />
+    DxcTypeKind_ObjCClass = 28,
+
+    /// <include file='DxcTypeKind.xml' path='doc/member[@name="DxcTypeKind.DxcTypeKind_ObjCSel"]/*' />
+    DxcTypeKind_ObjCSel = 29,
+
+    /// <include file='DxcTypeKind.xml' path='doc/member[@name="DxcTypeKind.DxcTypeKind_FirstBuiltin"]/*' />
+    DxcTypeKind_FirstBuiltin = DxcTypeKind_Void,
+
+    /// <include file='DxcTypeKind.xml' path='doc/member[@name="DxcTypeKind.DxcTypeKind_LastBuiltin"]/*' />
+    DxcTypeKind_LastBuiltin = DxcTypeKind_ObjCSel,
+
+    /// <include file='DxcTypeKind.xml' path='doc/member[@name="DxcTypeKind.DxcTypeKind_Complex"]/*' />
+    DxcTypeKind_Complex = 100,
+
+    /// <include file='DxcTypeKind.xml' path='doc/member[@name="DxcTypeKind.DxcTypeKind_Pointer"]/*' />
+    DxcTypeKind_Pointer = 101,
+
+    /// <include file='DxcTypeKind.xml' path='doc/member[@name="DxcTypeKind.DxcTypeKind_BlockPointer"]/*' />
+    DxcTypeKind_BlockPointer = 102,
+
+    /// <include file='DxcTypeKind.xml' path='doc/member[@name="DxcTypeKind.DxcTypeKind_LValueReference"]/*' />
+    DxcTypeKind_LValueReference = 103,
+
+    /// <include file='DxcTypeKind.xml' path='doc/member[@name="DxcTypeKind.DxcTypeKind_RValueReference"]/*' />
+    DxcTypeKind_RValueReference = 104,
+
+    /// <include file='DxcTypeKind.xml' path='doc/member[@name="DxcTypeKind.DxcTypeKind_Record"]/*' />
+    DxcTypeKind_Record = 105,
+
+    /// <include file='DxcTypeKind.xml' path='doc/member[@name="DxcTypeKind.DxcTypeKind_Enum"]/*' />
+    DxcTypeKind_Enum = 106,
+
+    /// <include file='DxcTypeKind.xml' path='doc/member[@name="DxcTypeKind.DxcTypeKind_Typedef"]/*' />
+    DxcTypeKind_Typedef = 107,
+
+    /// <include file='DxcTypeKind.xml' path='doc/member[@name="DxcTypeKind.DxcTypeKind_ObjCInterface"]/*' />
+    DxcTypeKind_ObjCInterface = 108,
+
+    /// <include file='DxcTypeKind.xml' path='doc/member[@name="DxcTypeKind.DxcTypeKind_ObjCObjectPointer"]/*' />
+    DxcTypeKind_ObjCObjectPointer = 109,
+
+    /// <include file='DxcTypeKind.xml' path='doc/member[@name="DxcTypeKind.DxcTypeKind_FunctionNoProto"]/*' />
+    DxcTypeKind_FunctionNoProto = 110,
+
+    /// <include file='DxcTypeKind.xml' path='doc/member[@name="DxcTypeKind.DxcTypeKind_FunctionProto"]/*' />
+    DxcTypeKind_FunctionProto = 111,
+
+    /// <include file='DxcTypeKind.xml' path='doc/member[@name="DxcTypeKind.DxcTypeKind_ConstantArray"]/*' />
+    DxcTypeKind_ConstantArray = 112,
+
+    /// <include file='DxcTypeKind.xml' path='doc/member[@name="DxcTypeKind.DxcTypeKind_Vector"]/*' />
+    DxcTypeKind_Vector = 113,
+
+    /// <include file='DxcTypeKind.xml' path='doc/member[@name="DxcTypeKind.DxcTypeKind_IncompleteArray"]/*' />
+    DxcTypeKind_IncompleteArray = 114,
+
+    /// <include file='DxcTypeKind.xml' path='doc/member[@name="DxcTypeKind.DxcTypeKind_VariableArray"]/*' />
+    DxcTypeKind_VariableArray = 115,
+
+    /// <include file='DxcTypeKind.xml' path='doc/member[@name="DxcTypeKind.DxcTypeKind_DependentSizedArray"]/*' />
+    DxcTypeKind_DependentSizedArray = 116,
+
+    /// <include file='DxcTypeKind.xml' path='doc/member[@name="DxcTypeKind.DxcTypeKind_MemberPointer"]/*' />
+    DxcTypeKind_MemberPointer = 117,
+}

src/ThridParty/Ghost.DXC/Generated/IDxcAssembler.cs

@@ -0,0 +1,76 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using static Ghost.DXC.Api;
+
+namespace Ghost.DXC;
+
+/// <include file='IDxcAssembler.xml' path='doc/member[@name="IDxcAssembler"]/*' />
+[Guid("091F7A26-1C1F-4948-904B-E6E3A8A771D5")]
+[NativeTypeName("struct IDxcAssembler : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcAssembler : IDxcAssembler.Interface, INativeGuid
+{
+    static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(in IID_IDxcAssembler);
+
+    public void** lpVtbl;
+
+    /// <inheritdoc cref="IUnknown.QueryInterface" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(0)]
+    [return: NativeTypeName("HRESULT")]
+    public int QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcAssembler*, Guid*, void**, int>)(lpVtbl[0]))((IDxcAssembler*)Unsafe.AsPointer(ref this), riid, ppvObject);
+    }
+
+    /// <inheritdoc cref="IUnknown.AddRef" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(1)]
+    [return: NativeTypeName("ULONG")]
+    public uint AddRef()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcAssembler*, uint>)(lpVtbl[1]))((IDxcAssembler*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IUnknown.Release" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(2)]
+    [return: NativeTypeName("ULONG")]
+    public uint Release()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcAssembler*, uint>)(lpVtbl[2]))((IDxcAssembler*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <include file='IDxcAssembler.xml' path='doc/member[@name="IDxcAssembler.AssembleToContainer"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(3)]
+    [return: NativeTypeName("HRESULT")]
+    public int AssembleToContainer(IDxcBlob* pShader, IDxcOperationResult** ppResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcAssembler*, IDxcBlob*, IDxcOperationResult**, int>)(lpVtbl[3]))((IDxcAssembler*)Unsafe.AsPointer(ref this), pShader, ppResult);
+    }
+
+    public interface Interface : IUnknown.Interface
+    {
+        [VtblIndex(3)]
+        [return: NativeTypeName("HRESULT")]
+        int AssembleToContainer(IDxcBlob* pShader, IDxcOperationResult** ppResult);
+    }
+
+    public partial struct Vtbl<TSelf>
+        where TSelf : unmanaged, Interface
+    {
+        [NativeTypeName("HRESULT (const IID &, void **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, Guid*, void**, int> QueryInterface;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> AddRef;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> Release;
+
+        [NativeTypeName("HRESULT (IDxcBlob *, IDxcOperationResult **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcBlob*, IDxcOperationResult**, int> AssembleToContainer;
+    }
+}

src/ThridParty/Ghost.DXC/Generated/IDxcBlob.cs

@@ -0,0 +1,92 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using static Ghost.DXC.Api;
+
+namespace Ghost.DXC;
+
+/// <include file='IDxcBlob.xml' path='doc/member[@name="IDxcBlob"]/*' />
+[Guid("8BA5FB08-5195-40E2-AC58-0D989C3A0102")]
+[NativeTypeName("struct IDxcBlob : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcBlob : IDxcBlob.Interface, INativeGuid
+{
+    static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(in IID_IDxcBlob);
+
+    public void** lpVtbl;
+
+    /// <inheritdoc cref="IUnknown.QueryInterface" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(0)]
+    [return: NativeTypeName("HRESULT")]
+    public int QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcBlob*, Guid*, void**, int>)(lpVtbl[0]))((IDxcBlob*)Unsafe.AsPointer(ref this), riid, ppvObject);
+    }
+
+    /// <inheritdoc cref="IUnknown.AddRef" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(1)]
+    [return: NativeTypeName("ULONG")]
+    public uint AddRef()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcBlob*, uint>)(lpVtbl[1]))((IDxcBlob*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IUnknown.Release" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(2)]
+    [return: NativeTypeName("ULONG")]
+    public uint Release()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcBlob*, uint>)(lpVtbl[2]))((IDxcBlob*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <include file='IDxcBlob.xml' path='doc/member[@name="IDxcBlob.GetBufferPointer"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(3)]
+    [return: NativeTypeName("LPVOID")]
+    public void* GetBufferPointer()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcBlob*, void*>)(lpVtbl[3]))((IDxcBlob*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <include file='IDxcBlob.xml' path='doc/member[@name="IDxcBlob.GetBufferSize"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(4)]
+    [return: NativeTypeName("SIZE_T")]
+    public ulong GetBufferSize()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcBlob*, ulong>)(lpVtbl[4]))((IDxcBlob*)Unsafe.AsPointer(ref this));
+    }
+
+    public interface Interface : IUnknown.Interface
+    {
+        [VtblIndex(3)]
+        [return: NativeTypeName("LPVOID")]
+        void* GetBufferPointer();
+
+        [VtblIndex(4)]
+        [return: NativeTypeName("SIZE_T")]
+        ulong GetBufferSize();
+    }
+
+    public partial struct Vtbl<TSelf>
+        where TSelf : unmanaged, Interface
+    {
+        [NativeTypeName("HRESULT (const IID &, void **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, Guid*, void**, int> QueryInterface;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> AddRef;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> Release;
+
+        [NativeTypeName("LPVOID () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, void*> GetBufferPointer;
+
+        [NativeTypeName("SIZE_T () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, ulong> GetBufferSize;
+    }
+}

src/ThridParty/Ghost.DXC/Generated/IDxcBlobEncoding.cs

@@ -0,0 +1,100 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using static Ghost.DXC.Api;
+
+namespace Ghost.DXC;
+
+/// <include file='IDxcBlobEncoding.xml' path='doc/member[@name="IDxcBlobEncoding"]/*' />
+[Guid("7241D424-2646-4191-97C0-98E96E42FC68")]
+[NativeTypeName("struct IDxcBlobEncoding : IDxcBlob")]
+[NativeInheritance("IDxcBlob")]
+public unsafe partial struct IDxcBlobEncoding : IDxcBlobEncoding.Interface, INativeGuid
+{
+    static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(in IID_IDxcBlobEncoding);
+
+    public void** lpVtbl;
+
+    /// <inheritdoc cref="IUnknown.QueryInterface" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(0)]
+    [return: NativeTypeName("HRESULT")]
+    public int QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcBlobEncoding*, Guid*, void**, int>)(lpVtbl[0]))((IDxcBlobEncoding*)Unsafe.AsPointer(ref this), riid, ppvObject);
+    }
+
+    /// <inheritdoc cref="IUnknown.AddRef" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(1)]
+    [return: NativeTypeName("ULONG")]
+    public uint AddRef()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcBlobEncoding*, uint>)(lpVtbl[1]))((IDxcBlobEncoding*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IUnknown.Release" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(2)]
+    [return: NativeTypeName("ULONG")]
+    public uint Release()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcBlobEncoding*, uint>)(lpVtbl[2]))((IDxcBlobEncoding*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IDxcBlob.GetBufferPointer" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(3)]
+    [return: NativeTypeName("LPVOID")]
+    public void* GetBufferPointer()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcBlobEncoding*, void*>)(lpVtbl[3]))((IDxcBlobEncoding*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IDxcBlob.GetBufferSize" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(4)]
+    [return: NativeTypeName("SIZE_T")]
+    public ulong GetBufferSize()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcBlobEncoding*, ulong>)(lpVtbl[4]))((IDxcBlobEncoding*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <include file='IDxcBlobEncoding.xml' path='doc/member[@name="IDxcBlobEncoding.GetEncoding"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(5)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetEncoding([NativeTypeName("BOOL *")] int* pKnown, [NativeTypeName("UINT32 *")] uint* pCodePage)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcBlobEncoding*, int*, uint*, int>)(lpVtbl[5]))((IDxcBlobEncoding*)Unsafe.AsPointer(ref this), pKnown, pCodePage);
+    }
+
+    public interface Interface : IDxcBlob.Interface
+    {
+        [VtblIndex(5)]
+        [return: NativeTypeName("HRESULT")]
+        int GetEncoding([NativeTypeName("BOOL *")] int* pKnown, [NativeTypeName("UINT32 *")] uint* pCodePage);
+    }
+
+    public partial struct Vtbl<TSelf>
+        where TSelf : unmanaged, Interface
+    {
+        [NativeTypeName("HRESULT (const IID &, void **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, Guid*, void**, int> QueryInterface;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> AddRef;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> Release;
+
+        [NativeTypeName("LPVOID () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, void*> GetBufferPointer;
+
+        [NativeTypeName("SIZE_T () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, ulong> GetBufferSize;
+
+        [NativeTypeName("HRESULT (BOOL *, UINT32 *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, int*, uint*, int> GetEncoding;
+    }
+}

src/ThridParty/Ghost.DXC/Generated/IDxcBlobUtf8.cs

@@ -0,0 +1,128 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using static Ghost.DXC.Api;
+
+namespace Ghost.DXC;
+
+/// <include file='IDxcBlobUtf8.xml' path='doc/member[@name="IDxcBlobUtf8"]/*' />
+[Guid("3DA636C9-BA71-4024-A301-30CBF125305B")]
+[NativeTypeName("struct IDxcBlobUtf8 : IDxcBlobEncoding")]
+[NativeInheritance("IDxcBlobEncoding")]
+public unsafe partial struct IDxcBlobUtf8 : IDxcBlobUtf8.Interface, INativeGuid
+{
+    static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(in IID_IDxcBlobUtf8);
+
+    public void** lpVtbl;
+
+    /// <inheritdoc cref="IUnknown.QueryInterface" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(0)]
+    [return: NativeTypeName("HRESULT")]
+    public int QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcBlobUtf8*, Guid*, void**, int>)(lpVtbl[0]))((IDxcBlobUtf8*)Unsafe.AsPointer(ref this), riid, ppvObject);
+    }
+
+    /// <inheritdoc cref="IUnknown.AddRef" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(1)]
+    [return: NativeTypeName("ULONG")]
+    public uint AddRef()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcBlobUtf8*, uint>)(lpVtbl[1]))((IDxcBlobUtf8*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IUnknown.Release" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(2)]
+    [return: NativeTypeName("ULONG")]
+    public uint Release()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcBlobUtf8*, uint>)(lpVtbl[2]))((IDxcBlobUtf8*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IDxcBlob.GetBufferPointer" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(3)]
+    [return: NativeTypeName("LPVOID")]
+    public void* GetBufferPointer()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcBlobUtf8*, void*>)(lpVtbl[3]))((IDxcBlobUtf8*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IDxcBlob.GetBufferSize" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(4)]
+    [return: NativeTypeName("SIZE_T")]
+    public ulong GetBufferSize()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcBlobUtf8*, ulong>)(lpVtbl[4]))((IDxcBlobUtf8*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IDxcBlobEncoding.GetEncoding" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(5)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetEncoding([NativeTypeName("BOOL *")] int* pKnown, [NativeTypeName("UINT32 *")] uint* pCodePage)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcBlobUtf8*, int*, uint*, int>)(lpVtbl[5]))((IDxcBlobUtf8*)Unsafe.AsPointer(ref this), pKnown, pCodePage);
+    }
+
+    /// <include file='IDxcBlobUtf8.xml' path='doc/member[@name="IDxcBlobUtf8.GetStringPointer"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(6)]
+    [return: NativeTypeName("LPCSTR")]
+    public sbyte* GetStringPointer()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcBlobUtf8*, sbyte*>)(lpVtbl[6]))((IDxcBlobUtf8*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <include file='IDxcBlobUtf8.xml' path='doc/member[@name="IDxcBlobUtf8.GetStringLength"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(7)]
+    [return: NativeTypeName("SIZE_T")]
+    public ulong GetStringLength()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcBlobUtf8*, ulong>)(lpVtbl[7]))((IDxcBlobUtf8*)Unsafe.AsPointer(ref this));
+    }
+
+    public interface Interface : IDxcBlobEncoding.Interface
+    {
+        [VtblIndex(6)]
+        [return: NativeTypeName("LPCSTR")]
+        sbyte* GetStringPointer();
+
+        [VtblIndex(7)]
+        [return: NativeTypeName("SIZE_T")]
+        ulong GetStringLength();
+    }
+
+    public partial struct Vtbl<TSelf>
+        where TSelf : unmanaged, Interface
+    {
+        [NativeTypeName("HRESULT (const IID &, void **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, Guid*, void**, int> QueryInterface;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> AddRef;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> Release;
+
+        [NativeTypeName("LPVOID () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, void*> GetBufferPointer;
+
+        [NativeTypeName("SIZE_T () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, ulong> GetBufferSize;
+
+        [NativeTypeName("HRESULT (BOOL *, UINT32 *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, int*, uint*, int> GetEncoding;
+
+        [NativeTypeName("LPCSTR () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, sbyte*> GetStringPointer;
+
+        [NativeTypeName("SIZE_T () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, ulong> GetStringLength;
+    }
+}

src/ThridParty/Ghost.DXC/Generated/IDxcBlobWide.cs

@@ -0,0 +1,128 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using static Ghost.DXC.Api;
+
+namespace Ghost.DXC;
+
+/// <include file='IDxcBlobWide.xml' path='doc/member[@name="IDxcBlobWide"]/*' />
+[Guid("A3F84EAB-0FAA-497E-A39C-EE6ED60B2D84")]
+[NativeTypeName("struct IDxcBlobWide : IDxcBlobEncoding")]
+[NativeInheritance("IDxcBlobEncoding")]
+public unsafe partial struct IDxcBlobWide : IDxcBlobWide.Interface, INativeGuid
+{
+    static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(in IID_IDxcBlobWide);
+
+    public void** lpVtbl;
+
+    /// <inheritdoc cref="IUnknown.QueryInterface" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(0)]
+    [return: NativeTypeName("HRESULT")]
+    public int QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcBlobWide*, Guid*, void**, int>)(lpVtbl[0]))((IDxcBlobWide*)Unsafe.AsPointer(ref this), riid, ppvObject);
+    }
+
+    /// <inheritdoc cref="IUnknown.AddRef" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(1)]
+    [return: NativeTypeName("ULONG")]
+    public uint AddRef()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcBlobWide*, uint>)(lpVtbl[1]))((IDxcBlobWide*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IUnknown.Release" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(2)]
+    [return: NativeTypeName("ULONG")]
+    public uint Release()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcBlobWide*, uint>)(lpVtbl[2]))((IDxcBlobWide*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IDxcBlob.GetBufferPointer" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(3)]
+    [return: NativeTypeName("LPVOID")]
+    public void* GetBufferPointer()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcBlobWide*, void*>)(lpVtbl[3]))((IDxcBlobWide*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IDxcBlob.GetBufferSize" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(4)]
+    [return: NativeTypeName("SIZE_T")]
+    public ulong GetBufferSize()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcBlobWide*, ulong>)(lpVtbl[4]))((IDxcBlobWide*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IDxcBlobEncoding.GetEncoding" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(5)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetEncoding([NativeTypeName("BOOL *")] int* pKnown, [NativeTypeName("UINT32 *")] uint* pCodePage)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcBlobWide*, int*, uint*, int>)(lpVtbl[5]))((IDxcBlobWide*)Unsafe.AsPointer(ref this), pKnown, pCodePage);
+    }
+
+    /// <include file='IDxcBlobWide.xml' path='doc/member[@name="IDxcBlobWide.GetStringPointer"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(6)]
+    [return: NativeTypeName("LPCWSTR")]
+    public char* GetStringPointer()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcBlobWide*, char*>)(lpVtbl[6]))((IDxcBlobWide*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <include file='IDxcBlobWide.xml' path='doc/member[@name="IDxcBlobWide.GetStringLength"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(7)]
+    [return: NativeTypeName("SIZE_T")]
+    public ulong GetStringLength()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcBlobWide*, ulong>)(lpVtbl[7]))((IDxcBlobWide*)Unsafe.AsPointer(ref this));
+    }
+
+    public interface Interface : IDxcBlobEncoding.Interface
+    {
+        [VtblIndex(6)]
+        [return: NativeTypeName("LPCWSTR")]
+        char* GetStringPointer();
+
+        [VtblIndex(7)]
+        [return: NativeTypeName("SIZE_T")]
+        ulong GetStringLength();
+    }
+
+    public partial struct Vtbl<TSelf>
+        where TSelf : unmanaged, Interface
+    {
+        [NativeTypeName("HRESULT (const IID &, void **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, Guid*, void**, int> QueryInterface;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> AddRef;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> Release;
+
+        [NativeTypeName("LPVOID () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, void*> GetBufferPointer;
+
+        [NativeTypeName("SIZE_T () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, ulong> GetBufferSize;
+
+        [NativeTypeName("HRESULT (BOOL *, UINT32 *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, int*, uint*, int> GetEncoding;
+
+        [NativeTypeName("LPCWSTR () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, char*> GetStringPointer;
+
+        [NativeTypeName("SIZE_T () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, ulong> GetStringLength;
+    }
+}

src/ThridParty/Ghost.DXC/Generated/IDxcCodeCompleteResults.cs

@@ -0,0 +1,92 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using static Ghost.DXC.Api;
+
+namespace Ghost.DXC;
+
+/// <include file='IDxcCodeCompleteResults.xml' path='doc/member[@name="IDxcCodeCompleteResults"]/*' />
+[Guid("1E06466A-FD8B-45F3-A78F-8A3F76EBB552")]
+[NativeTypeName("struct IDxcCodeCompleteResults : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcCodeCompleteResults : IDxcCodeCompleteResults.Interface, INativeGuid
+{
+    static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(in IID_IDxcCodeCompleteResults);
+
+    public void** lpVtbl;
+
+    /// <inheritdoc cref="IUnknown.QueryInterface" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(0)]
+    [return: NativeTypeName("HRESULT")]
+    public int QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCodeCompleteResults*, Guid*, void**, int>)(lpVtbl[0]))((IDxcCodeCompleteResults*)Unsafe.AsPointer(ref this), riid, ppvObject);
+    }
+
+    /// <inheritdoc cref="IUnknown.AddRef" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(1)]
+    [return: NativeTypeName("ULONG")]
+    public uint AddRef()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCodeCompleteResults*, uint>)(lpVtbl[1]))((IDxcCodeCompleteResults*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IUnknown.Release" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(2)]
+    [return: NativeTypeName("ULONG")]
+    public uint Release()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCodeCompleteResults*, uint>)(lpVtbl[2]))((IDxcCodeCompleteResults*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <include file='IDxcCodeCompleteResults.xml' path='doc/member[@name="IDxcCodeCompleteResults.GetNumResults"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(3)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetNumResults([NativeTypeName("unsigned int *")] uint* pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCodeCompleteResults*, uint*, int>)(lpVtbl[3]))((IDxcCodeCompleteResults*)Unsafe.AsPointer(ref this), pResult);
+    }
+
+    /// <include file='IDxcCodeCompleteResults.xml' path='doc/member[@name="IDxcCodeCompleteResults.GetResultAt"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(4)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetResultAt([NativeTypeName("unsigned int")] uint index, IDxcCompletionResult** pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCodeCompleteResults*, uint, IDxcCompletionResult**, int>)(lpVtbl[4]))((IDxcCodeCompleteResults*)Unsafe.AsPointer(ref this), index, pResult);
+    }
+
+    public interface Interface : IUnknown.Interface
+    {
+        [VtblIndex(3)]
+        [return: NativeTypeName("HRESULT")]
+        int GetNumResults([NativeTypeName("unsigned int *")] uint* pResult);
+
+        [VtblIndex(4)]
+        [return: NativeTypeName("HRESULT")]
+        int GetResultAt([NativeTypeName("unsigned int")] uint index, IDxcCompletionResult** pResult);
+    }
+
+    public partial struct Vtbl<TSelf>
+        where TSelf : unmanaged, Interface
+    {
+        [NativeTypeName("HRESULT (const IID &, void **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, Guid*, void**, int> QueryInterface;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> AddRef;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> Release;
+
+        [NativeTypeName("HRESULT (unsigned int *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint*, int> GetNumResults;
+
+        [NativeTypeName("HRESULT (unsigned int, IDxcCompletionResult **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint, IDxcCompletionResult**, int> GetResultAt;
+    }
+}

src/ThridParty/Ghost.DXC/Generated/IDxcCompiler.cs

@@ -0,0 +1,108 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using static Ghost.DXC.Api;
+
+namespace Ghost.DXC;
+
+/// <include file='IDxcCompiler.xml' path='doc/member[@name="IDxcCompiler"]/*' />
+[Guid("8C210BF3-011F-4422-8D70-6F9ACB8DB617")]
+[NativeTypeName("struct IDxcCompiler : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcCompiler : IDxcCompiler.Interface, INativeGuid
+{
+    static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(in IID_IDxcCompiler);
+
+    public void** lpVtbl;
+
+    /// <inheritdoc cref="IUnknown.QueryInterface" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(0)]
+    [return: NativeTypeName("HRESULT")]
+    public int QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCompiler*, Guid*, void**, int>)(lpVtbl[0]))((IDxcCompiler*)Unsafe.AsPointer(ref this), riid, ppvObject);
+    }
+
+    /// <inheritdoc cref="IUnknown.AddRef" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(1)]
+    [return: NativeTypeName("ULONG")]
+    public uint AddRef()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCompiler*, uint>)(lpVtbl[1]))((IDxcCompiler*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IUnknown.Release" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(2)]
+    [return: NativeTypeName("ULONG")]
+    public uint Release()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCompiler*, uint>)(lpVtbl[2]))((IDxcCompiler*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <include file='IDxcCompiler.xml' path='doc/member[@name="IDxcCompiler.Compile"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(3)]
+    [return: NativeTypeName("HRESULT")]
+    public int Compile(IDxcBlob* pSource, [NativeTypeName("LPCWSTR")] char* pSourceName, [NativeTypeName("LPCWSTR")] char* pEntryPoint, [NativeTypeName("LPCWSTR")] char* pTargetProfile, [NativeTypeName("LPCWSTR *")] char** pArguments, [NativeTypeName("UINT32")] uint argCount, [NativeTypeName("const DxcDefine *")] DxcDefine* pDefines, [NativeTypeName("UINT32")] uint defineCount, IDxcIncludeHandler* pIncludeHandler, IDxcOperationResult** ppResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCompiler*, IDxcBlob*, char*, char*, char*, char**, uint, DxcDefine*, uint, IDxcIncludeHandler*, IDxcOperationResult**, int>)(lpVtbl[3]))((IDxcCompiler*)Unsafe.AsPointer(ref this), pSource, pSourceName, pEntryPoint, pTargetProfile, pArguments, argCount, pDefines, defineCount, pIncludeHandler, ppResult);
+    }
+
+    /// <include file='IDxcCompiler.xml' path='doc/member[@name="IDxcCompiler.Preprocess"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(4)]
+    [return: NativeTypeName("HRESULT")]
+    public int Preprocess(IDxcBlob* pSource, [NativeTypeName("LPCWSTR")] char* pSourceName, [NativeTypeName("LPCWSTR *")] char** pArguments, [NativeTypeName("UINT32")] uint argCount, [NativeTypeName("const DxcDefine *")] DxcDefine* pDefines, [NativeTypeName("UINT32")] uint defineCount, IDxcIncludeHandler* pIncludeHandler, IDxcOperationResult** ppResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCompiler*, IDxcBlob*, char*, char**, uint, DxcDefine*, uint, IDxcIncludeHandler*, IDxcOperationResult**, int>)(lpVtbl[4]))((IDxcCompiler*)Unsafe.AsPointer(ref this), pSource, pSourceName, pArguments, argCount, pDefines, defineCount, pIncludeHandler, ppResult);
+    }
+
+    /// <include file='IDxcCompiler.xml' path='doc/member[@name="IDxcCompiler.Disassemble"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(5)]
+    [return: NativeTypeName("HRESULT")]
+    public int Disassemble(IDxcBlob* pSource, IDxcBlobEncoding** ppDisassembly)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCompiler*, IDxcBlob*, IDxcBlobEncoding**, int>)(lpVtbl[5]))((IDxcCompiler*)Unsafe.AsPointer(ref this), pSource, ppDisassembly);
+    }
+
+    public interface Interface : IUnknown.Interface
+    {
+        [VtblIndex(3)]
+        [return: NativeTypeName("HRESULT")]
+        int Compile(IDxcBlob* pSource, [NativeTypeName("LPCWSTR")] char* pSourceName, [NativeTypeName("LPCWSTR")] char* pEntryPoint, [NativeTypeName("LPCWSTR")] char* pTargetProfile, [NativeTypeName("LPCWSTR *")] char** pArguments, [NativeTypeName("UINT32")] uint argCount, [NativeTypeName("const DxcDefine *")] DxcDefine* pDefines, [NativeTypeName("UINT32")] uint defineCount, IDxcIncludeHandler* pIncludeHandler, IDxcOperationResult** ppResult);
+
+        [VtblIndex(4)]
+        [return: NativeTypeName("HRESULT")]
+        int Preprocess(IDxcBlob* pSource, [NativeTypeName("LPCWSTR")] char* pSourceName, [NativeTypeName("LPCWSTR *")] char** pArguments, [NativeTypeName("UINT32")] uint argCount, [NativeTypeName("const DxcDefine *")] DxcDefine* pDefines, [NativeTypeName("UINT32")] uint defineCount, IDxcIncludeHandler* pIncludeHandler, IDxcOperationResult** ppResult);
+
+        [VtblIndex(5)]
+        [return: NativeTypeName("HRESULT")]
+        int Disassemble(IDxcBlob* pSource, IDxcBlobEncoding** ppDisassembly);
+    }
+
+    public partial struct Vtbl<TSelf>
+        where TSelf : unmanaged, Interface
+    {
+        [NativeTypeName("HRESULT (const IID &, void **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, Guid*, void**, int> QueryInterface;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> AddRef;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> Release;
+
+        [NativeTypeName("HRESULT (IDxcBlob *, LPCWSTR, LPCWSTR, LPCWSTR, LPCWSTR *, UINT32, const DxcDefine *, UINT32, IDxcIncludeHandler *, IDxcOperationResult **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcBlob*, char*, char*, char*, char**, uint, DxcDefine*, uint, IDxcIncludeHandler*, IDxcOperationResult**, int> Compile;
+
+        [NativeTypeName("HRESULT (IDxcBlob *, LPCWSTR, LPCWSTR *, UINT32, const DxcDefine *, UINT32, IDxcIncludeHandler *, IDxcOperationResult **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcBlob*, char*, char**, uint, DxcDefine*, uint, IDxcIncludeHandler*, IDxcOperationResult**, int> Preprocess;
+
+        [NativeTypeName("HRESULT (IDxcBlob *, IDxcBlobEncoding **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcBlob*, IDxcBlobEncoding**, int> Disassemble;
+    }
+}

src/ThridParty/Ghost.DXC/Generated/IDxcCompiler2.cs

@@ -0,0 +1,112 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using static Ghost.DXC.Api;
+
+namespace Ghost.DXC;
+
+/// <include file='IDxcCompiler2.xml' path='doc/member[@name="IDxcCompiler2"]/*' />
+[Guid("A005A9D9-B8BB-4594-B5C9-0E633BEC4D37")]
+[NativeTypeName("struct IDxcCompiler2 : IDxcCompiler")]
+[NativeInheritance("IDxcCompiler")]
+public unsafe partial struct IDxcCompiler2 : IDxcCompiler2.Interface, INativeGuid
+{
+    static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(in IID_IDxcCompiler2);
+
+    public void** lpVtbl;
+
+    /// <inheritdoc cref="IUnknown.QueryInterface" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(0)]
+    [return: NativeTypeName("HRESULT")]
+    public int QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCompiler2*, Guid*, void**, int>)(lpVtbl[0]))((IDxcCompiler2*)Unsafe.AsPointer(ref this), riid, ppvObject);
+    }
+
+    /// <inheritdoc cref="IUnknown.AddRef" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(1)]
+    [return: NativeTypeName("ULONG")]
+    public uint AddRef()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCompiler2*, uint>)(lpVtbl[1]))((IDxcCompiler2*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IUnknown.Release" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(2)]
+    [return: NativeTypeName("ULONG")]
+    public uint Release()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCompiler2*, uint>)(lpVtbl[2]))((IDxcCompiler2*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IDxcCompiler.Compile" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(3)]
+    [return: NativeTypeName("HRESULT")]
+    public int Compile(IDxcBlob* pSource, [NativeTypeName("LPCWSTR")] char* pSourceName, [NativeTypeName("LPCWSTR")] char* pEntryPoint, [NativeTypeName("LPCWSTR")] char* pTargetProfile, [NativeTypeName("LPCWSTR *")] char** pArguments, [NativeTypeName("UINT32")] uint argCount, [NativeTypeName("const DxcDefine *")] DxcDefine* pDefines, [NativeTypeName("UINT32")] uint defineCount, IDxcIncludeHandler* pIncludeHandler, IDxcOperationResult** ppResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCompiler2*, IDxcBlob*, char*, char*, char*, char**, 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)]
+    [return: NativeTypeName("HRESULT")]
+    public int Preprocess(IDxcBlob* pSource, [NativeTypeName("LPCWSTR")] char* pSourceName, [NativeTypeName("LPCWSTR *")] char** pArguments, [NativeTypeName("UINT32")] uint argCount, [NativeTypeName("const DxcDefine *")] DxcDefine* pDefines, [NativeTypeName("UINT32")] uint defineCount, IDxcIncludeHandler* pIncludeHandler, IDxcOperationResult** ppResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCompiler2*, IDxcBlob*, char*, char**, 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)]
+    [return: NativeTypeName("HRESULT")]
+    public int Disassemble(IDxcBlob* pSource, IDxcBlobEncoding** ppDisassembly)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCompiler2*, IDxcBlob*, IDxcBlobEncoding**, int>)(lpVtbl[5]))((IDxcCompiler2*)Unsafe.AsPointer(ref this), pSource, ppDisassembly);
+    }
+
+    /// <include file='IDxcCompiler2.xml' path='doc/member[@name="IDxcCompiler2.CompileWithDebug"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(6)]
+    [return: NativeTypeName("HRESULT")]
+    public int CompileWithDebug(IDxcBlob* pSource, [NativeTypeName("LPCWSTR")] char* pSourceName, [NativeTypeName("LPCWSTR")] char* pEntryPoint, [NativeTypeName("LPCWSTR")] char* pTargetProfile, [NativeTypeName("LPCWSTR *")] char** pArguments, [NativeTypeName("UINT32")] uint argCount, [NativeTypeName("const DxcDefine *")] DxcDefine* pDefines, [NativeTypeName("UINT32")] uint defineCount, IDxcIncludeHandler* pIncludeHandler, IDxcOperationResult** ppResult, [NativeTypeName("LPWSTR *")] char** ppDebugBlobName, IDxcBlob** ppDebugBlob)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCompiler2*, IDxcBlob*, char*, char*, char*, char**, uint, DxcDefine*, uint, IDxcIncludeHandler*, IDxcOperationResult**, char**, IDxcBlob**, int>)(lpVtbl[6]))((IDxcCompiler2*)Unsafe.AsPointer(ref this), pSource, pSourceName, pEntryPoint, pTargetProfile, pArguments, argCount, pDefines, defineCount, pIncludeHandler, ppResult, ppDebugBlobName, ppDebugBlob);
+    }
+
+    public interface Interface : IDxcCompiler.Interface
+    {
+        [VtblIndex(6)]
+        [return: NativeTypeName("HRESULT")]
+        int CompileWithDebug(IDxcBlob* pSource, [NativeTypeName("LPCWSTR")] char* pSourceName, [NativeTypeName("LPCWSTR")] char* pEntryPoint, [NativeTypeName("LPCWSTR")] char* pTargetProfile, [NativeTypeName("LPCWSTR *")] char** pArguments, [NativeTypeName("UINT32")] uint argCount, [NativeTypeName("const DxcDefine *")] DxcDefine* pDefines, [NativeTypeName("UINT32")] uint defineCount, IDxcIncludeHandler* pIncludeHandler, IDxcOperationResult** ppResult, [NativeTypeName("LPWSTR *")] char** ppDebugBlobName, IDxcBlob** ppDebugBlob);
+    }
+
+    public partial struct Vtbl<TSelf>
+        where TSelf : unmanaged, Interface
+    {
+        [NativeTypeName("HRESULT (const IID &, void **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, Guid*, void**, int> QueryInterface;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> AddRef;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> Release;
+
+        [NativeTypeName("HRESULT (IDxcBlob *, LPCWSTR, LPCWSTR, LPCWSTR, LPCWSTR *, UINT32, const DxcDefine *, UINT32, IDxcIncludeHandler *, IDxcOperationResult **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcBlob*, char*, char*, char*, char**, uint, DxcDefine*, uint, IDxcIncludeHandler*, IDxcOperationResult**, int> Compile;
+
+        [NativeTypeName("HRESULT (IDxcBlob *, LPCWSTR, LPCWSTR *, UINT32, const DxcDefine *, UINT32, IDxcIncludeHandler *, IDxcOperationResult **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcBlob*, char*, char**, uint, DxcDefine*, uint, IDxcIncludeHandler*, IDxcOperationResult**, int> Preprocess;
+
+        [NativeTypeName("HRESULT (IDxcBlob *, IDxcBlobEncoding **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcBlob*, IDxcBlobEncoding**, int> Disassemble;
+
+        [NativeTypeName("HRESULT (IDxcBlob *, LPCWSTR, LPCWSTR, LPCWSTR, LPCWSTR *, UINT32, const DxcDefine *, UINT32, IDxcIncludeHandler *, IDxcOperationResult **, LPWSTR *, IDxcBlob **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcBlob*, char*, char*, char*, char**, uint, DxcDefine*, uint, IDxcIncludeHandler*, IDxcOperationResult**, char**, IDxcBlob**, int> CompileWithDebug;
+    }
+}

src/ThridParty/Ghost.DXC/Generated/IDxcCompiler3.cs

@@ -0,0 +1,92 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using static Ghost.DXC.Api;
+
+namespace Ghost.DXC;
+
+/// <include file='IDxcCompiler3.xml' path='doc/member[@name="IDxcCompiler3"]/*' />
+[Guid("228B4687-5A6A-4730-900C-9702B2203F54")]
+[NativeTypeName("struct IDxcCompiler3 : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcCompiler3 : IDxcCompiler3.Interface, INativeGuid
+{
+    static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(in IID_IDxcCompiler3);
+
+    public void** lpVtbl;
+
+    /// <inheritdoc cref="IUnknown.QueryInterface" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(0)]
+    [return: NativeTypeName("HRESULT")]
+    public int QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCompiler3*, Guid*, void**, int>)(lpVtbl[0]))((IDxcCompiler3*)Unsafe.AsPointer(ref this), riid, ppvObject);
+    }
+
+    /// <inheritdoc cref="IUnknown.AddRef" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(1)]
+    [return: NativeTypeName("ULONG")]
+    public uint AddRef()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCompiler3*, uint>)(lpVtbl[1]))((IDxcCompiler3*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IUnknown.Release" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(2)]
+    [return: NativeTypeName("ULONG")]
+    public uint Release()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCompiler3*, uint>)(lpVtbl[2]))((IDxcCompiler3*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <include file='IDxcCompiler3.xml' path='doc/member[@name="IDxcCompiler3.Compile"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(3)]
+    [return: NativeTypeName("HRESULT")]
+    public int Compile([NativeTypeName("const DxcBuffer *")] DxcBuffer* pSource, [NativeTypeName("LPCWSTR *")] char** pArguments, [NativeTypeName("UINT32")] uint argCount, IDxcIncludeHandler* pIncludeHandler, [NativeTypeName("const IID &")] Guid* riid, [NativeTypeName("LPVOID *")] void** ppResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCompiler3*, DxcBuffer*, char**, uint, IDxcIncludeHandler*, Guid*, void**, int>)(lpVtbl[3]))((IDxcCompiler3*)Unsafe.AsPointer(ref this), pSource, pArguments, argCount, pIncludeHandler, riid, ppResult);
+    }
+
+    /// <include file='IDxcCompiler3.xml' path='doc/member[@name="IDxcCompiler3.Disassemble"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(4)]
+    [return: NativeTypeName("HRESULT")]
+    public int Disassemble([NativeTypeName("const DxcBuffer *")] DxcBuffer* pObject, [NativeTypeName("const IID &")] Guid* riid, [NativeTypeName("LPVOID *")] void** ppResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCompiler3*, DxcBuffer*, Guid*, void**, int>)(lpVtbl[4]))((IDxcCompiler3*)Unsafe.AsPointer(ref this), pObject, riid, ppResult);
+    }
+
+    public interface Interface : IUnknown.Interface
+    {
+        [VtblIndex(3)]
+        [return: NativeTypeName("HRESULT")]
+        int Compile([NativeTypeName("const DxcBuffer *")] DxcBuffer* pSource, [NativeTypeName("LPCWSTR *")] char** pArguments, [NativeTypeName("UINT32")] uint argCount, IDxcIncludeHandler* pIncludeHandler, [NativeTypeName("const IID &")] Guid* riid, [NativeTypeName("LPVOID *")] void** ppResult);
+
+        [VtblIndex(4)]
+        [return: NativeTypeName("HRESULT")]
+        int Disassemble([NativeTypeName("const DxcBuffer *")] DxcBuffer* pObject, [NativeTypeName("const IID &")] Guid* riid, [NativeTypeName("LPVOID *")] void** ppResult);
+    }
+
+    public partial struct Vtbl<TSelf>
+        where TSelf : unmanaged, Interface
+    {
+        [NativeTypeName("HRESULT (const IID &, void **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, Guid*, void**, int> QueryInterface;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> AddRef;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> Release;
+
+        [NativeTypeName("HRESULT (const DxcBuffer *, LPCWSTR *, UINT32, IDxcIncludeHandler *, const IID &, LPVOID *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, DxcBuffer*, char**, uint, IDxcIncludeHandler*, Guid*, void**, int> Compile;
+
+        [NativeTypeName("HRESULT (const DxcBuffer *, const IID &, LPVOID *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, DxcBuffer*, Guid*, void**, int> Disassemble;
+    }
+}

src/ThridParty/Ghost.DXC/Generated/IDxcCompilerArgs.cs

@@ -0,0 +1,140 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using static Ghost.DXC.Api;
+
+namespace Ghost.DXC;
+
+/// <include file='IDxcCompilerArgs.xml' path='doc/member[@name="IDxcCompilerArgs"]/*' />
+[Guid("73EFFE2A-70DC-45F8-9690-EFF64C02429D")]
+[NativeTypeName("struct IDxcCompilerArgs : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcCompilerArgs : IDxcCompilerArgs.Interface, INativeGuid
+{
+    static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(in IID_IDxcCompilerArgs);
+
+    public void** lpVtbl;
+
+    /// <inheritdoc cref="IUnknown.QueryInterface" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(0)]
+    [return: NativeTypeName("HRESULT")]
+    public int QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCompilerArgs*, Guid*, void**, int>)(lpVtbl[0]))((IDxcCompilerArgs*)Unsafe.AsPointer(ref this), riid, ppvObject);
+    }
+
+    /// <inheritdoc cref="IUnknown.AddRef" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(1)]
+    [return: NativeTypeName("ULONG")]
+    public uint AddRef()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCompilerArgs*, uint>)(lpVtbl[1]))((IDxcCompilerArgs*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IUnknown.Release" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(2)]
+    [return: NativeTypeName("ULONG")]
+    public uint Release()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCompilerArgs*, uint>)(lpVtbl[2]))((IDxcCompilerArgs*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <include file='IDxcCompilerArgs.xml' path='doc/member[@name="IDxcCompilerArgs.GetArguments"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(3)]
+    [return: NativeTypeName("LPCWSTR *")]
+    public char** GetArguments()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCompilerArgs*, char**>)(lpVtbl[3]))((IDxcCompilerArgs*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <include file='IDxcCompilerArgs.xml' path='doc/member[@name="IDxcCompilerArgs.GetCount"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(4)]
+    [return: NativeTypeName("UINT32")]
+    public uint GetCount()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCompilerArgs*, uint>)(lpVtbl[4]))((IDxcCompilerArgs*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <include file='IDxcCompilerArgs.xml' path='doc/member[@name="IDxcCompilerArgs.AddArguments"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(5)]
+    [return: NativeTypeName("HRESULT")]
+    public int AddArguments([NativeTypeName("LPCWSTR *")] char** pArguments, [NativeTypeName("UINT32")] uint argCount)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCompilerArgs*, char**, uint, int>)(lpVtbl[5]))((IDxcCompilerArgs*)Unsafe.AsPointer(ref this), pArguments, argCount);
+    }
+
+    /// <include file='IDxcCompilerArgs.xml' path='doc/member[@name="IDxcCompilerArgs.AddArgumentsUTF8"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(6)]
+    [return: NativeTypeName("HRESULT")]
+    public int AddArgumentsUTF8([NativeTypeName("LPCSTR *")] sbyte** pArguments, [NativeTypeName("UINT32")] uint argCount)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCompilerArgs*, sbyte**, uint, int>)(lpVtbl[6]))((IDxcCompilerArgs*)Unsafe.AsPointer(ref this), pArguments, argCount);
+    }
+
+    /// <include file='IDxcCompilerArgs.xml' path='doc/member[@name="IDxcCompilerArgs.AddDefines"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(7)]
+    [return: NativeTypeName("HRESULT")]
+    public int AddDefines([NativeTypeName("const DxcDefine *")] DxcDefine* pDefines, [NativeTypeName("UINT32")] uint defineCount)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCompilerArgs*, DxcDefine*, uint, int>)(lpVtbl[7]))((IDxcCompilerArgs*)Unsafe.AsPointer(ref this), pDefines, defineCount);
+    }
+
+    public interface Interface : IUnknown.Interface
+    {
+        [VtblIndex(3)]
+        [return: NativeTypeName("LPCWSTR *")]
+        char** GetArguments();
+
+        [VtblIndex(4)]
+        [return: NativeTypeName("UINT32")]
+        uint GetCount();
+
+        [VtblIndex(5)]
+        [return: NativeTypeName("HRESULT")]
+        int AddArguments([NativeTypeName("LPCWSTR *")] char** pArguments, [NativeTypeName("UINT32")] uint argCount);
+
+        [VtblIndex(6)]
+        [return: NativeTypeName("HRESULT")]
+        int AddArgumentsUTF8([NativeTypeName("LPCSTR *")] sbyte** pArguments, [NativeTypeName("UINT32")] uint argCount);
+
+        [VtblIndex(7)]
+        [return: NativeTypeName("HRESULT")]
+        int AddDefines([NativeTypeName("const DxcDefine *")] DxcDefine* pDefines, [NativeTypeName("UINT32")] uint defineCount);
+    }
+
+    public partial struct Vtbl<TSelf>
+        where TSelf : unmanaged, Interface
+    {
+        [NativeTypeName("HRESULT (const IID &, void **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, Guid*, void**, int> QueryInterface;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> AddRef;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> Release;
+
+        [NativeTypeName("LPCWSTR *() __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, char**> GetArguments;
+
+        [NativeTypeName("UINT32 () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> GetCount;
+
+        [NativeTypeName("HRESULT (LPCWSTR *, UINT32) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, char**, uint, int> AddArguments;
+
+        [NativeTypeName("HRESULT (LPCSTR *, UINT32) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, sbyte**, uint, int> AddArgumentsUTF8;
+
+        [NativeTypeName("HRESULT (const DxcDefine *, UINT32) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, DxcDefine*, uint, int> AddDefines;
+    }
+}

src/ThridParty/Ghost.DXC/Generated/IDxcCompletionResult.cs

@@ -0,0 +1,92 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using static Ghost.DXC.Api;
+
+namespace Ghost.DXC;
+
+/// <include file='IDxcCompletionResult.xml' path='doc/member[@name="IDxcCompletionResult"]/*' />
+[Guid("943C0588-22D0-4784-86FC-701F802AC2B6")]
+[NativeTypeName("struct IDxcCompletionResult : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcCompletionResult : IDxcCompletionResult.Interface, INativeGuid
+{
+    static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(in IID_IDxcCompletionResult);
+
+    public void** lpVtbl;
+
+    /// <inheritdoc cref="IUnknown.QueryInterface" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(0)]
+    [return: NativeTypeName("HRESULT")]
+    public int QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCompletionResult*, Guid*, void**, int>)(lpVtbl[0]))((IDxcCompletionResult*)Unsafe.AsPointer(ref this), riid, ppvObject);
+    }
+
+    /// <inheritdoc cref="IUnknown.AddRef" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(1)]
+    [return: NativeTypeName("ULONG")]
+    public uint AddRef()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCompletionResult*, uint>)(lpVtbl[1]))((IDxcCompletionResult*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IUnknown.Release" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(2)]
+    [return: NativeTypeName("ULONG")]
+    public uint Release()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCompletionResult*, uint>)(lpVtbl[2]))((IDxcCompletionResult*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <include file='IDxcCompletionResult.xml' path='doc/member[@name="IDxcCompletionResult.GetCursorKind"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(3)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetCursorKind(DxcCursorKind* pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCompletionResult*, DxcCursorKind*, int>)(lpVtbl[3]))((IDxcCompletionResult*)Unsafe.AsPointer(ref this), pResult);
+    }
+
+    /// <include file='IDxcCompletionResult.xml' path='doc/member[@name="IDxcCompletionResult.GetCompletionString"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(4)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetCompletionString(IDxcCompletionString** pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCompletionResult*, IDxcCompletionString**, int>)(lpVtbl[4]))((IDxcCompletionResult*)Unsafe.AsPointer(ref this), pResult);
+    }
+
+    public interface Interface : IUnknown.Interface
+    {
+        [VtblIndex(3)]
+        [return: NativeTypeName("HRESULT")]
+        int GetCursorKind(DxcCursorKind* pResult);
+
+        [VtblIndex(4)]
+        [return: NativeTypeName("HRESULT")]
+        int GetCompletionString(IDxcCompletionString** pResult);
+    }
+
+    public partial struct Vtbl<TSelf>
+        where TSelf : unmanaged, Interface
+    {
+        [NativeTypeName("HRESULT (const IID &, void **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, Guid*, void**, int> QueryInterface;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> AddRef;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> Release;
+
+        [NativeTypeName("HRESULT (DxcCursorKind *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, DxcCursorKind*, int> GetCursorKind;
+
+        [NativeTypeName("HRESULT (IDxcCompletionString **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcCompletionString**, int> GetCompletionString;
+    }
+}

src/ThridParty/Ghost.DXC/Generated/IDxcCompletionString.cs

@@ -0,0 +1,108 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using static Ghost.DXC.Api;
+
+namespace Ghost.DXC;
+
+/// <include file='IDxcCompletionString.xml' path='doc/member[@name="IDxcCompletionString"]/*' />
+[Guid("06B51E0F-A605-4C69-A110-CD6E14B58EEC")]
+[NativeTypeName("struct IDxcCompletionString : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcCompletionString : IDxcCompletionString.Interface, INativeGuid
+{
+    static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(in IID_IDxcCompletionString);
+
+    public void** lpVtbl;
+
+    /// <inheritdoc cref="IUnknown.QueryInterface" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(0)]
+    [return: NativeTypeName("HRESULT")]
+    public int QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCompletionString*, Guid*, void**, int>)(lpVtbl[0]))((IDxcCompletionString*)Unsafe.AsPointer(ref this), riid, ppvObject);
+    }
+
+    /// <inheritdoc cref="IUnknown.AddRef" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(1)]
+    [return: NativeTypeName("ULONG")]
+    public uint AddRef()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCompletionString*, uint>)(lpVtbl[1]))((IDxcCompletionString*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IUnknown.Release" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(2)]
+    [return: NativeTypeName("ULONG")]
+    public uint Release()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCompletionString*, uint>)(lpVtbl[2]))((IDxcCompletionString*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <include file='IDxcCompletionString.xml' path='doc/member[@name="IDxcCompletionString.GetNumCompletionChunks"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(3)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetNumCompletionChunks([NativeTypeName("unsigned int *")] uint* pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCompletionString*, uint*, int>)(lpVtbl[3]))((IDxcCompletionString*)Unsafe.AsPointer(ref this), pResult);
+    }
+
+    /// <include file='IDxcCompletionString.xml' path='doc/member[@name="IDxcCompletionString.GetCompletionChunkKind"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(4)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetCompletionChunkKind([NativeTypeName("unsigned int")] uint chunkNumber, DxcCompletionChunkKind* pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCompletionString*, uint, DxcCompletionChunkKind*, int>)(lpVtbl[4]))((IDxcCompletionString*)Unsafe.AsPointer(ref this), chunkNumber, pResult);
+    }
+
+    /// <include file='IDxcCompletionString.xml' path='doc/member[@name="IDxcCompletionString.GetCompletionChunkText"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(5)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetCompletionChunkText([NativeTypeName("unsigned int")] uint chunkNumber, [NativeTypeName("LPSTR *")] sbyte** pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCompletionString*, uint, sbyte**, int>)(lpVtbl[5]))((IDxcCompletionString*)Unsafe.AsPointer(ref this), chunkNumber, pResult);
+    }
+
+    public interface Interface : IUnknown.Interface
+    {
+        [VtblIndex(3)]
+        [return: NativeTypeName("HRESULT")]
+        int GetNumCompletionChunks([NativeTypeName("unsigned int *")] uint* pResult);
+
+        [VtblIndex(4)]
+        [return: NativeTypeName("HRESULT")]
+        int GetCompletionChunkKind([NativeTypeName("unsigned int")] uint chunkNumber, DxcCompletionChunkKind* pResult);
+
+        [VtblIndex(5)]
+        [return: NativeTypeName("HRESULT")]
+        int GetCompletionChunkText([NativeTypeName("unsigned int")] uint chunkNumber, [NativeTypeName("LPSTR *")] sbyte** pResult);
+    }
+
+    public partial struct Vtbl<TSelf>
+        where TSelf : unmanaged, Interface
+    {
+        [NativeTypeName("HRESULT (const IID &, void **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, Guid*, void**, int> QueryInterface;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> AddRef;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> Release;
+
+        [NativeTypeName("HRESULT (unsigned int *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint*, int> GetNumCompletionChunks;
+
+        [NativeTypeName("HRESULT (unsigned int, DxcCompletionChunkKind *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint, DxcCompletionChunkKind*, int> GetCompletionChunkKind;
+
+        [NativeTypeName("HRESULT (unsigned int, LPSTR *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint, sbyte**, int> GetCompletionChunkText;
+    }
+}

src/ThridParty/Ghost.DXC/Generated/IDxcContainerBuilder.cs

@@ -0,0 +1,124 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using static Ghost.DXC.Api;
+
+namespace Ghost.DXC;
+
+/// <include file='IDxcContainerBuilder.xml' path='doc/member[@name="IDxcContainerBuilder"]/*' />
+[Guid("334B1F50-2292-4B35-99A1-25588D8C17FE")]
+[NativeTypeName("struct IDxcContainerBuilder : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcContainerBuilder : IDxcContainerBuilder.Interface, INativeGuid
+{
+    static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(in IID_IDxcContainerBuilder);
+
+    public void** lpVtbl;
+
+    /// <inheritdoc cref="IUnknown.QueryInterface" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(0)]
+    [return: NativeTypeName("HRESULT")]
+    public int QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcContainerBuilder*, Guid*, void**, int>)(lpVtbl[0]))((IDxcContainerBuilder*)Unsafe.AsPointer(ref this), riid, ppvObject);
+    }
+
+    /// <inheritdoc cref="IUnknown.AddRef" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(1)]
+    [return: NativeTypeName("ULONG")]
+    public uint AddRef()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcContainerBuilder*, uint>)(lpVtbl[1]))((IDxcContainerBuilder*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IUnknown.Release" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(2)]
+    [return: NativeTypeName("ULONG")]
+    public uint Release()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcContainerBuilder*, uint>)(lpVtbl[2]))((IDxcContainerBuilder*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <include file='IDxcContainerBuilder.xml' path='doc/member[@name="IDxcContainerBuilder.Load"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(3)]
+    [return: NativeTypeName("HRESULT")]
+    public int Load(IDxcBlob* pDxilContainerHeader)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcContainerBuilder*, IDxcBlob*, int>)(lpVtbl[3]))((IDxcContainerBuilder*)Unsafe.AsPointer(ref this), pDxilContainerHeader);
+    }
+
+    /// <include file='IDxcContainerBuilder.xml' path='doc/member[@name="IDxcContainerBuilder.AddPart"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(4)]
+    [return: NativeTypeName("HRESULT")]
+    public int AddPart([NativeTypeName("UINT32")] uint fourCC, IDxcBlob* pSource)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcContainerBuilder*, uint, IDxcBlob*, int>)(lpVtbl[4]))((IDxcContainerBuilder*)Unsafe.AsPointer(ref this), fourCC, pSource);
+    }
+
+    /// <include file='IDxcContainerBuilder.xml' path='doc/member[@name="IDxcContainerBuilder.RemovePart"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(5)]
+    [return: NativeTypeName("HRESULT")]
+    public int RemovePart([NativeTypeName("UINT32")] uint fourCC)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcContainerBuilder*, uint, int>)(lpVtbl[5]))((IDxcContainerBuilder*)Unsafe.AsPointer(ref this), fourCC);
+    }
+
+    /// <include file='IDxcContainerBuilder.xml' path='doc/member[@name="IDxcContainerBuilder.SerializeContainer"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(6)]
+    [return: NativeTypeName("HRESULT")]
+    public int SerializeContainer(IDxcOperationResult** ppResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcContainerBuilder*, IDxcOperationResult**, int>)(lpVtbl[6]))((IDxcContainerBuilder*)Unsafe.AsPointer(ref this), ppResult);
+    }
+
+    public interface Interface : IUnknown.Interface
+    {
+        [VtblIndex(3)]
+        [return: NativeTypeName("HRESULT")]
+        int Load(IDxcBlob* pDxilContainerHeader);
+
+        [VtblIndex(4)]
+        [return: NativeTypeName("HRESULT")]
+        int AddPart([NativeTypeName("UINT32")] uint fourCC, IDxcBlob* pSource);
+
+        [VtblIndex(5)]
+        [return: NativeTypeName("HRESULT")]
+        int RemovePart([NativeTypeName("UINT32")] uint fourCC);
+
+        [VtblIndex(6)]
+        [return: NativeTypeName("HRESULT")]
+        int SerializeContainer(IDxcOperationResult** ppResult);
+    }
+
+    public partial struct Vtbl<TSelf>
+        where TSelf : unmanaged, Interface
+    {
+        [NativeTypeName("HRESULT (const IID &, void **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, Guid*, void**, int> QueryInterface;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> AddRef;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> Release;
+
+        [NativeTypeName("HRESULT (IDxcBlob *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcBlob*, int> Load;
+
+        [NativeTypeName("HRESULT (UINT32, IDxcBlob *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint, IDxcBlob*, int> AddPart;
+
+        [NativeTypeName("HRESULT (UINT32) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint, int> RemovePart;
+
+        [NativeTypeName("HRESULT (IDxcOperationResult **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcOperationResult**, int> SerializeContainer;
+    }
+}

src/ThridParty/Ghost.DXC/Generated/IDxcContainerReflection.cs

@@ -0,0 +1,156 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using static Ghost.DXC.Api;
+
+namespace Ghost.DXC;
+
+/// <include file='IDxcContainerReflection.xml' path='doc/member[@name="IDxcContainerReflection"]/*' />
+[Guid("D2C21B26-8350-4BDC-976A-331CE6F4C54C")]
+[NativeTypeName("struct IDxcContainerReflection : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcContainerReflection : IDxcContainerReflection.Interface, INativeGuid
+{
+    static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(in IID_IDxcContainerReflection);
+
+    public void** lpVtbl;
+
+    /// <inheritdoc cref="IUnknown.QueryInterface" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(0)]
+    [return: NativeTypeName("HRESULT")]
+    public int QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcContainerReflection*, Guid*, void**, int>)(lpVtbl[0]))((IDxcContainerReflection*)Unsafe.AsPointer(ref this), riid, ppvObject);
+    }
+
+    /// <inheritdoc cref="IUnknown.AddRef" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(1)]
+    [return: NativeTypeName("ULONG")]
+    public uint AddRef()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcContainerReflection*, uint>)(lpVtbl[1]))((IDxcContainerReflection*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IUnknown.Release" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(2)]
+    [return: NativeTypeName("ULONG")]
+    public uint Release()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcContainerReflection*, uint>)(lpVtbl[2]))((IDxcContainerReflection*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <include file='IDxcContainerReflection.xml' path='doc/member[@name="IDxcContainerReflection.Load"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(3)]
+    [return: NativeTypeName("HRESULT")]
+    public int Load(IDxcBlob* pContainer)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcContainerReflection*, IDxcBlob*, int>)(lpVtbl[3]))((IDxcContainerReflection*)Unsafe.AsPointer(ref this), pContainer);
+    }
+
+    /// <include file='IDxcContainerReflection.xml' path='doc/member[@name="IDxcContainerReflection.GetPartCount"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(4)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetPartCount([NativeTypeName("UINT32 *")] uint* pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcContainerReflection*, uint*, int>)(lpVtbl[4]))((IDxcContainerReflection*)Unsafe.AsPointer(ref this), pResult);
+    }
+
+    /// <include file='IDxcContainerReflection.xml' path='doc/member[@name="IDxcContainerReflection.GetPartKind"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(5)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetPartKind([NativeTypeName("UINT32")] uint idx, [NativeTypeName("UINT32 *")] uint* pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcContainerReflection*, uint, uint*, int>)(lpVtbl[5]))((IDxcContainerReflection*)Unsafe.AsPointer(ref this), idx, pResult);
+    }
+
+    /// <include file='IDxcContainerReflection.xml' path='doc/member[@name="IDxcContainerReflection.GetPartContent"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(6)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetPartContent([NativeTypeName("UINT32")] uint idx, IDxcBlob** ppResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcContainerReflection*, uint, IDxcBlob**, int>)(lpVtbl[6]))((IDxcContainerReflection*)Unsafe.AsPointer(ref this), idx, ppResult);
+    }
+
+    /// <include file='IDxcContainerReflection.xml' path='doc/member[@name="IDxcContainerReflection.FindFirstPartKind"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(7)]
+    [return: NativeTypeName("HRESULT")]
+    public int FindFirstPartKind([NativeTypeName("UINT32")] uint kind, [NativeTypeName("UINT32 *")] uint* pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcContainerReflection*, uint, uint*, int>)(lpVtbl[7]))((IDxcContainerReflection*)Unsafe.AsPointer(ref this), kind, pResult);
+    }
+
+    /// <include file='IDxcContainerReflection.xml' path='doc/member[@name="IDxcContainerReflection.GetPartReflection"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(8)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetPartReflection([NativeTypeName("UINT32")] uint idx, [NativeTypeName("const IID &")] Guid* iid, void** ppvObject)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcContainerReflection*, uint, Guid*, void**, int>)(lpVtbl[8]))((IDxcContainerReflection*)Unsafe.AsPointer(ref this), idx, iid, ppvObject);
+    }
+
+    public interface Interface : IUnknown.Interface
+    {
+        [VtblIndex(3)]
+        [return: NativeTypeName("HRESULT")]
+        int Load(IDxcBlob* pContainer);
+
+        [VtblIndex(4)]
+        [return: NativeTypeName("HRESULT")]
+        int GetPartCount([NativeTypeName("UINT32 *")] uint* pResult);
+
+        [VtblIndex(5)]
+        [return: NativeTypeName("HRESULT")]
+        int GetPartKind([NativeTypeName("UINT32")] uint idx, [NativeTypeName("UINT32 *")] uint* pResult);
+
+        [VtblIndex(6)]
+        [return: NativeTypeName("HRESULT")]
+        int GetPartContent([NativeTypeName("UINT32")] uint idx, IDxcBlob** ppResult);
+
+        [VtblIndex(7)]
+        [return: NativeTypeName("HRESULT")]
+        int FindFirstPartKind([NativeTypeName("UINT32")] uint kind, [NativeTypeName("UINT32 *")] uint* pResult);
+
+        [VtblIndex(8)]
+        [return: NativeTypeName("HRESULT")]
+        int GetPartReflection([NativeTypeName("UINT32")] uint idx, [NativeTypeName("const IID &")] Guid* iid, void** ppvObject);
+    }
+
+    public partial struct Vtbl<TSelf>
+        where TSelf : unmanaged, Interface
+    {
+        [NativeTypeName("HRESULT (const IID &, void **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, Guid*, void**, int> QueryInterface;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> AddRef;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> Release;
+
+        [NativeTypeName("HRESULT (IDxcBlob *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcBlob*, int> Load;
+
+        [NativeTypeName("HRESULT (UINT32 *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint*, int> GetPartCount;
+
+        [NativeTypeName("HRESULT (UINT32, UINT32 *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint, uint*, int> GetPartKind;
+
+        [NativeTypeName("HRESULT (UINT32, IDxcBlob **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint, IDxcBlob**, int> GetPartContent;
+
+        [NativeTypeName("HRESULT (UINT32, UINT32 *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint, uint*, int> FindFirstPartKind;
+
+        [NativeTypeName("HRESULT (UINT32, const IID &, void **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint, Guid*, void**, int> GetPartReflection;
+    }
+}

src/ThridParty/Ghost.DXC/Generated/IDxcCursor.cs

@@ -0,0 +1,396 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using static Ghost.DXC.Api;
+
+namespace Ghost.DXC;
+
+/// <include file='IDxcCursor.xml' path='doc/member[@name="IDxcCursor"]/*' />
+[Guid("1467B985-288D-4D2A-80C1-EF89C42C40BC")]
+[NativeTypeName("struct IDxcCursor : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcCursor : IDxcCursor.Interface, INativeGuid
+{
+    static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(in IID_IDxcCursor);
+
+    public void** lpVtbl;
+
+    /// <inheritdoc cref="IUnknown.QueryInterface" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(0)]
+    [return: NativeTypeName("HRESULT")]
+    public int QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCursor*, Guid*, void**, int>)(lpVtbl[0]))((IDxcCursor*)Unsafe.AsPointer(ref this), riid, ppvObject);
+    }
+
+    /// <inheritdoc cref="IUnknown.AddRef" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(1)]
+    [return: NativeTypeName("ULONG")]
+    public uint AddRef()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCursor*, uint>)(lpVtbl[1]))((IDxcCursor*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IUnknown.Release" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(2)]
+    [return: NativeTypeName("ULONG")]
+    public uint Release()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCursor*, uint>)(lpVtbl[2]))((IDxcCursor*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <include file='IDxcCursor.xml' path='doc/member[@name="IDxcCursor.GetExtent"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(3)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetExtent(IDxcSourceRange** pRange)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCursor*, IDxcSourceRange**, int>)(lpVtbl[3]))((IDxcCursor*)Unsafe.AsPointer(ref this), pRange);
+    }
+
+    /// <include file='IDxcCursor.xml' path='doc/member[@name="IDxcCursor.GetLocation"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(4)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetLocation(IDxcSourceLocation** pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCursor*, IDxcSourceLocation**, int>)(lpVtbl[4]))((IDxcCursor*)Unsafe.AsPointer(ref this), pResult);
+    }
+
+    /// <include file='IDxcCursor.xml' path='doc/member[@name="IDxcCursor.GetKind"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(5)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetKind(DxcCursorKind* pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCursor*, DxcCursorKind*, int>)(lpVtbl[5]))((IDxcCursor*)Unsafe.AsPointer(ref this), pResult);
+    }
+
+    /// <include file='IDxcCursor.xml' path='doc/member[@name="IDxcCursor.GetKindFlags"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(6)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetKindFlags(DxcCursorKindFlags* pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCursor*, DxcCursorKindFlags*, int>)(lpVtbl[6]))((IDxcCursor*)Unsafe.AsPointer(ref this), pResult);
+    }
+
+    /// <include file='IDxcCursor.xml' path='doc/member[@name="IDxcCursor.GetSemanticParent"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(7)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetSemanticParent(IDxcCursor** pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCursor*, IDxcCursor**, int>)(lpVtbl[7]))((IDxcCursor*)Unsafe.AsPointer(ref this), pResult);
+    }
+
+    /// <include file='IDxcCursor.xml' path='doc/member[@name="IDxcCursor.GetLexicalParent"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(8)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetLexicalParent(IDxcCursor** pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCursor*, IDxcCursor**, int>)(lpVtbl[8]))((IDxcCursor*)Unsafe.AsPointer(ref this), pResult);
+    }
+
+    /// <include file='IDxcCursor.xml' path='doc/member[@name="IDxcCursor.GetCursorType"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(9)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetCursorType(IDxcType** pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCursor*, IDxcType**, int>)(lpVtbl[9]))((IDxcCursor*)Unsafe.AsPointer(ref this), pResult);
+    }
+
+    /// <include file='IDxcCursor.xml' path='doc/member[@name="IDxcCursor.GetNumArguments"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(10)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetNumArguments(int* pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCursor*, int*, int>)(lpVtbl[10]))((IDxcCursor*)Unsafe.AsPointer(ref this), pResult);
+    }
+
+    /// <include file='IDxcCursor.xml' path='doc/member[@name="IDxcCursor.GetArgumentAt"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(11)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetArgumentAt(int index, IDxcCursor** pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCursor*, int, IDxcCursor**, int>)(lpVtbl[11]))((IDxcCursor*)Unsafe.AsPointer(ref this), index, pResult);
+    }
+
+    /// <include file='IDxcCursor.xml' path='doc/member[@name="IDxcCursor.GetReferencedCursor"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(12)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetReferencedCursor(IDxcCursor** pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCursor*, IDxcCursor**, int>)(lpVtbl[12]))((IDxcCursor*)Unsafe.AsPointer(ref this), pResult);
+    }
+
+    /// <include file='IDxcCursor.xml' path='doc/member[@name="IDxcCursor.GetDefinitionCursor"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(13)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetDefinitionCursor(IDxcCursor** pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCursor*, IDxcCursor**, int>)(lpVtbl[13]))((IDxcCursor*)Unsafe.AsPointer(ref this), pResult);
+    }
+
+    /// <include file='IDxcCursor.xml' path='doc/member[@name="IDxcCursor.FindReferencesInFile"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(14)]
+    [return: NativeTypeName("HRESULT")]
+    public int FindReferencesInFile(IDxcFile* file, [NativeTypeName("unsigned int")] uint skip, [NativeTypeName("unsigned int")] uint top, [NativeTypeName("unsigned int *")] uint* pResultLength, IDxcCursor*** pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCursor*, IDxcFile*, uint, uint, uint*, IDxcCursor***, int>)(lpVtbl[14]))((IDxcCursor*)Unsafe.AsPointer(ref this), file, skip, top, pResultLength, pResult);
+    }
+
+    /// <include file='IDxcCursor.xml' path='doc/member[@name="IDxcCursor.GetSpelling"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(15)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetSpelling([NativeTypeName("LPSTR *")] sbyte** pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCursor*, sbyte**, int>)(lpVtbl[15]))((IDxcCursor*)Unsafe.AsPointer(ref this), pResult);
+    }
+
+    /// <include file='IDxcCursor.xml' path='doc/member[@name="IDxcCursor.IsEqualTo"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(16)]
+    [return: NativeTypeName("HRESULT")]
+    public int IsEqualTo(IDxcCursor* other, [NativeTypeName("BOOL *")] int* pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCursor*, IDxcCursor*, int*, int>)(lpVtbl[16]))((IDxcCursor*)Unsafe.AsPointer(ref this), other, pResult);
+    }
+
+    /// <include file='IDxcCursor.xml' path='doc/member[@name="IDxcCursor.IsNull"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(17)]
+    [return: NativeTypeName("HRESULT")]
+    public int IsNull([NativeTypeName("BOOL *")] int* pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCursor*, int*, int>)(lpVtbl[17]))((IDxcCursor*)Unsafe.AsPointer(ref this), pResult);
+    }
+
+    /// <include file='IDxcCursor.xml' path='doc/member[@name="IDxcCursor.IsDefinition"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(18)]
+    [return: NativeTypeName("HRESULT")]
+    public int IsDefinition([NativeTypeName("BOOL *")] int* pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCursor*, int*, int>)(lpVtbl[18]))((IDxcCursor*)Unsafe.AsPointer(ref this), pResult);
+    }
+
+    /// <include file='IDxcCursor.xml' path='doc/member[@name="IDxcCursor.GetDisplayName"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(19)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetDisplayName([NativeTypeName("BSTR *")] char** pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCursor*, char**, int>)(lpVtbl[19]))((IDxcCursor*)Unsafe.AsPointer(ref this), pResult);
+    }
+
+    /// <include file='IDxcCursor.xml' path='doc/member[@name="IDxcCursor.GetQualifiedName"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(20)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetQualifiedName([NativeTypeName("BOOL")] int includeTemplateArgs, [NativeTypeName("BSTR *")] char** pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCursor*, int, char**, int>)(lpVtbl[20]))((IDxcCursor*)Unsafe.AsPointer(ref this), includeTemplateArgs, pResult);
+    }
+
+    /// <include file='IDxcCursor.xml' path='doc/member[@name="IDxcCursor.GetFormattedName"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(21)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetFormattedName(DxcCursorFormatting formatting, [NativeTypeName("BSTR *")] char** pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCursor*, DxcCursorFormatting, char**, int>)(lpVtbl[21]))((IDxcCursor*)Unsafe.AsPointer(ref this), formatting, pResult);
+    }
+
+    /// <include file='IDxcCursor.xml' path='doc/member[@name="IDxcCursor.GetChildren"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(22)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetChildren([NativeTypeName("unsigned int")] uint skip, [NativeTypeName("unsigned int")] uint top, [NativeTypeName("unsigned int *")] uint* pResultLength, IDxcCursor*** pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCursor*, uint, uint, uint*, IDxcCursor***, int>)(lpVtbl[22]))((IDxcCursor*)Unsafe.AsPointer(ref this), skip, top, pResultLength, pResult);
+    }
+
+    /// <include file='IDxcCursor.xml' path='doc/member[@name="IDxcCursor.GetSnappedChild"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(23)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetSnappedChild(IDxcSourceLocation* location, IDxcCursor** pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcCursor*, IDxcSourceLocation*, IDxcCursor**, int>)(lpVtbl[23]))((IDxcCursor*)Unsafe.AsPointer(ref this), location, pResult);
+    }
+
+    public interface Interface : IUnknown.Interface
+    {
+        [VtblIndex(3)]
+        [return: NativeTypeName("HRESULT")]
+        int GetExtent(IDxcSourceRange** pRange);
+
+        [VtblIndex(4)]
+        [return: NativeTypeName("HRESULT")]
+        int GetLocation(IDxcSourceLocation** pResult);
+
+        [VtblIndex(5)]
+        [return: NativeTypeName("HRESULT")]
+        int GetKind(DxcCursorKind* pResult);
+
+        [VtblIndex(6)]
+        [return: NativeTypeName("HRESULT")]
+        int GetKindFlags(DxcCursorKindFlags* pResult);
+
+        [VtblIndex(7)]
+        [return: NativeTypeName("HRESULT")]
+        int GetSemanticParent(IDxcCursor** pResult);
+
+        [VtblIndex(8)]
+        [return: NativeTypeName("HRESULT")]
+        int GetLexicalParent(IDxcCursor** pResult);
+
+        [VtblIndex(9)]
+        [return: NativeTypeName("HRESULT")]
+        int GetCursorType(IDxcType** pResult);
+
+        [VtblIndex(10)]
+        [return: NativeTypeName("HRESULT")]
+        int GetNumArguments(int* pResult);
+
+        [VtblIndex(11)]
+        [return: NativeTypeName("HRESULT")]
+        int GetArgumentAt(int index, IDxcCursor** pResult);
+
+        [VtblIndex(12)]
+        [return: NativeTypeName("HRESULT")]
+        int GetReferencedCursor(IDxcCursor** pResult);
+
+        [VtblIndex(13)]
+        [return: NativeTypeName("HRESULT")]
+        int GetDefinitionCursor(IDxcCursor** pResult);
+
+        [VtblIndex(14)]
+        [return: NativeTypeName("HRESULT")]
+        int FindReferencesInFile(IDxcFile* file, [NativeTypeName("unsigned int")] uint skip, [NativeTypeName("unsigned int")] uint top, [NativeTypeName("unsigned int *")] uint* pResultLength, IDxcCursor*** pResult);
+
+        [VtblIndex(15)]
+        [return: NativeTypeName("HRESULT")]
+        int GetSpelling([NativeTypeName("LPSTR *")] sbyte** pResult);
+
+        [VtblIndex(16)]
+        [return: NativeTypeName("HRESULT")]
+        int IsEqualTo(IDxcCursor* other, [NativeTypeName("BOOL *")] int* pResult);
+
+        [VtblIndex(17)]
+        [return: NativeTypeName("HRESULT")]
+        int IsNull([NativeTypeName("BOOL *")] int* pResult);
+
+        [VtblIndex(18)]
+        [return: NativeTypeName("HRESULT")]
+        int IsDefinition([NativeTypeName("BOOL *")] int* pResult);
+
+        [VtblIndex(19)]
+        [return: NativeTypeName("HRESULT")]
+        int GetDisplayName([NativeTypeName("BSTR *")] char** pResult);
+
+        [VtblIndex(20)]
+        [return: NativeTypeName("HRESULT")]
+        int GetQualifiedName([NativeTypeName("BOOL")] int includeTemplateArgs, [NativeTypeName("BSTR *")] char** pResult);
+
+        [VtblIndex(21)]
+        [return: NativeTypeName("HRESULT")]
+        int GetFormattedName(DxcCursorFormatting formatting, [NativeTypeName("BSTR *")] char** pResult);
+
+        [VtblIndex(22)]
+        [return: NativeTypeName("HRESULT")]
+        int GetChildren([NativeTypeName("unsigned int")] uint skip, [NativeTypeName("unsigned int")] uint top, [NativeTypeName("unsigned int *")] uint* pResultLength, IDxcCursor*** pResult);
+
+        [VtblIndex(23)]
+        [return: NativeTypeName("HRESULT")]
+        int GetSnappedChild(IDxcSourceLocation* location, IDxcCursor** pResult);
+    }
+
+    public partial struct Vtbl<TSelf>
+        where TSelf : unmanaged, Interface
+    {
+        [NativeTypeName("HRESULT (const IID &, void **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, Guid*, void**, int> QueryInterface;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> AddRef;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> Release;
+
+        [NativeTypeName("HRESULT (IDxcSourceRange **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcSourceRange**, int> GetExtent;
+
+        [NativeTypeName("HRESULT (IDxcSourceLocation **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcSourceLocation**, int> GetLocation;
+
+        [NativeTypeName("HRESULT (DxcCursorKind *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, DxcCursorKind*, int> GetKind;
+
+        [NativeTypeName("HRESULT (DxcCursorKindFlags *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, DxcCursorKindFlags*, int> GetKindFlags;
+
+        [NativeTypeName("HRESULT (IDxcCursor **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcCursor**, int> GetSemanticParent;
+
+        [NativeTypeName("HRESULT (IDxcCursor **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcCursor**, int> GetLexicalParent;
+
+        [NativeTypeName("HRESULT (IDxcType **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcType**, int> GetCursorType;
+
+        [NativeTypeName("HRESULT (int *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, int*, int> GetNumArguments;
+
+        [NativeTypeName("HRESULT (int, IDxcCursor **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, int, IDxcCursor**, int> GetArgumentAt;
+
+        [NativeTypeName("HRESULT (IDxcCursor **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcCursor**, int> GetReferencedCursor;
+
+        [NativeTypeName("HRESULT (IDxcCursor **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcCursor**, int> GetDefinitionCursor;
+
+        [NativeTypeName("HRESULT (IDxcFile *, unsigned int, unsigned int, unsigned int *, IDxcCursor ***) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcFile*, uint, uint, uint*, IDxcCursor***, int> FindReferencesInFile;
+
+        [NativeTypeName("HRESULT (LPSTR *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, sbyte**, int> GetSpelling;
+
+        [NativeTypeName("HRESULT (IDxcCursor *, BOOL *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcCursor*, int*, int> IsEqualTo;
+
+        [NativeTypeName("HRESULT (BOOL *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, int*, int> IsNull;
+
+        [NativeTypeName("HRESULT (BOOL *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, int*, int> IsDefinition;
+
+        [NativeTypeName("HRESULT (BSTR *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, char**, int> GetDisplayName;
+
+        [NativeTypeName("HRESULT (BOOL, BSTR *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, int, char**, int> GetQualifiedName;
+
+        [NativeTypeName("HRESULT (DxcCursorFormatting, BSTR *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, DxcCursorFormatting, char**, int> GetFormattedName;
+
+        [NativeTypeName("HRESULT (unsigned int, unsigned int, unsigned int *, IDxcCursor ***) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint, uint, uint*, IDxcCursor***, int> GetChildren;
+
+        [NativeTypeName("HRESULT (IDxcSourceLocation *, IDxcCursor **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcSourceLocation*, IDxcCursor**, int> GetSnappedChild;
+    }
+}

src/ThridParty/Ghost.DXC/Generated/IDxcDiagnostic.cs

@@ -0,0 +1,204 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using static Ghost.DXC.Api;
+
+namespace Ghost.DXC;
+
+/// <include file='IDxcDiagnostic.xml' path='doc/member[@name="IDxcDiagnostic"]/*' />
+[Guid("4F76B234-3659-4D33-99B0-3B0DB994B564")]
+[NativeTypeName("struct IDxcDiagnostic : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcDiagnostic : IDxcDiagnostic.Interface, INativeGuid
+{
+    static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(in IID_IDxcDiagnostic);
+
+    public void** lpVtbl;
+
+    /// <inheritdoc cref="IUnknown.QueryInterface" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(0)]
+    [return: NativeTypeName("HRESULT")]
+    public int QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcDiagnostic*, Guid*, void**, int>)(lpVtbl[0]))((IDxcDiagnostic*)Unsafe.AsPointer(ref this), riid, ppvObject);
+    }
+
+    /// <inheritdoc cref="IUnknown.AddRef" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(1)]
+    [return: NativeTypeName("ULONG")]
+    public uint AddRef()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcDiagnostic*, uint>)(lpVtbl[1]))((IDxcDiagnostic*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IUnknown.Release" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(2)]
+    [return: NativeTypeName("ULONG")]
+    public uint Release()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcDiagnostic*, uint>)(lpVtbl[2]))((IDxcDiagnostic*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <include file='IDxcDiagnostic.xml' path='doc/member[@name="IDxcDiagnostic.FormatDiagnostic"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(3)]
+    [return: NativeTypeName("HRESULT")]
+    public int FormatDiagnostic(DxcDiagnosticDisplayOptions options, [NativeTypeName("LPSTR *")] sbyte** pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcDiagnostic*, DxcDiagnosticDisplayOptions, sbyte**, int>)(lpVtbl[3]))((IDxcDiagnostic*)Unsafe.AsPointer(ref this), options, pResult);
+    }
+
+    /// <include file='IDxcDiagnostic.xml' path='doc/member[@name="IDxcDiagnostic.GetSeverity"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(4)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetSeverity(DxcDiagnosticSeverity* pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcDiagnostic*, DxcDiagnosticSeverity*, int>)(lpVtbl[4]))((IDxcDiagnostic*)Unsafe.AsPointer(ref this), pResult);
+    }
+
+    /// <include file='IDxcDiagnostic.xml' path='doc/member[@name="IDxcDiagnostic.GetLocation"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(5)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetLocation(IDxcSourceLocation** pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcDiagnostic*, IDxcSourceLocation**, int>)(lpVtbl[5]))((IDxcDiagnostic*)Unsafe.AsPointer(ref this), pResult);
+    }
+
+    /// <include file='IDxcDiagnostic.xml' path='doc/member[@name="IDxcDiagnostic.GetSpelling"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(6)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetSpelling([NativeTypeName("LPSTR *")] sbyte** pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcDiagnostic*, sbyte**, int>)(lpVtbl[6]))((IDxcDiagnostic*)Unsafe.AsPointer(ref this), pResult);
+    }
+
+    /// <include file='IDxcDiagnostic.xml' path='doc/member[@name="IDxcDiagnostic.GetCategoryText"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(7)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetCategoryText([NativeTypeName("LPSTR *")] sbyte** pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcDiagnostic*, sbyte**, int>)(lpVtbl[7]))((IDxcDiagnostic*)Unsafe.AsPointer(ref this), pResult);
+    }
+
+    /// <include file='IDxcDiagnostic.xml' path='doc/member[@name="IDxcDiagnostic.GetNumRanges"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(8)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetNumRanges([NativeTypeName("unsigned int *")] uint* pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcDiagnostic*, uint*, int>)(lpVtbl[8]))((IDxcDiagnostic*)Unsafe.AsPointer(ref this), pResult);
+    }
+
+    /// <include file='IDxcDiagnostic.xml' path='doc/member[@name="IDxcDiagnostic.GetRangeAt"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(9)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetRangeAt([NativeTypeName("unsigned int")] uint index, IDxcSourceRange** pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcDiagnostic*, uint, IDxcSourceRange**, int>)(lpVtbl[9]))((IDxcDiagnostic*)Unsafe.AsPointer(ref this), index, pResult);
+    }
+
+    /// <include file='IDxcDiagnostic.xml' path='doc/member[@name="IDxcDiagnostic.GetNumFixIts"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(10)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetNumFixIts([NativeTypeName("unsigned int *")] uint* pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcDiagnostic*, uint*, int>)(lpVtbl[10]))((IDxcDiagnostic*)Unsafe.AsPointer(ref this), pResult);
+    }
+
+    /// <include file='IDxcDiagnostic.xml' path='doc/member[@name="IDxcDiagnostic.GetFixItAt"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(11)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetFixItAt([NativeTypeName("unsigned int")] uint index, IDxcSourceRange** pReplacementRange, [NativeTypeName("LPSTR *")] sbyte** pText)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcDiagnostic*, uint, IDxcSourceRange**, sbyte**, int>)(lpVtbl[11]))((IDxcDiagnostic*)Unsafe.AsPointer(ref this), index, pReplacementRange, pText);
+    }
+
+    public interface Interface : IUnknown.Interface
+    {
+        [VtblIndex(3)]
+        [return: NativeTypeName("HRESULT")]
+        int FormatDiagnostic(DxcDiagnosticDisplayOptions options, [NativeTypeName("LPSTR *")] sbyte** pResult);
+
+        [VtblIndex(4)]
+        [return: NativeTypeName("HRESULT")]
+        int GetSeverity(DxcDiagnosticSeverity* pResult);
+
+        [VtblIndex(5)]
+        [return: NativeTypeName("HRESULT")]
+        int GetLocation(IDxcSourceLocation** pResult);
+
+        [VtblIndex(6)]
+        [return: NativeTypeName("HRESULT")]
+        int GetSpelling([NativeTypeName("LPSTR *")] sbyte** pResult);
+
+        [VtblIndex(7)]
+        [return: NativeTypeName("HRESULT")]
+        int GetCategoryText([NativeTypeName("LPSTR *")] sbyte** pResult);
+
+        [VtblIndex(8)]
+        [return: NativeTypeName("HRESULT")]
+        int GetNumRanges([NativeTypeName("unsigned int *")] uint* pResult);
+
+        [VtblIndex(9)]
+        [return: NativeTypeName("HRESULT")]
+        int GetRangeAt([NativeTypeName("unsigned int")] uint index, IDxcSourceRange** pResult);
+
+        [VtblIndex(10)]
+        [return: NativeTypeName("HRESULT")]
+        int GetNumFixIts([NativeTypeName("unsigned int *")] uint* pResult);
+
+        [VtblIndex(11)]
+        [return: NativeTypeName("HRESULT")]
+        int GetFixItAt([NativeTypeName("unsigned int")] uint index, IDxcSourceRange** pReplacementRange, [NativeTypeName("LPSTR *")] sbyte** pText);
+    }
+
+    public partial struct Vtbl<TSelf>
+        where TSelf : unmanaged, Interface
+    {
+        [NativeTypeName("HRESULT (const IID &, void **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, Guid*, void**, int> QueryInterface;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> AddRef;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> Release;
+
+        [NativeTypeName("HRESULT (DxcDiagnosticDisplayOptions, LPSTR *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, DxcDiagnosticDisplayOptions, sbyte**, int> FormatDiagnostic;
+
+        [NativeTypeName("HRESULT (DxcDiagnosticSeverity *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, DxcDiagnosticSeverity*, int> GetSeverity;
+
+        [NativeTypeName("HRESULT (IDxcSourceLocation **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcSourceLocation**, int> GetLocation;
+
+        [NativeTypeName("HRESULT (LPSTR *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, sbyte**, int> GetSpelling;
+
+        [NativeTypeName("HRESULT (LPSTR *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, sbyte**, int> GetCategoryText;
+
+        [NativeTypeName("HRESULT (unsigned int *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint*, int> GetNumRanges;
+
+        [NativeTypeName("HRESULT (unsigned int, IDxcSourceRange **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint, IDxcSourceRange**, int> GetRangeAt;
+
+        [NativeTypeName("HRESULT (unsigned int *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint*, int> GetNumFixIts;
+
+        [NativeTypeName("HRESULT (unsigned int, IDxcSourceRange **, LPSTR *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint, IDxcSourceRange**, sbyte**, int> GetFixItAt;
+    }
+}

src/ThridParty/Ghost.DXC/Generated/IDxcExtraOutputs.cs

@@ -0,0 +1,92 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using static Ghost.DXC.Api;
+
+namespace Ghost.DXC;
+
+/// <include file='IDxcExtraOutputs.xml' path='doc/member[@name="IDxcExtraOutputs"]/*' />
+[Guid("319B37A2-A5C2-494A-A5DE-4801B2FAF989")]
+[NativeTypeName("struct IDxcExtraOutputs : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcExtraOutputs : IDxcExtraOutputs.Interface, INativeGuid
+{
+    static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(in IID_IDxcExtraOutputs);
+
+    public void** lpVtbl;
+
+    /// <inheritdoc cref="IUnknown.QueryInterface" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(0)]
+    [return: NativeTypeName("HRESULT")]
+    public int QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcExtraOutputs*, Guid*, void**, int>)(lpVtbl[0]))((IDxcExtraOutputs*)Unsafe.AsPointer(ref this), riid, ppvObject);
+    }
+
+    /// <inheritdoc cref="IUnknown.AddRef" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(1)]
+    [return: NativeTypeName("ULONG")]
+    public uint AddRef()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcExtraOutputs*, uint>)(lpVtbl[1]))((IDxcExtraOutputs*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IUnknown.Release" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(2)]
+    [return: NativeTypeName("ULONG")]
+    public uint Release()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcExtraOutputs*, uint>)(lpVtbl[2]))((IDxcExtraOutputs*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <include file='IDxcExtraOutputs.xml' path='doc/member[@name="IDxcExtraOutputs.GetOutputCount"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(3)]
+    [return: NativeTypeName("UINT32")]
+    public uint GetOutputCount()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcExtraOutputs*, uint>)(lpVtbl[3]))((IDxcExtraOutputs*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <include file='IDxcExtraOutputs.xml' path='doc/member[@name="IDxcExtraOutputs.GetOutput"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(4)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetOutput([NativeTypeName("UINT32")] uint uIndex, [NativeTypeName("const IID &")] Guid* iid, void** ppvObject, IDxcBlobWide** ppOutputType, IDxcBlobWide** ppOutputName)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcExtraOutputs*, uint, Guid*, void**, IDxcBlobWide**, IDxcBlobWide**, int>)(lpVtbl[4]))((IDxcExtraOutputs*)Unsafe.AsPointer(ref this), uIndex, iid, ppvObject, ppOutputType, ppOutputName);
+    }
+
+    public interface Interface : IUnknown.Interface
+    {
+        [VtblIndex(3)]
+        [return: NativeTypeName("UINT32")]
+        uint GetOutputCount();
+
+        [VtblIndex(4)]
+        [return: NativeTypeName("HRESULT")]
+        int GetOutput([NativeTypeName("UINT32")] uint uIndex, [NativeTypeName("const IID &")] Guid* iid, void** ppvObject, IDxcBlobWide** ppOutputType, IDxcBlobWide** ppOutputName);
+    }
+
+    public partial struct Vtbl<TSelf>
+        where TSelf : unmanaged, Interface
+    {
+        [NativeTypeName("HRESULT (const IID &, void **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, Guid*, void**, int> QueryInterface;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> AddRef;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> Release;
+
+        [NativeTypeName("UINT32 () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> GetOutputCount;
+
+        [NativeTypeName("HRESULT (UINT32, const IID &, void **, IDxcBlobWide **, IDxcBlobWide **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint, Guid*, void**, IDxcBlobWide**, IDxcBlobWide**, int> GetOutput;
+    }
+}

src/ThridParty/Ghost.DXC/Generated/IDxcFile.cs

@@ -0,0 +1,92 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using static Ghost.DXC.Api;
+
+namespace Ghost.DXC;
+
+/// <include file='IDxcFile.xml' path='doc/member[@name="IDxcFile"]/*' />
+[Guid("BB2FCA9E-1478-47BA-B08C-2C502ADA4895")]
+[NativeTypeName("struct IDxcFile : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcFile : IDxcFile.Interface, INativeGuid
+{
+    static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(in IID_IDxcFile);
+
+    public void** lpVtbl;
+
+    /// <inheritdoc cref="IUnknown.QueryInterface" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(0)]
+    [return: NativeTypeName("HRESULT")]
+    public int QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcFile*, Guid*, void**, int>)(lpVtbl[0]))((IDxcFile*)Unsafe.AsPointer(ref this), riid, ppvObject);
+    }
+
+    /// <inheritdoc cref="IUnknown.AddRef" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(1)]
+    [return: NativeTypeName("ULONG")]
+    public uint AddRef()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcFile*, uint>)(lpVtbl[1]))((IDxcFile*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IUnknown.Release" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(2)]
+    [return: NativeTypeName("ULONG")]
+    public uint Release()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcFile*, uint>)(lpVtbl[2]))((IDxcFile*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <include file='IDxcFile.xml' path='doc/member[@name="IDxcFile.GetName"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(3)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetName([NativeTypeName("LPSTR *")] sbyte** pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcFile*, sbyte**, int>)(lpVtbl[3]))((IDxcFile*)Unsafe.AsPointer(ref this), pResult);
+    }
+
+    /// <include file='IDxcFile.xml' path='doc/member[@name="IDxcFile.IsEqualTo"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(4)]
+    [return: NativeTypeName("HRESULT")]
+    public int IsEqualTo(IDxcFile* other, [NativeTypeName("BOOL *")] int* pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcFile*, IDxcFile*, int*, int>)(lpVtbl[4]))((IDxcFile*)Unsafe.AsPointer(ref this), other, pResult);
+    }
+
+    public interface Interface : IUnknown.Interface
+    {
+        [VtblIndex(3)]
+        [return: NativeTypeName("HRESULT")]
+        int GetName([NativeTypeName("LPSTR *")] sbyte** pResult);
+
+        [VtblIndex(4)]
+        [return: NativeTypeName("HRESULT")]
+        int IsEqualTo(IDxcFile* other, [NativeTypeName("BOOL *")] int* pResult);
+    }
+
+    public partial struct Vtbl<TSelf>
+        where TSelf : unmanaged, Interface
+    {
+        [NativeTypeName("HRESULT (const IID &, void **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, Guid*, void**, int> QueryInterface;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> AddRef;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> Release;
+
+        [NativeTypeName("HRESULT (LPSTR *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, sbyte**, int> GetName;
+
+        [NativeTypeName("HRESULT (IDxcFile *, BOOL *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcFile*, int*, int> IsEqualTo;
+    }
+}

src/ThridParty/Ghost.DXC/Generated/IDxcIncludeHandler.cs

@@ -0,0 +1,76 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using static Ghost.DXC.Api;
+
+namespace Ghost.DXC;
+
+/// <include file='IDxcIncludeHandler.xml' path='doc/member[@name="IDxcIncludeHandler"]/*' />
+[Guid("7F61FC7D-950D-467F-B3E3-3C02FB49187C")]
+[NativeTypeName("struct IDxcIncludeHandler : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcIncludeHandler : IDxcIncludeHandler.Interface, INativeGuid
+{
+    static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(in IID_IDxcIncludeHandler);
+
+    public void** lpVtbl;
+
+    /// <inheritdoc cref="IUnknown.QueryInterface" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(0)]
+    [return: NativeTypeName("HRESULT")]
+    public int QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcIncludeHandler*, Guid*, void**, int>)(lpVtbl[0]))((IDxcIncludeHandler*)Unsafe.AsPointer(ref this), riid, ppvObject);
+    }
+
+    /// <inheritdoc cref="IUnknown.AddRef" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(1)]
+    [return: NativeTypeName("ULONG")]
+    public uint AddRef()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcIncludeHandler*, uint>)(lpVtbl[1]))((IDxcIncludeHandler*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IUnknown.Release" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(2)]
+    [return: NativeTypeName("ULONG")]
+    public uint Release()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcIncludeHandler*, uint>)(lpVtbl[2]))((IDxcIncludeHandler*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <include file='IDxcIncludeHandler.xml' path='doc/member[@name="IDxcIncludeHandler.LoadSource"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(3)]
+    [return: NativeTypeName("HRESULT")]
+    public int LoadSource([NativeTypeName("LPCWSTR")] char* pFilename, IDxcBlob** ppIncludeSource)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcIncludeHandler*, char*, IDxcBlob**, int>)(lpVtbl[3]))((IDxcIncludeHandler*)Unsafe.AsPointer(ref this), pFilename, ppIncludeSource);
+    }
+
+    public interface Interface : IUnknown.Interface
+    {
+        [VtblIndex(3)]
+        [return: NativeTypeName("HRESULT")]
+        int LoadSource([NativeTypeName("LPCWSTR")] char* pFilename, IDxcBlob** ppIncludeSource);
+    }
+
+    public partial struct Vtbl<TSelf>
+        where TSelf : unmanaged, Interface
+    {
+        [NativeTypeName("HRESULT (const IID &, void **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, Guid*, void**, int> QueryInterface;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> AddRef;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> Release;
+
+        [NativeTypeName("HRESULT (LPCWSTR, IDxcBlob **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, char*, IDxcBlob**, int> LoadSource;
+    }
+}

src/ThridParty/Ghost.DXC/Generated/IDxcInclusion.cs

@@ -0,0 +1,108 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using static Ghost.DXC.Api;
+
+namespace Ghost.DXC;
+
+/// <include file='IDxcInclusion.xml' path='doc/member[@name="IDxcInclusion"]/*' />
+[Guid("0C364D65-DF44-4412-888E-4E552FC5E3D6")]
+[NativeTypeName("struct IDxcInclusion : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcInclusion : IDxcInclusion.Interface, INativeGuid
+{
+    static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(in IID_IDxcInclusion);
+
+    public void** lpVtbl;
+
+    /// <inheritdoc cref="IUnknown.QueryInterface" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(0)]
+    [return: NativeTypeName("HRESULT")]
+    public int QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcInclusion*, Guid*, void**, int>)(lpVtbl[0]))((IDxcInclusion*)Unsafe.AsPointer(ref this), riid, ppvObject);
+    }
+
+    /// <inheritdoc cref="IUnknown.AddRef" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(1)]
+    [return: NativeTypeName("ULONG")]
+    public uint AddRef()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcInclusion*, uint>)(lpVtbl[1]))((IDxcInclusion*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IUnknown.Release" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(2)]
+    [return: NativeTypeName("ULONG")]
+    public uint Release()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcInclusion*, uint>)(lpVtbl[2]))((IDxcInclusion*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <include file='IDxcInclusion.xml' path='doc/member[@name="IDxcInclusion.GetIncludedFile"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(3)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetIncludedFile(IDxcFile** pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcInclusion*, IDxcFile**, int>)(lpVtbl[3]))((IDxcInclusion*)Unsafe.AsPointer(ref this), pResult);
+    }
+
+    /// <include file='IDxcInclusion.xml' path='doc/member[@name="IDxcInclusion.GetStackLength"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(4)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetStackLength([NativeTypeName("unsigned int *")] uint* pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcInclusion*, uint*, int>)(lpVtbl[4]))((IDxcInclusion*)Unsafe.AsPointer(ref this), pResult);
+    }
+
+    /// <include file='IDxcInclusion.xml' path='doc/member[@name="IDxcInclusion.GetStackItem"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(5)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetStackItem([NativeTypeName("unsigned int")] uint index, IDxcSourceLocation** pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcInclusion*, uint, IDxcSourceLocation**, int>)(lpVtbl[5]))((IDxcInclusion*)Unsafe.AsPointer(ref this), index, pResult);
+    }
+
+    public interface Interface : IUnknown.Interface
+    {
+        [VtblIndex(3)]
+        [return: NativeTypeName("HRESULT")]
+        int GetIncludedFile(IDxcFile** pResult);
+
+        [VtblIndex(4)]
+        [return: NativeTypeName("HRESULT")]
+        int GetStackLength([NativeTypeName("unsigned int *")] uint* pResult);
+
+        [VtblIndex(5)]
+        [return: NativeTypeName("HRESULT")]
+        int GetStackItem([NativeTypeName("unsigned int")] uint index, IDxcSourceLocation** pResult);
+    }
+
+    public partial struct Vtbl<TSelf>
+        where TSelf : unmanaged, Interface
+    {
+        [NativeTypeName("HRESULT (const IID &, void **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, Guid*, void**, int> QueryInterface;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> AddRef;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> Release;
+
+        [NativeTypeName("HRESULT (IDxcFile **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcFile**, int> GetIncludedFile;
+
+        [NativeTypeName("HRESULT (unsigned int *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint*, int> GetStackLength;
+
+        [NativeTypeName("HRESULT (unsigned int, IDxcSourceLocation **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint, IDxcSourceLocation**, int> GetStackItem;
+    }
+}

src/ThridParty/Ghost.DXC/Generated/IDxcIndex.cs

@@ -0,0 +1,108 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using static Ghost.DXC.Api;
+
+namespace Ghost.DXC;
+
+/// <include file='IDxcIndex.xml' path='doc/member[@name="IDxcIndex"]/*' />
+[Guid("937824A0-7F5A-4815-9BA7-7FC0424F4173")]
+[NativeTypeName("struct IDxcIndex : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcIndex : IDxcIndex.Interface, INativeGuid
+{
+    static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(in IID_IDxcIndex);
+
+    public void** lpVtbl;
+
+    /// <inheritdoc cref="IUnknown.QueryInterface" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(0)]
+    [return: NativeTypeName("HRESULT")]
+    public int QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcIndex*, Guid*, void**, int>)(lpVtbl[0]))((IDxcIndex*)Unsafe.AsPointer(ref this), riid, ppvObject);
+    }
+
+    /// <inheritdoc cref="IUnknown.AddRef" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(1)]
+    [return: NativeTypeName("ULONG")]
+    public uint AddRef()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcIndex*, uint>)(lpVtbl[1]))((IDxcIndex*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IUnknown.Release" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(2)]
+    [return: NativeTypeName("ULONG")]
+    public uint Release()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcIndex*, uint>)(lpVtbl[2]))((IDxcIndex*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <include file='IDxcIndex.xml' path='doc/member[@name="IDxcIndex.SetGlobalOptions"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(3)]
+    [return: NativeTypeName("HRESULT")]
+    public int SetGlobalOptions(DxcGlobalOptions options)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcIndex*, DxcGlobalOptions, int>)(lpVtbl[3]))((IDxcIndex*)Unsafe.AsPointer(ref this), options);
+    }
+
+    /// <include file='IDxcIndex.xml' path='doc/member[@name="IDxcIndex.GetGlobalOptions"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(4)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetGlobalOptions(DxcGlobalOptions* options)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcIndex*, DxcGlobalOptions*, int>)(lpVtbl[4]))((IDxcIndex*)Unsafe.AsPointer(ref this), options);
+    }
+
+    /// <include file='IDxcIndex.xml' path='doc/member[@name="IDxcIndex.ParseTranslationUnit"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(5)]
+    [return: NativeTypeName("HRESULT")]
+    public int ParseTranslationUnit([NativeTypeName("const char *")] sbyte* source_filename, [NativeTypeName("const char *const *")] sbyte** command_line_args, int num_command_line_args, IDxcUnsavedFile** unsaved_files, [NativeTypeName("unsigned int")] uint num_unsaved_files, DxcTranslationUnitFlags options, IDxcTranslationUnit** pTranslationUnit)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcIndex*, sbyte*, sbyte**, int, IDxcUnsavedFile**, uint, DxcTranslationUnitFlags, IDxcTranslationUnit**, int>)(lpVtbl[5]))((IDxcIndex*)Unsafe.AsPointer(ref this), source_filename, command_line_args, num_command_line_args, unsaved_files, num_unsaved_files, options, pTranslationUnit);
+    }
+
+    public interface Interface : IUnknown.Interface
+    {
+        [VtblIndex(3)]
+        [return: NativeTypeName("HRESULT")]
+        int SetGlobalOptions(DxcGlobalOptions options);
+
+        [VtblIndex(4)]
+        [return: NativeTypeName("HRESULT")]
+        int GetGlobalOptions(DxcGlobalOptions* options);
+
+        [VtblIndex(5)]
+        [return: NativeTypeName("HRESULT")]
+        int ParseTranslationUnit([NativeTypeName("const char *")] sbyte* source_filename, [NativeTypeName("const char *const *")] sbyte** command_line_args, int num_command_line_args, IDxcUnsavedFile** unsaved_files, [NativeTypeName("unsigned int")] uint num_unsaved_files, DxcTranslationUnitFlags options, IDxcTranslationUnit** pTranslationUnit);
+    }
+
+    public partial struct Vtbl<TSelf>
+        where TSelf : unmanaged, Interface
+    {
+        [NativeTypeName("HRESULT (const IID &, void **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, Guid*, void**, int> QueryInterface;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> AddRef;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> Release;
+
+        [NativeTypeName("HRESULT (DxcGlobalOptions) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, DxcGlobalOptions, int> SetGlobalOptions;
+
+        [NativeTypeName("HRESULT (DxcGlobalOptions *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, DxcGlobalOptions*, int> GetGlobalOptions;
+
+        [NativeTypeName("HRESULT (const char *, const char *const *, int, IDxcUnsavedFile **, unsigned int, DxcTranslationUnitFlags, IDxcTranslationUnit **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, sbyte*, sbyte**, int, IDxcUnsavedFile**, uint, DxcTranslationUnitFlags, IDxcTranslationUnit**, int> ParseTranslationUnit;
+    }
+}

src/ThridParty/Ghost.DXC/Generated/IDxcIntelliSense.cs

@@ -0,0 +1,172 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using static Ghost.DXC.Api;
+
+namespace Ghost.DXC;
+
+/// <include file='IDxcIntelliSense.xml' path='doc/member[@name="IDxcIntelliSense"]/*' />
+[Guid("B1F99513-46D6-4112-8169-DD0D6053F17D")]
+[NativeTypeName("struct IDxcIntelliSense : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcIntelliSense : IDxcIntelliSense.Interface, INativeGuid
+{
+    static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(in IID_IDxcIntelliSense);
+
+    public void** lpVtbl;
+
+    /// <inheritdoc cref="IUnknown.QueryInterface" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(0)]
+    [return: NativeTypeName("HRESULT")]
+    public int QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcIntelliSense*, Guid*, void**, int>)(lpVtbl[0]))((IDxcIntelliSense*)Unsafe.AsPointer(ref this), riid, ppvObject);
+    }
+
+    /// <inheritdoc cref="IUnknown.AddRef" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(1)]
+    [return: NativeTypeName("ULONG")]
+    public uint AddRef()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcIntelliSense*, uint>)(lpVtbl[1]))((IDxcIntelliSense*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IUnknown.Release" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(2)]
+    [return: NativeTypeName("ULONG")]
+    public uint Release()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcIntelliSense*, uint>)(lpVtbl[2]))((IDxcIntelliSense*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <include file='IDxcIntelliSense.xml' path='doc/member[@name="IDxcIntelliSense.CreateIndex"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(3)]
+    [return: NativeTypeName("HRESULT")]
+    public int CreateIndex(IDxcIndex** index)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcIntelliSense*, IDxcIndex**, int>)(lpVtbl[3]))((IDxcIntelliSense*)Unsafe.AsPointer(ref this), index);
+    }
+
+    /// <include file='IDxcIntelliSense.xml' path='doc/member[@name="IDxcIntelliSense.GetNullLocation"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(4)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetNullLocation(IDxcSourceLocation** location)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcIntelliSense*, IDxcSourceLocation**, int>)(lpVtbl[4]))((IDxcIntelliSense*)Unsafe.AsPointer(ref this), location);
+    }
+
+    /// <include file='IDxcIntelliSense.xml' path='doc/member[@name="IDxcIntelliSense.GetNullRange"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(5)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetNullRange(IDxcSourceRange** location)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcIntelliSense*, IDxcSourceRange**, int>)(lpVtbl[5]))((IDxcIntelliSense*)Unsafe.AsPointer(ref this), location);
+    }
+
+    /// <include file='IDxcIntelliSense.xml' path='doc/member[@name="IDxcIntelliSense.GetRange"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(6)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetRange(IDxcSourceLocation* start, IDxcSourceLocation* end, IDxcSourceRange** location)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcIntelliSense*, IDxcSourceLocation*, IDxcSourceLocation*, IDxcSourceRange**, int>)(lpVtbl[6]))((IDxcIntelliSense*)Unsafe.AsPointer(ref this), start, end, location);
+    }
+
+    /// <include file='IDxcIntelliSense.xml' path='doc/member[@name="IDxcIntelliSense.GetDefaultDiagnosticDisplayOptions"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(7)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetDefaultDiagnosticDisplayOptions(DxcDiagnosticDisplayOptions* pValue)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcIntelliSense*, DxcDiagnosticDisplayOptions*, int>)(lpVtbl[7]))((IDxcIntelliSense*)Unsafe.AsPointer(ref this), pValue);
+    }
+
+    /// <include file='IDxcIntelliSense.xml' path='doc/member[@name="IDxcIntelliSense.GetDefaultEditingTUOptions"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(8)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetDefaultEditingTUOptions(DxcTranslationUnitFlags* pValue)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcIntelliSense*, DxcTranslationUnitFlags*, int>)(lpVtbl[8]))((IDxcIntelliSense*)Unsafe.AsPointer(ref this), pValue);
+    }
+
+    /// <include file='IDxcIntelliSense.xml' path='doc/member[@name="IDxcIntelliSense.CreateUnsavedFile"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(9)]
+    [return: NativeTypeName("HRESULT")]
+    public int CreateUnsavedFile([NativeTypeName("LPCSTR")] sbyte* fileName, [NativeTypeName("LPCSTR")] sbyte* contents, [NativeTypeName("unsigned int")] uint contentLength, IDxcUnsavedFile** pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcIntelliSense*, sbyte*, sbyte*, uint, IDxcUnsavedFile**, int>)(lpVtbl[9]))((IDxcIntelliSense*)Unsafe.AsPointer(ref this), fileName, contents, contentLength, pResult);
+    }
+
+    public interface Interface : IUnknown.Interface
+    {
+        [VtblIndex(3)]
+        [return: NativeTypeName("HRESULT")]
+        int CreateIndex(IDxcIndex** index);
+
+        [VtblIndex(4)]
+        [return: NativeTypeName("HRESULT")]
+        int GetNullLocation(IDxcSourceLocation** location);
+
+        [VtblIndex(5)]
+        [return: NativeTypeName("HRESULT")]
+        int GetNullRange(IDxcSourceRange** location);
+
+        [VtblIndex(6)]
+        [return: NativeTypeName("HRESULT")]
+        int GetRange(IDxcSourceLocation* start, IDxcSourceLocation* end, IDxcSourceRange** location);
+
+        [VtblIndex(7)]
+        [return: NativeTypeName("HRESULT")]
+        int GetDefaultDiagnosticDisplayOptions(DxcDiagnosticDisplayOptions* pValue);
+
+        [VtblIndex(8)]
+        [return: NativeTypeName("HRESULT")]
+        int GetDefaultEditingTUOptions(DxcTranslationUnitFlags* pValue);
+
+        [VtblIndex(9)]
+        [return: NativeTypeName("HRESULT")]
+        int CreateUnsavedFile([NativeTypeName("LPCSTR")] sbyte* fileName, [NativeTypeName("LPCSTR")] sbyte* contents, [NativeTypeName("unsigned int")] uint contentLength, IDxcUnsavedFile** pResult);
+    }
+
+    public partial struct Vtbl<TSelf>
+        where TSelf : unmanaged, Interface
+    {
+        [NativeTypeName("HRESULT (const IID &, void **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, Guid*, void**, int> QueryInterface;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> AddRef;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> Release;
+
+        [NativeTypeName("HRESULT (IDxcIndex **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcIndex**, int> CreateIndex;
+
+        [NativeTypeName("HRESULT (IDxcSourceLocation **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcSourceLocation**, int> GetNullLocation;
+
+        [NativeTypeName("HRESULT (IDxcSourceRange **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcSourceRange**, int> GetNullRange;
+
+        [NativeTypeName("HRESULT (IDxcSourceLocation *, IDxcSourceLocation *, IDxcSourceRange **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcSourceLocation*, IDxcSourceLocation*, IDxcSourceRange**, int> GetRange;
+
+        [NativeTypeName("HRESULT (DxcDiagnosticDisplayOptions *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, DxcDiagnosticDisplayOptions*, int> GetDefaultDiagnosticDisplayOptions;
+
+        [NativeTypeName("HRESULT (DxcTranslationUnitFlags *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, DxcTranslationUnitFlags*, int> GetDefaultEditingTUOptions;
+
+        [NativeTypeName("HRESULT (LPCSTR, LPCSTR, unsigned int, IDxcUnsavedFile **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, sbyte*, sbyte*, uint, IDxcUnsavedFile**, int> CreateUnsavedFile;
+    }
+}

src/ThridParty/Ghost.DXC/Generated/IDxcLibrary.cs

@@ -0,0 +1,226 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using static Ghost.DXC.Api;
+
+namespace Ghost.DXC;
+
+/// <include file='IDxcLibrary.xml' path='doc/member[@name="IDxcLibrary"]/*' />
+[Guid("E5204DC7-D18C-4C3C-BDFB-851673980FE7")]
+[NativeTypeName("struct IDxcLibrary : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcLibrary : IDxcLibrary.Interface, INativeGuid
+{
+    static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(in IID_IDxcLibrary);
+
+    public void** lpVtbl;
+
+    [return: NativeTypeName("HRESULT")]
+    public int GetBlobAsUtf16(IDxcBlob* pBlob, IDxcBlobEncoding** pBlobEncoding)
+    {
+        return this.GetBlobAsWide(pBlob, pBlobEncoding);
+    }
+
+    /// <inheritdoc cref="IUnknown.QueryInterface" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(0)]
+    [return: NativeTypeName("HRESULT")]
+    public int QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcLibrary*, Guid*, void**, int>)(lpVtbl[0]))((IDxcLibrary*)Unsafe.AsPointer(ref this), riid, ppvObject);
+    }
+
+    /// <inheritdoc cref="IUnknown.AddRef" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(1)]
+    [return: NativeTypeName("ULONG")]
+    public uint AddRef()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcLibrary*, uint>)(lpVtbl[1]))((IDxcLibrary*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IUnknown.Release" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(2)]
+    [return: NativeTypeName("ULONG")]
+    public uint Release()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcLibrary*, uint>)(lpVtbl[2]))((IDxcLibrary*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <include file='IDxcLibrary.xml' path='doc/member[@name="IDxcLibrary.SetMalloc"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(3)]
+    [return: NativeTypeName("HRESULT")]
+    public int SetMalloc(IMalloc* pMalloc)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcLibrary*, IMalloc*, int>)(lpVtbl[3]))((IDxcLibrary*)Unsafe.AsPointer(ref this), pMalloc);
+    }
+
+    /// <include file='IDxcLibrary.xml' path='doc/member[@name="IDxcLibrary.CreateBlobFromBlob"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(4)]
+    [return: NativeTypeName("HRESULT")]
+    public int CreateBlobFromBlob(IDxcBlob* pBlob, [NativeTypeName("UINT32")] uint offset, [NativeTypeName("UINT32")] uint length, IDxcBlob** ppResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcLibrary*, IDxcBlob*, uint, uint, IDxcBlob**, int>)(lpVtbl[4]))((IDxcLibrary*)Unsafe.AsPointer(ref this), pBlob, offset, length, ppResult);
+    }
+
+    /// <include file='IDxcLibrary.xml' path='doc/member[@name="IDxcLibrary.CreateBlobFromFile"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(5)]
+    [return: NativeTypeName("HRESULT")]
+    public int CreateBlobFromFile([NativeTypeName("LPCWSTR")] char* pFileName, [NativeTypeName("UINT32 *")] uint* codePage, IDxcBlobEncoding** pBlobEncoding)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcLibrary*, char*, uint*, IDxcBlobEncoding**, int>)(lpVtbl[5]))((IDxcLibrary*)Unsafe.AsPointer(ref this), pFileName, codePage, pBlobEncoding);
+    }
+
+    /// <include file='IDxcLibrary.xml' path='doc/member[@name="IDxcLibrary.CreateBlobWithEncodingFromPinned"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(6)]
+    [return: NativeTypeName("HRESULT")]
+    public int CreateBlobWithEncodingFromPinned([NativeTypeName("LPCVOID")] void* pText, [NativeTypeName("UINT32")] uint size, [NativeTypeName("UINT32")] uint codePage, IDxcBlobEncoding** pBlobEncoding)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcLibrary*, void*, uint, uint, IDxcBlobEncoding**, int>)(lpVtbl[6]))((IDxcLibrary*)Unsafe.AsPointer(ref this), pText, size, codePage, pBlobEncoding);
+    }
+
+    /// <include file='IDxcLibrary.xml' path='doc/member[@name="IDxcLibrary.CreateBlobWithEncodingOnHeapCopy"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(7)]
+    [return: NativeTypeName("HRESULT")]
+    public int CreateBlobWithEncodingOnHeapCopy([NativeTypeName("LPCVOID")] void* pText, [NativeTypeName("UINT32")] uint size, [NativeTypeName("UINT32")] uint codePage, IDxcBlobEncoding** pBlobEncoding)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcLibrary*, void*, uint, uint, IDxcBlobEncoding**, int>)(lpVtbl[7]))((IDxcLibrary*)Unsafe.AsPointer(ref this), pText, size, codePage, pBlobEncoding);
+    }
+
+    /// <include file='IDxcLibrary.xml' path='doc/member[@name="IDxcLibrary.CreateBlobWithEncodingOnMalloc"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(8)]
+    [return: NativeTypeName("HRESULT")]
+    public int CreateBlobWithEncodingOnMalloc([NativeTypeName("LPCVOID")] void* pText, IMalloc* pIMalloc, [NativeTypeName("UINT32")] uint size, [NativeTypeName("UINT32")] uint codePage, IDxcBlobEncoding** pBlobEncoding)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcLibrary*, void*, IMalloc*, uint, uint, IDxcBlobEncoding**, int>)(lpVtbl[8]))((IDxcLibrary*)Unsafe.AsPointer(ref this), pText, pIMalloc, size, codePage, pBlobEncoding);
+    }
+
+    /// <include file='IDxcLibrary.xml' path='doc/member[@name="IDxcLibrary.CreateIncludeHandler"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(9)]
+    [return: NativeTypeName("HRESULT")]
+    public int CreateIncludeHandler(IDxcIncludeHandler** ppResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcLibrary*, IDxcIncludeHandler**, int>)(lpVtbl[9]))((IDxcLibrary*)Unsafe.AsPointer(ref this), ppResult);
+    }
+
+    /// <include file='IDxcLibrary.xml' path='doc/member[@name="IDxcLibrary.CreateStreamFromBlobReadOnly"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(10)]
+    [return: NativeTypeName("HRESULT")]
+    public int CreateStreamFromBlobReadOnly(IDxcBlob* pBlob, IStream** ppStream)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcLibrary*, IDxcBlob*, IStream**, int>)(lpVtbl[10]))((IDxcLibrary*)Unsafe.AsPointer(ref this), pBlob, ppStream);
+    }
+
+    /// <include file='IDxcLibrary.xml' path='doc/member[@name="IDxcLibrary.GetBlobAsUtf8"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(11)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetBlobAsUtf8(IDxcBlob* pBlob, IDxcBlobEncoding** pBlobEncoding)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcLibrary*, IDxcBlob*, IDxcBlobEncoding**, int>)(lpVtbl[11]))((IDxcLibrary*)Unsafe.AsPointer(ref this), pBlob, pBlobEncoding);
+    }
+
+    /// <include file='IDxcLibrary.xml' path='doc/member[@name="IDxcLibrary.GetBlobAsWide"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(12)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetBlobAsWide(IDxcBlob* pBlob, IDxcBlobEncoding** pBlobEncoding)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcLibrary*, IDxcBlob*, IDxcBlobEncoding**, int>)(lpVtbl[12]))((IDxcLibrary*)Unsafe.AsPointer(ref this), pBlob, pBlobEncoding);
+    }
+
+    public interface Interface : IUnknown.Interface
+    {
+        [VtblIndex(3)]
+        [return: NativeTypeName("HRESULT")]
+        int SetMalloc(IMalloc* pMalloc);
+
+        [VtblIndex(4)]
+        [return: NativeTypeName("HRESULT")]
+        int CreateBlobFromBlob(IDxcBlob* pBlob, [NativeTypeName("UINT32")] uint offset, [NativeTypeName("UINT32")] uint length, IDxcBlob** ppResult);
+
+        [VtblIndex(5)]
+        [return: NativeTypeName("HRESULT")]
+        int CreateBlobFromFile([NativeTypeName("LPCWSTR")] char* pFileName, [NativeTypeName("UINT32 *")] uint* codePage, IDxcBlobEncoding** pBlobEncoding);
+
+        [VtblIndex(6)]
+        [return: NativeTypeName("HRESULT")]
+        int CreateBlobWithEncodingFromPinned([NativeTypeName("LPCVOID")] void* pText, [NativeTypeName("UINT32")] uint size, [NativeTypeName("UINT32")] uint codePage, IDxcBlobEncoding** pBlobEncoding);
+
+        [VtblIndex(7)]
+        [return: NativeTypeName("HRESULT")]
+        int CreateBlobWithEncodingOnHeapCopy([NativeTypeName("LPCVOID")] void* pText, [NativeTypeName("UINT32")] uint size, [NativeTypeName("UINT32")] uint codePage, IDxcBlobEncoding** pBlobEncoding);
+
+        [VtblIndex(8)]
+        [return: NativeTypeName("HRESULT")]
+        int CreateBlobWithEncodingOnMalloc([NativeTypeName("LPCVOID")] void* pText, IMalloc* pIMalloc, [NativeTypeName("UINT32")] uint size, [NativeTypeName("UINT32")] uint codePage, IDxcBlobEncoding** pBlobEncoding);
+
+        [VtblIndex(9)]
+        [return: NativeTypeName("HRESULT")]
+        int CreateIncludeHandler(IDxcIncludeHandler** ppResult);
+
+        [VtblIndex(10)]
+        [return: NativeTypeName("HRESULT")]
+        int CreateStreamFromBlobReadOnly(IDxcBlob* pBlob, IStream** ppStream);
+
+        [VtblIndex(11)]
+        [return: NativeTypeName("HRESULT")]
+        int GetBlobAsUtf8(IDxcBlob* pBlob, IDxcBlobEncoding** pBlobEncoding);
+
+        [VtblIndex(12)]
+        [return: NativeTypeName("HRESULT")]
+        int GetBlobAsWide(IDxcBlob* pBlob, IDxcBlobEncoding** pBlobEncoding);
+    }
+
+    public partial struct Vtbl<TSelf>
+        where TSelf : unmanaged, Interface
+    {
+        [NativeTypeName("HRESULT (const IID &, void **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, Guid*, void**, int> QueryInterface;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> AddRef;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> Release;
+
+        [NativeTypeName("HRESULT (IMalloc *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IMalloc*, int> SetMalloc;
+
+        [NativeTypeName("HRESULT (IDxcBlob *, UINT32, UINT32, IDxcBlob **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcBlob*, uint, uint, IDxcBlob**, int> CreateBlobFromBlob;
+
+        [NativeTypeName("HRESULT (LPCWSTR, UINT32 *, IDxcBlobEncoding **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, char*, uint*, IDxcBlobEncoding**, int> CreateBlobFromFile;
+
+        [NativeTypeName("HRESULT (LPCVOID, UINT32, UINT32, IDxcBlobEncoding **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, void*, uint, uint, IDxcBlobEncoding**, int> CreateBlobWithEncodingFromPinned;
+
+        [NativeTypeName("HRESULT (LPCVOID, UINT32, UINT32, IDxcBlobEncoding **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, void*, uint, uint, IDxcBlobEncoding**, int> CreateBlobWithEncodingOnHeapCopy;
+
+        [NativeTypeName("HRESULT (LPCVOID, IMalloc *, UINT32, UINT32, IDxcBlobEncoding **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, void*, IMalloc*, uint, uint, IDxcBlobEncoding**, int> CreateBlobWithEncodingOnMalloc;
+
+        [NativeTypeName("HRESULT (IDxcIncludeHandler **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcIncludeHandler**, int> CreateIncludeHandler;
+
+        [NativeTypeName("HRESULT (IDxcBlob *, IStream **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcBlob*, IStream**, int> CreateStreamFromBlobReadOnly;
+
+        [NativeTypeName("HRESULT (IDxcBlob *, IDxcBlobEncoding **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcBlob*, IDxcBlobEncoding**, int> GetBlobAsUtf8;
+
+        [NativeTypeName("HRESULT (IDxcBlob *, IDxcBlobEncoding **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcBlob*, IDxcBlobEncoding**, int> GetBlobAsWide;
+    }
+}

src/ThridParty/Ghost.DXC/Generated/IDxcLinker.cs

@@ -0,0 +1,92 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using static Ghost.DXC.Api;
+
+namespace Ghost.DXC;
+
+/// <include file='IDxcLinker.xml' path='doc/member[@name="IDxcLinker"]/*' />
+[Guid("F1B5BE2A-62DD-4327-A1C2-42AC1E1E78E6")]
+[NativeTypeName("struct IDxcLinker : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcLinker : IDxcLinker.Interface, INativeGuid
+{
+    static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(in IID_IDxcLinker);
+
+    public void** lpVtbl;
+
+    /// <inheritdoc cref="IUnknown.QueryInterface" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(0)]
+    [return: NativeTypeName("HRESULT")]
+    public int QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcLinker*, Guid*, void**, int>)(lpVtbl[0]))((IDxcLinker*)Unsafe.AsPointer(ref this), riid, ppvObject);
+    }
+
+    /// <inheritdoc cref="IUnknown.AddRef" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(1)]
+    [return: NativeTypeName("ULONG")]
+    public uint AddRef()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcLinker*, uint>)(lpVtbl[1]))((IDxcLinker*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IUnknown.Release" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(2)]
+    [return: NativeTypeName("ULONG")]
+    public uint Release()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcLinker*, uint>)(lpVtbl[2]))((IDxcLinker*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <include file='IDxcLinker.xml' path='doc/member[@name="IDxcLinker.RegisterLibrary"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(3)]
+    [return: NativeTypeName("HRESULT")]
+    public int RegisterLibrary([NativeTypeName("LPCWSTR")] char* pLibName, IDxcBlob* pLib)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcLinker*, char*, IDxcBlob*, int>)(lpVtbl[3]))((IDxcLinker*)Unsafe.AsPointer(ref this), pLibName, pLib);
+    }
+
+    /// <include file='IDxcLinker.xml' path='doc/member[@name="IDxcLinker.Link"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(4)]
+    [return: NativeTypeName("HRESULT")]
+    public int Link([NativeTypeName("LPCWSTR")] char* pEntryName, [NativeTypeName("LPCWSTR")] char* pTargetProfile, [NativeTypeName("const LPCWSTR *")] char** pLibNames, [NativeTypeName("UINT32")] uint libCount, [NativeTypeName("const LPCWSTR *")] char** pArguments, [NativeTypeName("UINT32")] uint argCount, IDxcOperationResult** ppResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcLinker*, char*, char*, char**, uint, char**, uint, IDxcOperationResult**, int>)(lpVtbl[4]))((IDxcLinker*)Unsafe.AsPointer(ref this), pEntryName, pTargetProfile, pLibNames, libCount, pArguments, argCount, ppResult);
+    }
+
+    public interface Interface : IUnknown.Interface
+    {
+        [VtblIndex(3)]
+        [return: NativeTypeName("HRESULT")]
+        int RegisterLibrary([NativeTypeName("LPCWSTR")] char* pLibName, IDxcBlob* pLib);
+
+        [VtblIndex(4)]
+        [return: NativeTypeName("HRESULT")]
+        int Link([NativeTypeName("LPCWSTR")] char* pEntryName, [NativeTypeName("LPCWSTR")] char* pTargetProfile, [NativeTypeName("const LPCWSTR *")] char** pLibNames, [NativeTypeName("UINT32")] uint libCount, [NativeTypeName("const LPCWSTR *")] char** pArguments, [NativeTypeName("UINT32")] uint argCount, IDxcOperationResult** ppResult);
+    }
+
+    public partial struct Vtbl<TSelf>
+        where TSelf : unmanaged, Interface
+    {
+        [NativeTypeName("HRESULT (const IID &, void **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, Guid*, void**, int> QueryInterface;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> AddRef;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> Release;
+
+        [NativeTypeName("HRESULT (LPCWSTR, IDxcBlob *)")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, char*, IDxcBlob*, int> RegisterLibrary;
+
+        [NativeTypeName("HRESULT (LPCWSTR, LPCWSTR, const LPCWSTR *, UINT32, const LPCWSTR *, UINT32, IDxcOperationResult **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, char*, char*, char**, uint, char**, uint, IDxcOperationResult**, int> Link;
+    }
+}

src/ThridParty/Ghost.DXC/Generated/IDxcOperationResult.cs

@@ -0,0 +1,108 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using static Ghost.DXC.Api;
+
+namespace Ghost.DXC;
+
+/// <include file='IDxcOperationResult.xml' path='doc/member[@name="IDxcOperationResult"]/*' />
+[Guid("CEDB484A-D4E9-445A-B991-CA21CA157DC2")]
+[NativeTypeName("struct IDxcOperationResult : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcOperationResult : IDxcOperationResult.Interface, INativeGuid
+{
+    static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(in IID_IDxcOperationResult);
+
+    public void** lpVtbl;
+
+    /// <inheritdoc cref="IUnknown.QueryInterface" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(0)]
+    [return: NativeTypeName("HRESULT")]
+    public int QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcOperationResult*, Guid*, void**, int>)(lpVtbl[0]))((IDxcOperationResult*)Unsafe.AsPointer(ref this), riid, ppvObject);
+    }
+
+    /// <inheritdoc cref="IUnknown.AddRef" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(1)]
+    [return: NativeTypeName("ULONG")]
+    public uint AddRef()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcOperationResult*, uint>)(lpVtbl[1]))((IDxcOperationResult*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IUnknown.Release" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(2)]
+    [return: NativeTypeName("ULONG")]
+    public uint Release()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcOperationResult*, uint>)(lpVtbl[2]))((IDxcOperationResult*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <include file='IDxcOperationResult.xml' path='doc/member[@name="IDxcOperationResult.GetStatus"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(3)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetStatus([NativeTypeName("HRESULT *")] int* pStatus)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcOperationResult*, int*, int>)(lpVtbl[3]))((IDxcOperationResult*)Unsafe.AsPointer(ref this), pStatus);
+    }
+
+    /// <include file='IDxcOperationResult.xml' path='doc/member[@name="IDxcOperationResult.GetResult"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(4)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetResult(IDxcBlob** ppResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcOperationResult*, IDxcBlob**, int>)(lpVtbl[4]))((IDxcOperationResult*)Unsafe.AsPointer(ref this), ppResult);
+    }
+
+    /// <include file='IDxcOperationResult.xml' path='doc/member[@name="IDxcOperationResult.GetErrorBuffer"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(5)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetErrorBuffer(IDxcBlobEncoding** ppErrors)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcOperationResult*, IDxcBlobEncoding**, int>)(lpVtbl[5]))((IDxcOperationResult*)Unsafe.AsPointer(ref this), ppErrors);
+    }
+
+    public interface Interface : IUnknown.Interface
+    {
+        [VtblIndex(3)]
+        [return: NativeTypeName("HRESULT")]
+        int GetStatus([NativeTypeName("HRESULT *")] int* pStatus);
+
+        [VtblIndex(4)]
+        [return: NativeTypeName("HRESULT")]
+        int GetResult(IDxcBlob** ppResult);
+
+        [VtblIndex(5)]
+        [return: NativeTypeName("HRESULT")]
+        int GetErrorBuffer(IDxcBlobEncoding** ppErrors);
+    }
+
+    public partial struct Vtbl<TSelf>
+        where TSelf : unmanaged, Interface
+    {
+        [NativeTypeName("HRESULT (const IID &, void **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, Guid*, void**, int> QueryInterface;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> AddRef;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> Release;
+
+        [NativeTypeName("HRESULT (HRESULT *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, int*, int> GetStatus;
+
+        [NativeTypeName("HRESULT (IDxcBlob **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcBlob**, int> GetResult;
+
+        [NativeTypeName("HRESULT (IDxcBlobEncoding **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcBlobEncoding**, int> GetErrorBuffer;
+    }
+}

src/ThridParty/Ghost.DXC/Generated/IDxcOptimizer.cs

@@ -0,0 +1,108 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using static Ghost.DXC.Api;
+
+namespace Ghost.DXC;
+
+/// <include file='IDxcOptimizer.xml' path='doc/member[@name="IDxcOptimizer"]/*' />
+[Guid("25740E2E-9CBA-401B-9119-4FB42F39F270")]
+[NativeTypeName("struct IDxcOptimizer : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcOptimizer : IDxcOptimizer.Interface, INativeGuid
+{
+    static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(in IID_IDxcOptimizer);
+
+    public void** lpVtbl;
+
+    /// <inheritdoc cref="IUnknown.QueryInterface" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(0)]
+    [return: NativeTypeName("HRESULT")]
+    public int QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcOptimizer*, Guid*, void**, int>)(lpVtbl[0]))((IDxcOptimizer*)Unsafe.AsPointer(ref this), riid, ppvObject);
+    }
+
+    /// <inheritdoc cref="IUnknown.AddRef" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(1)]
+    [return: NativeTypeName("ULONG")]
+    public uint AddRef()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcOptimizer*, uint>)(lpVtbl[1]))((IDxcOptimizer*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IUnknown.Release" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(2)]
+    [return: NativeTypeName("ULONG")]
+    public uint Release()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcOptimizer*, uint>)(lpVtbl[2]))((IDxcOptimizer*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <include file='IDxcOptimizer.xml' path='doc/member[@name="IDxcOptimizer.GetAvailablePassCount"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(3)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetAvailablePassCount([NativeTypeName("UINT32 *")] uint* pCount)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcOptimizer*, uint*, int>)(lpVtbl[3]))((IDxcOptimizer*)Unsafe.AsPointer(ref this), pCount);
+    }
+
+    /// <include file='IDxcOptimizer.xml' path='doc/member[@name="IDxcOptimizer.GetAvailablePass"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(4)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetAvailablePass([NativeTypeName("UINT32")] uint index, IDxcOptimizerPass** ppResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcOptimizer*, uint, IDxcOptimizerPass**, int>)(lpVtbl[4]))((IDxcOptimizer*)Unsafe.AsPointer(ref this), index, ppResult);
+    }
+
+    /// <include file='IDxcOptimizer.xml' path='doc/member[@name="IDxcOptimizer.RunOptimizer"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(5)]
+    [return: NativeTypeName("HRESULT")]
+    public int RunOptimizer(IDxcBlob* pBlob, [NativeTypeName("LPCWSTR *")] char** ppOptions, [NativeTypeName("UINT32")] uint optionCount, IDxcBlob** pOutputModule, IDxcBlobEncoding** ppOutputText)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcOptimizer*, IDxcBlob*, char**, uint, IDxcBlob**, IDxcBlobEncoding**, int>)(lpVtbl[5]))((IDxcOptimizer*)Unsafe.AsPointer(ref this), pBlob, ppOptions, optionCount, pOutputModule, ppOutputText);
+    }
+
+    public interface Interface : IUnknown.Interface
+    {
+        [VtblIndex(3)]
+        [return: NativeTypeName("HRESULT")]
+        int GetAvailablePassCount([NativeTypeName("UINT32 *")] uint* pCount);
+
+        [VtblIndex(4)]
+        [return: NativeTypeName("HRESULT")]
+        int GetAvailablePass([NativeTypeName("UINT32")] uint index, IDxcOptimizerPass** ppResult);
+
+        [VtblIndex(5)]
+        [return: NativeTypeName("HRESULT")]
+        int RunOptimizer(IDxcBlob* pBlob, [NativeTypeName("LPCWSTR *")] char** ppOptions, [NativeTypeName("UINT32")] uint optionCount, IDxcBlob** pOutputModule, IDxcBlobEncoding** ppOutputText);
+    }
+
+    public partial struct Vtbl<TSelf>
+        where TSelf : unmanaged, Interface
+    {
+        [NativeTypeName("HRESULT (const IID &, void **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, Guid*, void**, int> QueryInterface;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> AddRef;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> Release;
+
+        [NativeTypeName("HRESULT (UINT32 *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint*, int> GetAvailablePassCount;
+
+        [NativeTypeName("HRESULT (UINT32, IDxcOptimizerPass **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint, IDxcOptimizerPass**, int> GetAvailablePass;
+
+        [NativeTypeName("HRESULT (IDxcBlob *, LPCWSTR *, UINT32, IDxcBlob **, IDxcBlobEncoding **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcBlob*, char**, uint, IDxcBlob**, IDxcBlobEncoding**, int> RunOptimizer;
+    }
+}

src/ThridParty/Ghost.DXC/Generated/IDxcOptimizerPass.cs

@@ -0,0 +1,140 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using static Ghost.DXC.Api;
+
+namespace Ghost.DXC;
+
+/// <include file='IDxcOptimizerPass.xml' path='doc/member[@name="IDxcOptimizerPass"]/*' />
+[Guid("AE2CD79F-CC22-453F-9B6B-B124E7A5204C")]
+[NativeTypeName("struct IDxcOptimizerPass : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcOptimizerPass : IDxcOptimizerPass.Interface, INativeGuid
+{
+    static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(in IID_IDxcOptimizerPass);
+
+    public void** lpVtbl;
+
+    /// <inheritdoc cref="IUnknown.QueryInterface" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(0)]
+    [return: NativeTypeName("HRESULT")]
+    public int QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcOptimizerPass*, Guid*, void**, int>)(lpVtbl[0]))((IDxcOptimizerPass*)Unsafe.AsPointer(ref this), riid, ppvObject);
+    }
+
+    /// <inheritdoc cref="IUnknown.AddRef" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(1)]
+    [return: NativeTypeName("ULONG")]
+    public uint AddRef()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcOptimizerPass*, uint>)(lpVtbl[1]))((IDxcOptimizerPass*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IUnknown.Release" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(2)]
+    [return: NativeTypeName("ULONG")]
+    public uint Release()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcOptimizerPass*, uint>)(lpVtbl[2]))((IDxcOptimizerPass*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <include file='IDxcOptimizerPass.xml' path='doc/member[@name="IDxcOptimizerPass.GetOptionName"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(3)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetOptionName([NativeTypeName("LPWSTR *")] char** ppResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcOptimizerPass*, char**, int>)(lpVtbl[3]))((IDxcOptimizerPass*)Unsafe.AsPointer(ref this), ppResult);
+    }
+
+    /// <include file='IDxcOptimizerPass.xml' path='doc/member[@name="IDxcOptimizerPass.GetDescription"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(4)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetDescription([NativeTypeName("LPWSTR *")] char** ppResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcOptimizerPass*, char**, int>)(lpVtbl[4]))((IDxcOptimizerPass*)Unsafe.AsPointer(ref this), ppResult);
+    }
+
+    /// <include file='IDxcOptimizerPass.xml' path='doc/member[@name="IDxcOptimizerPass.GetOptionArgCount"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(5)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetOptionArgCount([NativeTypeName("UINT32 *")] uint* pCount)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcOptimizerPass*, uint*, int>)(lpVtbl[5]))((IDxcOptimizerPass*)Unsafe.AsPointer(ref this), pCount);
+    }
+
+    /// <include file='IDxcOptimizerPass.xml' path='doc/member[@name="IDxcOptimizerPass.GetOptionArgName"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(6)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetOptionArgName([NativeTypeName("UINT32")] uint argIndex, [NativeTypeName("LPWSTR *")] char** ppResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcOptimizerPass*, uint, char**, int>)(lpVtbl[6]))((IDxcOptimizerPass*)Unsafe.AsPointer(ref this), argIndex, ppResult);
+    }
+
+    /// <include file='IDxcOptimizerPass.xml' path='doc/member[@name="IDxcOptimizerPass.GetOptionArgDescription"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(7)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetOptionArgDescription([NativeTypeName("UINT32")] uint argIndex, [NativeTypeName("LPWSTR *")] char** ppResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcOptimizerPass*, uint, char**, int>)(lpVtbl[7]))((IDxcOptimizerPass*)Unsafe.AsPointer(ref this), argIndex, ppResult);
+    }
+
+    public interface Interface : IUnknown.Interface
+    {
+        [VtblIndex(3)]
+        [return: NativeTypeName("HRESULT")]
+        int GetOptionName([NativeTypeName("LPWSTR *")] char** ppResult);
+
+        [VtblIndex(4)]
+        [return: NativeTypeName("HRESULT")]
+        int GetDescription([NativeTypeName("LPWSTR *")] char** ppResult);
+
+        [VtblIndex(5)]
+        [return: NativeTypeName("HRESULT")]
+        int GetOptionArgCount([NativeTypeName("UINT32 *")] uint* pCount);
+
+        [VtblIndex(6)]
+        [return: NativeTypeName("HRESULT")]
+        int GetOptionArgName([NativeTypeName("UINT32")] uint argIndex, [NativeTypeName("LPWSTR *")] char** ppResult);
+
+        [VtblIndex(7)]
+        [return: NativeTypeName("HRESULT")]
+        int GetOptionArgDescription([NativeTypeName("UINT32")] uint argIndex, [NativeTypeName("LPWSTR *")] char** ppResult);
+    }
+
+    public partial struct Vtbl<TSelf>
+        where TSelf : unmanaged, Interface
+    {
+        [NativeTypeName("HRESULT (const IID &, void **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, Guid*, void**, int> QueryInterface;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> AddRef;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> Release;
+
+        [NativeTypeName("HRESULT (LPWSTR *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, char**, int> GetOptionName;
+
+        [NativeTypeName("HRESULT (LPWSTR *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, char**, int> GetDescription;
+
+        [NativeTypeName("HRESULT (UINT32 *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint*, int> GetOptionArgCount;
+
+        [NativeTypeName("HRESULT (UINT32, LPWSTR *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint, char**, int> GetOptionArgName;
+
+        [NativeTypeName("HRESULT (UINT32, LPWSTR *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint, char**, int> GetOptionArgDescription;
+    }
+}

src/ThridParty/Ghost.DXC/Generated/IDxcPdbUtils.cs

@@ -0,0 +1,444 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using static Ghost.DXC.Api;
+
+namespace Ghost.DXC;
+
+/// <include file='IDxcPdbUtils.xml' path='doc/member[@name="IDxcPdbUtils"]/*' />
+[Guid("E6C9647E-9D6A-4C3B-B94C-524B5A6C343D")]
+[NativeTypeName("struct IDxcPdbUtils : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcPdbUtils : IDxcPdbUtils.Interface, INativeGuid
+{
+    static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(in IID_IDxcPdbUtils);
+
+    public void** lpVtbl;
+
+    /// <inheritdoc cref="IUnknown.QueryInterface" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(0)]
+    [return: NativeTypeName("HRESULT")]
+    public int QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils*, Guid*, void**, int>)(lpVtbl[0]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), riid, ppvObject);
+    }
+
+    /// <inheritdoc cref="IUnknown.AddRef" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(1)]
+    [return: NativeTypeName("ULONG")]
+    public uint AddRef()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils*, uint>)(lpVtbl[1]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IUnknown.Release" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(2)]
+    [return: NativeTypeName("ULONG")]
+    public uint Release()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils*, uint>)(lpVtbl[2]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <include file='IDxcPdbUtils.xml' path='doc/member[@name="IDxcPdbUtils.Load"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(3)]
+    [return: NativeTypeName("HRESULT")]
+    public int Load(IDxcBlob* pPdbOrDxil)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils*, IDxcBlob*, int>)(lpVtbl[3]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), pPdbOrDxil);
+    }
+
+    /// <include file='IDxcPdbUtils.xml' path='doc/member[@name="IDxcPdbUtils.GetSourceCount"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(4)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetSourceCount([NativeTypeName("UINT32 *")] uint* pCount)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils*, uint*, int>)(lpVtbl[4]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), pCount);
+    }
+
+    /// <include file='IDxcPdbUtils.xml' path='doc/member[@name="IDxcPdbUtils.GetSource"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(5)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetSource([NativeTypeName("UINT32")] uint uIndex, IDxcBlobEncoding** ppResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils*, uint, IDxcBlobEncoding**, int>)(lpVtbl[5]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), uIndex, ppResult);
+    }
+
+    /// <include file='IDxcPdbUtils.xml' path='doc/member[@name="IDxcPdbUtils.GetSourceName"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(6)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetSourceName([NativeTypeName("UINT32")] uint uIndex, [NativeTypeName("BSTR *")] char** pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils*, uint, char**, int>)(lpVtbl[6]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), uIndex, pResult);
+    }
+
+    /// <include file='IDxcPdbUtils.xml' path='doc/member[@name="IDxcPdbUtils.GetFlagCount"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(7)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetFlagCount([NativeTypeName("UINT32 *")] uint* pCount)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils*, uint*, int>)(lpVtbl[7]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), pCount);
+    }
+
+    /// <include file='IDxcPdbUtils.xml' path='doc/member[@name="IDxcPdbUtils.GetFlag"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(8)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetFlag([NativeTypeName("UINT32")] uint uIndex, [NativeTypeName("BSTR *")] char** pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils*, uint, char**, int>)(lpVtbl[8]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), uIndex, pResult);
+    }
+
+    /// <include file='IDxcPdbUtils.xml' path='doc/member[@name="IDxcPdbUtils.GetArgCount"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(9)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetArgCount([NativeTypeName("UINT32 *")] uint* pCount)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils*, uint*, int>)(lpVtbl[9]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), pCount);
+    }
+
+    /// <include file='IDxcPdbUtils.xml' path='doc/member[@name="IDxcPdbUtils.GetArg"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(10)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetArg([NativeTypeName("UINT32")] uint uIndex, [NativeTypeName("BSTR *")] char** pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils*, uint, char**, int>)(lpVtbl[10]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), uIndex, pResult);
+    }
+
+    /// <include file='IDxcPdbUtils.xml' path='doc/member[@name="IDxcPdbUtils.GetArgPairCount"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(11)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetArgPairCount([NativeTypeName("UINT32 *")] uint* pCount)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils*, uint*, int>)(lpVtbl[11]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), pCount);
+    }
+
+    /// <include file='IDxcPdbUtils.xml' path='doc/member[@name="IDxcPdbUtils.GetArgPair"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(12)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetArgPair([NativeTypeName("UINT32")] uint uIndex, [NativeTypeName("BSTR *")] char** pName, [NativeTypeName("BSTR *")] char** pValue)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils*, uint, char**, char**, int>)(lpVtbl[12]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), uIndex, pName, pValue);
+    }
+
+    /// <include file='IDxcPdbUtils.xml' path='doc/member[@name="IDxcPdbUtils.GetDefineCount"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(13)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetDefineCount([NativeTypeName("UINT32 *")] uint* pCount)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils*, uint*, int>)(lpVtbl[13]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), pCount);
+    }
+
+    /// <include file='IDxcPdbUtils.xml' path='doc/member[@name="IDxcPdbUtils.GetDefine"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(14)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetDefine([NativeTypeName("UINT32")] uint uIndex, [NativeTypeName("BSTR *")] char** pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils*, uint, char**, int>)(lpVtbl[14]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), uIndex, pResult);
+    }
+
+    /// <include file='IDxcPdbUtils.xml' path='doc/member[@name="IDxcPdbUtils.GetTargetProfile"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(15)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetTargetProfile([NativeTypeName("BSTR *")] char** pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils*, char**, int>)(lpVtbl[15]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), pResult);
+    }
+
+    /// <include file='IDxcPdbUtils.xml' path='doc/member[@name="IDxcPdbUtils.GetEntryPoint"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(16)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetEntryPoint([NativeTypeName("BSTR *")] char** pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils*, char**, int>)(lpVtbl[16]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), pResult);
+    }
+
+    /// <include file='IDxcPdbUtils.xml' path='doc/member[@name="IDxcPdbUtils.GetMainFileName"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(17)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetMainFileName([NativeTypeName("BSTR *")] char** pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils*, char**, int>)(lpVtbl[17]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), pResult);
+    }
+
+    /// <include file='IDxcPdbUtils.xml' path='doc/member[@name="IDxcPdbUtils.GetHash"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(18)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetHash(IDxcBlob** ppResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils*, IDxcBlob**, int>)(lpVtbl[18]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), ppResult);
+    }
+
+    /// <include file='IDxcPdbUtils.xml' path='doc/member[@name="IDxcPdbUtils.GetName"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(19)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetName([NativeTypeName("BSTR *")] char** pResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils*, char**, int>)(lpVtbl[19]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), pResult);
+    }
+
+    /// <include file='IDxcPdbUtils.xml' path='doc/member[@name="IDxcPdbUtils.IsFullPDB"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(20)]
+    [return: NativeTypeName("BOOL")]
+    public int IsFullPDB()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils*, int>)(lpVtbl[20]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <include file='IDxcPdbUtils.xml' path='doc/member[@name="IDxcPdbUtils.GetFullPDB"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(21)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetFullPDB(IDxcBlob** ppFullPDB)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils*, IDxcBlob**, int>)(lpVtbl[21]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), ppFullPDB);
+    }
+
+    /// <include file='IDxcPdbUtils.xml' path='doc/member[@name="IDxcPdbUtils.GetVersionInfo"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(22)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetVersionInfo(IDxcVersionInfo** ppVersionInfo)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils*, IDxcVersionInfo**, int>)(lpVtbl[22]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), ppVersionInfo);
+    }
+
+    /// <include file='IDxcPdbUtils.xml' path='doc/member[@name="IDxcPdbUtils.SetCompiler"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(23)]
+    [return: NativeTypeName("HRESULT")]
+    public int SetCompiler(IDxcCompiler3* pCompiler)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils*, IDxcCompiler3*, int>)(lpVtbl[23]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), pCompiler);
+    }
+
+    /// <include file='IDxcPdbUtils.xml' path='doc/member[@name="IDxcPdbUtils.CompileForFullPDB"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(24)]
+    [return: NativeTypeName("HRESULT")]
+    public int CompileForFullPDB(IDxcResult** ppResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils*, IDxcResult**, int>)(lpVtbl[24]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), ppResult);
+    }
+
+    /// <include file='IDxcPdbUtils.xml' path='doc/member[@name="IDxcPdbUtils.OverrideArgs"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(25)]
+    [return: NativeTypeName("HRESULT")]
+    public int OverrideArgs(DxcArgPair* pArgPairs, [NativeTypeName("UINT32")] uint uNumArgPairs)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils*, DxcArgPair*, uint, int>)(lpVtbl[25]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), pArgPairs, uNumArgPairs);
+    }
+
+    /// <include file='IDxcPdbUtils.xml' path='doc/member[@name="IDxcPdbUtils.OverrideRootSignature"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(26)]
+    [return: NativeTypeName("HRESULT")]
+    public int OverrideRootSignature([NativeTypeName("const WCHAR *")] char* pRootSignature)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils*, char*, int>)(lpVtbl[26]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), pRootSignature);
+    }
+
+    public interface Interface : IUnknown.Interface
+    {
+        [VtblIndex(3)]
+        [return: NativeTypeName("HRESULT")]
+        int Load(IDxcBlob* pPdbOrDxil);
+
+        [VtblIndex(4)]
+        [return: NativeTypeName("HRESULT")]
+        int GetSourceCount([NativeTypeName("UINT32 *")] uint* pCount);
+
+        [VtblIndex(5)]
+        [return: NativeTypeName("HRESULT")]
+        int GetSource([NativeTypeName("UINT32")] uint uIndex, IDxcBlobEncoding** ppResult);
+
+        [VtblIndex(6)]
+        [return: NativeTypeName("HRESULT")]
+        int GetSourceName([NativeTypeName("UINT32")] uint uIndex, [NativeTypeName("BSTR *")] char** pResult);
+
+        [VtblIndex(7)]
+        [return: NativeTypeName("HRESULT")]
+        int GetFlagCount([NativeTypeName("UINT32 *")] uint* pCount);
+
+        [VtblIndex(8)]
+        [return: NativeTypeName("HRESULT")]
+        int GetFlag([NativeTypeName("UINT32")] uint uIndex, [NativeTypeName("BSTR *")] char** pResult);
+
+        [VtblIndex(9)]
+        [return: NativeTypeName("HRESULT")]
+        int GetArgCount([NativeTypeName("UINT32 *")] uint* pCount);
+
+        [VtblIndex(10)]
+        [return: NativeTypeName("HRESULT")]
+        int GetArg([NativeTypeName("UINT32")] uint uIndex, [NativeTypeName("BSTR *")] char** pResult);
+
+        [VtblIndex(11)]
+        [return: NativeTypeName("HRESULT")]
+        int GetArgPairCount([NativeTypeName("UINT32 *")] uint* pCount);
+
+        [VtblIndex(12)]
+        [return: NativeTypeName("HRESULT")]
+        int GetArgPair([NativeTypeName("UINT32")] uint uIndex, [NativeTypeName("BSTR *")] char** pName, [NativeTypeName("BSTR *")] char** pValue);
+
+        [VtblIndex(13)]
+        [return: NativeTypeName("HRESULT")]
+        int GetDefineCount([NativeTypeName("UINT32 *")] uint* pCount);
+
+        [VtblIndex(14)]
+        [return: NativeTypeName("HRESULT")]
+        int GetDefine([NativeTypeName("UINT32")] uint uIndex, [NativeTypeName("BSTR *")] char** pResult);
+
+        [VtblIndex(15)]
+        [return: NativeTypeName("HRESULT")]
+        int GetTargetProfile([NativeTypeName("BSTR *")] char** pResult);
+
+        [VtblIndex(16)]
+        [return: NativeTypeName("HRESULT")]
+        int GetEntryPoint([NativeTypeName("BSTR *")] char** pResult);
+
+        [VtblIndex(17)]
+        [return: NativeTypeName("HRESULT")]
+        int GetMainFileName([NativeTypeName("BSTR *")] char** pResult);
+
+        [VtblIndex(18)]
+        [return: NativeTypeName("HRESULT")]
+        int GetHash(IDxcBlob** ppResult);
+
+        [VtblIndex(19)]
+        [return: NativeTypeName("HRESULT")]
+        int GetName([NativeTypeName("BSTR *")] char** pResult);
+
+        [VtblIndex(20)]
+        [return: NativeTypeName("BOOL")]
+        int IsFullPDB();
+
+        [VtblIndex(21)]
+        [return: NativeTypeName("HRESULT")]
+        int GetFullPDB(IDxcBlob** ppFullPDB);
+
+        [VtblIndex(22)]
+        [return: NativeTypeName("HRESULT")]
+        int GetVersionInfo(IDxcVersionInfo** ppVersionInfo);
+
+        [VtblIndex(23)]
+        [return: NativeTypeName("HRESULT")]
+        int SetCompiler(IDxcCompiler3* pCompiler);
+
+        [VtblIndex(24)]
+        [return: NativeTypeName("HRESULT")]
+        int CompileForFullPDB(IDxcResult** ppResult);
+
+        [VtblIndex(25)]
+        [return: NativeTypeName("HRESULT")]
+        int OverrideArgs(DxcArgPair* pArgPairs, [NativeTypeName("UINT32")] uint uNumArgPairs);
+
+        [VtblIndex(26)]
+        [return: NativeTypeName("HRESULT")]
+        int OverrideRootSignature([NativeTypeName("const WCHAR *")] char* pRootSignature);
+    }
+
+    public partial struct Vtbl<TSelf>
+        where TSelf : unmanaged, Interface
+    {
+        [NativeTypeName("HRESULT (const IID &, void **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, Guid*, void**, int> QueryInterface;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> AddRef;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> Release;
+
+        [NativeTypeName("HRESULT (IDxcBlob *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcBlob*, int> Load;
+
+        [NativeTypeName("HRESULT (UINT32 *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint*, int> GetSourceCount;
+
+        [NativeTypeName("HRESULT (UINT32, IDxcBlobEncoding **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint, IDxcBlobEncoding**, int> GetSource;
+
+        [NativeTypeName("HRESULT (UINT32, BSTR *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint, char**, int> GetSourceName;
+
+        [NativeTypeName("HRESULT (UINT32 *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint*, int> GetFlagCount;
+
+        [NativeTypeName("HRESULT (UINT32, BSTR *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint, char**, int> GetFlag;
+
+        [NativeTypeName("HRESULT (UINT32 *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint*, int> GetArgCount;
+
+        [NativeTypeName("HRESULT (UINT32, BSTR *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint, char**, int> GetArg;
+
+        [NativeTypeName("HRESULT (UINT32 *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint*, int> GetArgPairCount;
+
+        [NativeTypeName("HRESULT (UINT32, BSTR *, BSTR *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint, char**, char**, int> GetArgPair;
+
+        [NativeTypeName("HRESULT (UINT32 *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint*, int> GetDefineCount;
+
+        [NativeTypeName("HRESULT (UINT32, BSTR *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint, char**, int> GetDefine;
+
+        [NativeTypeName("HRESULT (BSTR *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, char**, int> GetTargetProfile;
+
+        [NativeTypeName("HRESULT (BSTR *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, char**, int> GetEntryPoint;
+
+        [NativeTypeName("HRESULT (BSTR *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, char**, int> GetMainFileName;
+
+        [NativeTypeName("HRESULT (IDxcBlob **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcBlob**, int> GetHash;
+
+        [NativeTypeName("HRESULT (BSTR *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, char**, int> GetName;
+
+        [NativeTypeName("BOOL () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, int> IsFullPDB;
+
+        [NativeTypeName("HRESULT (IDxcBlob **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcBlob**, int> GetFullPDB;
+
+        [NativeTypeName("HRESULT (IDxcVersionInfo **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcVersionInfo**, int> GetVersionInfo;
+
+        [NativeTypeName("HRESULT (IDxcCompiler3 *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcCompiler3*, int> SetCompiler;
+
+        [NativeTypeName("HRESULT (IDxcResult **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcResult**, int> CompileForFullPDB;
+
+        [NativeTypeName("HRESULT (DxcArgPair *, UINT32) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, DxcArgPair*, uint, int> OverrideArgs;
+
+        [NativeTypeName("HRESULT (const WCHAR *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, char*, int> OverrideRootSignature;
+    }
+}

src/ThridParty/Ghost.DXC/Generated/IDxcPdbUtils2.cs

@@ -0,0 +1,460 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using static Ghost.DXC.Api;
+
+namespace Ghost.DXC;
+
+/// <include file='IDxcPdbUtils2.xml' path='doc/member[@name="IDxcPdbUtils2"]/*' />
+[Guid("4315D938-F369-4F93-95A2-252017CC3807")]
+[NativeTypeName("struct IDxcPdbUtils2 : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcPdbUtils2 : IDxcPdbUtils2.Interface, INativeGuid
+{
+    static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(in IID_IDxcPdbUtils2);
+
+    public void** lpVtbl;
+
+    /// <inheritdoc cref="IUnknown.QueryInterface" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(0)]
+    [return: NativeTypeName("HRESULT")]
+    public int QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils2*, Guid*, void**, int>)(lpVtbl[0]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this), riid, ppvObject);
+    }
+
+    /// <inheritdoc cref="IUnknown.AddRef" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(1)]
+    [return: NativeTypeName("ULONG")]
+    public uint AddRef()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils2*, uint>)(lpVtbl[1]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IUnknown.Release" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(2)]
+    [return: NativeTypeName("ULONG")]
+    public uint Release()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils2*, uint>)(lpVtbl[2]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <include file='IDxcPdbUtils2.xml' path='doc/member[@name="IDxcPdbUtils2.Load"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(3)]
+    [return: NativeTypeName("HRESULT")]
+    public int Load(IDxcBlob* pPdbOrDxil)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils2*, IDxcBlob*, int>)(lpVtbl[3]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this), pPdbOrDxil);
+    }
+
+    /// <include file='IDxcPdbUtils2.xml' path='doc/member[@name="IDxcPdbUtils2.GetSourceCount"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(4)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetSourceCount([NativeTypeName("UINT32 *")] uint* pCount)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils2*, uint*, int>)(lpVtbl[4]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this), pCount);
+    }
+
+    /// <include file='IDxcPdbUtils2.xml' path='doc/member[@name="IDxcPdbUtils2.GetSource"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(5)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetSource([NativeTypeName("UINT32")] uint uIndex, IDxcBlobEncoding** ppResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils2*, uint, IDxcBlobEncoding**, int>)(lpVtbl[5]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this), uIndex, ppResult);
+    }
+
+    /// <include file='IDxcPdbUtils2.xml' path='doc/member[@name="IDxcPdbUtils2.GetSourceName"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(6)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetSourceName([NativeTypeName("UINT32")] uint uIndex, IDxcBlobWide** ppResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils2*, uint, IDxcBlobWide**, int>)(lpVtbl[6]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this), uIndex, ppResult);
+    }
+
+    /// <include file='IDxcPdbUtils2.xml' path='doc/member[@name="IDxcPdbUtils2.GetLibraryPDBCount"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(7)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetLibraryPDBCount([NativeTypeName("UINT32 *")] uint* pCount)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils2*, uint*, int>)(lpVtbl[7]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this), pCount);
+    }
+
+    /// <include file='IDxcPdbUtils2.xml' path='doc/member[@name="IDxcPdbUtils2.GetLibraryPDB"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(8)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetLibraryPDB([NativeTypeName("UINT32")] uint uIndex, IDxcPdbUtils2** ppOutPdbUtils, IDxcBlobWide** ppLibraryName)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils2*, uint, IDxcPdbUtils2**, IDxcBlobWide**, int>)(lpVtbl[8]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this), uIndex, ppOutPdbUtils, ppLibraryName);
+    }
+
+    /// <include file='IDxcPdbUtils2.xml' path='doc/member[@name="IDxcPdbUtils2.GetFlagCount"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(9)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetFlagCount([NativeTypeName("UINT32 *")] uint* pCount)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils2*, uint*, int>)(lpVtbl[9]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this), pCount);
+    }
+
+    /// <include file='IDxcPdbUtils2.xml' path='doc/member[@name="IDxcPdbUtils2.GetFlag"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(10)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetFlag([NativeTypeName("UINT32")] uint uIndex, IDxcBlobWide** ppResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils2*, uint, IDxcBlobWide**, int>)(lpVtbl[10]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this), uIndex, ppResult);
+    }
+
+    /// <include file='IDxcPdbUtils2.xml' path='doc/member[@name="IDxcPdbUtils2.GetArgCount"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(11)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetArgCount([NativeTypeName("UINT32 *")] uint* pCount)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils2*, uint*, int>)(lpVtbl[11]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this), pCount);
+    }
+
+    /// <include file='IDxcPdbUtils2.xml' path='doc/member[@name="IDxcPdbUtils2.GetArg"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(12)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetArg([NativeTypeName("UINT32")] uint uIndex, IDxcBlobWide** ppResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils2*, uint, IDxcBlobWide**, int>)(lpVtbl[12]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this), uIndex, ppResult);
+    }
+
+    /// <include file='IDxcPdbUtils2.xml' path='doc/member[@name="IDxcPdbUtils2.GetArgPairCount"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(13)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetArgPairCount([NativeTypeName("UINT32 *")] uint* pCount)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils2*, uint*, int>)(lpVtbl[13]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this), pCount);
+    }
+
+    /// <include file='IDxcPdbUtils2.xml' path='doc/member[@name="IDxcPdbUtils2.GetArgPair"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(14)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetArgPair([NativeTypeName("UINT32")] uint uIndex, IDxcBlobWide** ppName, IDxcBlobWide** ppValue)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils2*, uint, IDxcBlobWide**, IDxcBlobWide**, int>)(lpVtbl[14]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this), uIndex, ppName, ppValue);
+    }
+
+    /// <include file='IDxcPdbUtils2.xml' path='doc/member[@name="IDxcPdbUtils2.GetDefineCount"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(15)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetDefineCount([NativeTypeName("UINT32 *")] uint* pCount)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils2*, uint*, int>)(lpVtbl[15]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this), pCount);
+    }
+
+    /// <include file='IDxcPdbUtils2.xml' path='doc/member[@name="IDxcPdbUtils2.GetDefine"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(16)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetDefine([NativeTypeName("UINT32")] uint uIndex, IDxcBlobWide** ppResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils2*, uint, IDxcBlobWide**, int>)(lpVtbl[16]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this), uIndex, ppResult);
+    }
+
+    /// <include file='IDxcPdbUtils2.xml' path='doc/member[@name="IDxcPdbUtils2.GetTargetProfile"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(17)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetTargetProfile(IDxcBlobWide** ppResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils2*, IDxcBlobWide**, int>)(lpVtbl[17]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this), ppResult);
+    }
+
+    /// <include file='IDxcPdbUtils2.xml' path='doc/member[@name="IDxcPdbUtils2.GetEntryPoint"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(18)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetEntryPoint(IDxcBlobWide** ppResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils2*, IDxcBlobWide**, int>)(lpVtbl[18]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this), ppResult);
+    }
+
+    /// <include file='IDxcPdbUtils2.xml' path='doc/member[@name="IDxcPdbUtils2.GetMainFileName"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(19)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetMainFileName(IDxcBlobWide** ppResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils2*, IDxcBlobWide**, int>)(lpVtbl[19]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this), ppResult);
+    }
+
+    /// <include file='IDxcPdbUtils2.xml' path='doc/member[@name="IDxcPdbUtils2.GetHash"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(20)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetHash(IDxcBlob** ppResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils2*, IDxcBlob**, int>)(lpVtbl[20]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this), ppResult);
+    }
+
+    /// <include file='IDxcPdbUtils2.xml' path='doc/member[@name="IDxcPdbUtils2.GetName"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(21)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetName(IDxcBlobWide** ppResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils2*, IDxcBlobWide**, int>)(lpVtbl[21]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this), ppResult);
+    }
+
+    /// <include file='IDxcPdbUtils2.xml' path='doc/member[@name="IDxcPdbUtils2.GetVersionInfo"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(22)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetVersionInfo(IDxcVersionInfo** ppVersionInfo)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils2*, IDxcVersionInfo**, int>)(lpVtbl[22]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this), ppVersionInfo);
+    }
+
+    /// <include file='IDxcPdbUtils2.xml' path='doc/member[@name="IDxcPdbUtils2.GetCustomToolchainID"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(23)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetCustomToolchainID([NativeTypeName("UINT32 *")] uint* pID)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils2*, uint*, int>)(lpVtbl[23]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this), pID);
+    }
+
+    /// <include file='IDxcPdbUtils2.xml' path='doc/member[@name="IDxcPdbUtils2.GetCustomToolchainData"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(24)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetCustomToolchainData(IDxcBlob** ppBlob)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils2*, IDxcBlob**, int>)(lpVtbl[24]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this), ppBlob);
+    }
+
+    /// <include file='IDxcPdbUtils2.xml' path='doc/member[@name="IDxcPdbUtils2.GetWholeDxil"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(25)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetWholeDxil(IDxcBlob** ppResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils2*, IDxcBlob**, int>)(lpVtbl[25]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this), ppResult);
+    }
+
+    /// <include file='IDxcPdbUtils2.xml' path='doc/member[@name="IDxcPdbUtils2.IsFullPDB"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(26)]
+    [return: NativeTypeName("BOOL")]
+    public int IsFullPDB()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils2*, int>)(lpVtbl[26]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <include file='IDxcPdbUtils2.xml' path='doc/member[@name="IDxcPdbUtils2.IsPDBRef"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(27)]
+    [return: NativeTypeName("BOOL")]
+    public int IsPDBRef()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPdbUtils2*, int>)(lpVtbl[27]))((IDxcPdbUtils2*)Unsafe.AsPointer(ref this));
+    }
+
+    public interface Interface : IUnknown.Interface
+    {
+        [VtblIndex(3)]
+        [return: NativeTypeName("HRESULT")]
+        int Load(IDxcBlob* pPdbOrDxil);
+
+        [VtblIndex(4)]
+        [return: NativeTypeName("HRESULT")]
+        int GetSourceCount([NativeTypeName("UINT32 *")] uint* pCount);
+
+        [VtblIndex(5)]
+        [return: NativeTypeName("HRESULT")]
+        int GetSource([NativeTypeName("UINT32")] uint uIndex, IDxcBlobEncoding** ppResult);
+
+        [VtblIndex(6)]
+        [return: NativeTypeName("HRESULT")]
+        int GetSourceName([NativeTypeName("UINT32")] uint uIndex, IDxcBlobWide** ppResult);
+
+        [VtblIndex(7)]
+        [return: NativeTypeName("HRESULT")]
+        int GetLibraryPDBCount([NativeTypeName("UINT32 *")] uint* pCount);
+
+        [VtblIndex(8)]
+        [return: NativeTypeName("HRESULT")]
+        int GetLibraryPDB([NativeTypeName("UINT32")] uint uIndex, IDxcPdbUtils2** ppOutPdbUtils, IDxcBlobWide** ppLibraryName);
+
+        [VtblIndex(9)]
+        [return: NativeTypeName("HRESULT")]
+        int GetFlagCount([NativeTypeName("UINT32 *")] uint* pCount);
+
+        [VtblIndex(10)]
+        [return: NativeTypeName("HRESULT")]
+        int GetFlag([NativeTypeName("UINT32")] uint uIndex, IDxcBlobWide** ppResult);
+
+        [VtblIndex(11)]
+        [return: NativeTypeName("HRESULT")]
+        int GetArgCount([NativeTypeName("UINT32 *")] uint* pCount);
+
+        [VtblIndex(12)]
+        [return: NativeTypeName("HRESULT")]
+        int GetArg([NativeTypeName("UINT32")] uint uIndex, IDxcBlobWide** ppResult);
+
+        [VtblIndex(13)]
+        [return: NativeTypeName("HRESULT")]
+        int GetArgPairCount([NativeTypeName("UINT32 *")] uint* pCount);
+
+        [VtblIndex(14)]
+        [return: NativeTypeName("HRESULT")]
+        int GetArgPair([NativeTypeName("UINT32")] uint uIndex, IDxcBlobWide** ppName, IDxcBlobWide** ppValue);
+
+        [VtblIndex(15)]
+        [return: NativeTypeName("HRESULT")]
+        int GetDefineCount([NativeTypeName("UINT32 *")] uint* pCount);
+
+        [VtblIndex(16)]
+        [return: NativeTypeName("HRESULT")]
+        int GetDefine([NativeTypeName("UINT32")] uint uIndex, IDxcBlobWide** ppResult);
+
+        [VtblIndex(17)]
+        [return: NativeTypeName("HRESULT")]
+        int GetTargetProfile(IDxcBlobWide** ppResult);
+
+        [VtblIndex(18)]
+        [return: NativeTypeName("HRESULT")]
+        int GetEntryPoint(IDxcBlobWide** ppResult);
+
+        [VtblIndex(19)]
+        [return: NativeTypeName("HRESULT")]
+        int GetMainFileName(IDxcBlobWide** ppResult);
+
+        [VtblIndex(20)]
+        [return: NativeTypeName("HRESULT")]
+        int GetHash(IDxcBlob** ppResult);
+
+        [VtblIndex(21)]
+        [return: NativeTypeName("HRESULT")]
+        int GetName(IDxcBlobWide** ppResult);
+
+        [VtblIndex(22)]
+        [return: NativeTypeName("HRESULT")]
+        int GetVersionInfo(IDxcVersionInfo** ppVersionInfo);
+
+        [VtblIndex(23)]
+        [return: NativeTypeName("HRESULT")]
+        int GetCustomToolchainID([NativeTypeName("UINT32 *")] uint* pID);
+
+        [VtblIndex(24)]
+        [return: NativeTypeName("HRESULT")]
+        int GetCustomToolchainData(IDxcBlob** ppBlob);
+
+        [VtblIndex(25)]
+        [return: NativeTypeName("HRESULT")]
+        int GetWholeDxil(IDxcBlob** ppResult);
+
+        [VtblIndex(26)]
+        [return: NativeTypeName("BOOL")]
+        int IsFullPDB();
+
+        [VtblIndex(27)]
+        [return: NativeTypeName("BOOL")]
+        int IsPDBRef();
+    }
+
+    public partial struct Vtbl<TSelf>
+        where TSelf : unmanaged, Interface
+    {
+        [NativeTypeName("HRESULT (const IID &, void **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, Guid*, void**, int> QueryInterface;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> AddRef;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> Release;
+
+        [NativeTypeName("HRESULT (IDxcBlob *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcBlob*, int> Load;
+
+        [NativeTypeName("HRESULT (UINT32 *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint*, int> GetSourceCount;
+
+        [NativeTypeName("HRESULT (UINT32, IDxcBlobEncoding **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint, IDxcBlobEncoding**, int> GetSource;
+
+        [NativeTypeName("HRESULT (UINT32, IDxcBlobWide **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint, IDxcBlobWide**, int> GetSourceName;
+
+        [NativeTypeName("HRESULT (UINT32 *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint*, int> GetLibraryPDBCount;
+
+        [NativeTypeName("HRESULT (UINT32, IDxcPdbUtils2 **, IDxcBlobWide **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint, IDxcPdbUtils2**, IDxcBlobWide**, int> GetLibraryPDB;
+
+        [NativeTypeName("HRESULT (UINT32 *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint*, int> GetFlagCount;
+
+        [NativeTypeName("HRESULT (UINT32, IDxcBlobWide **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint, IDxcBlobWide**, int> GetFlag;
+
+        [NativeTypeName("HRESULT (UINT32 *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint*, int> GetArgCount;
+
+        [NativeTypeName("HRESULT (UINT32, IDxcBlobWide **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint, IDxcBlobWide**, int> GetArg;
+
+        [NativeTypeName("HRESULT (UINT32 *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint*, int> GetArgPairCount;
+
+        [NativeTypeName("HRESULT (UINT32, IDxcBlobWide **, IDxcBlobWide **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint, IDxcBlobWide**, IDxcBlobWide**, int> GetArgPair;
+
+        [NativeTypeName("HRESULT (UINT32 *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint*, int> GetDefineCount;
+
+        [NativeTypeName("HRESULT (UINT32, IDxcBlobWide **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint, IDxcBlobWide**, int> GetDefine;
+
+        [NativeTypeName("HRESULT (IDxcBlobWide **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcBlobWide**, int> GetTargetProfile;
+
+        [NativeTypeName("HRESULT (IDxcBlobWide **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcBlobWide**, int> GetEntryPoint;
+
+        [NativeTypeName("HRESULT (IDxcBlobWide **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcBlobWide**, int> GetMainFileName;
+
+        [NativeTypeName("HRESULT (IDxcBlob **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcBlob**, int> GetHash;
+
+        [NativeTypeName("HRESULT (IDxcBlobWide **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcBlobWide**, int> GetName;
+
+        [NativeTypeName("HRESULT (IDxcVersionInfo **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcVersionInfo**, int> GetVersionInfo;
+
+        [NativeTypeName("HRESULT (UINT32 *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint*, int> GetCustomToolchainID;
+
+        [NativeTypeName("HRESULT (IDxcBlob **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcBlob**, int> GetCustomToolchainData;
+
+        [NativeTypeName("HRESULT (IDxcBlob **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcBlob**, int> GetWholeDxil;
+
+        [NativeTypeName("BOOL () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, int> IsFullPDB;
+
+        [NativeTypeName("BOOL () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, int> IsPDBRef;
+    }
+}

src/ThridParty/Ghost.DXC/Generated/IDxcPixArrayType.cs

@@ -0,0 +1,144 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using static Ghost.DXC.Api;
+
+namespace Ghost.DXC;
+
+/// <include file='IDxcPixArrayType.xml' path='doc/member[@name="IDxcPixArrayType"]/*' />
+[Guid("9BA0D9D3-457B-426F-8019-9F3849982AA2")]
+[NativeTypeName("struct IDxcPixArrayType : IDxcPixType")]
+[NativeInheritance("IDxcPixType")]
+public unsafe partial struct IDxcPixArrayType : IDxcPixArrayType.Interface, INativeGuid
+{
+    static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(in IID_IDxcPixArrayType);
+
+    public void** lpVtbl;
+
+    /// <inheritdoc cref="IUnknown.QueryInterface" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(0)]
+    [return: NativeTypeName("HRESULT")]
+    public int QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixArrayType*, Guid*, void**, int>)(lpVtbl[0]))((IDxcPixArrayType*)Unsafe.AsPointer(ref this), riid, ppvObject);
+    }
+
+    /// <inheritdoc cref="IUnknown.AddRef" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(1)]
+    [return: NativeTypeName("ULONG")]
+    public uint AddRef()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixArrayType*, uint>)(lpVtbl[1]))((IDxcPixArrayType*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IUnknown.Release" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(2)]
+    [return: NativeTypeName("ULONG")]
+    public uint Release()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixArrayType*, uint>)(lpVtbl[2]))((IDxcPixArrayType*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IDxcPixType.GetName" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(3)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetName([NativeTypeName("BSTR *")] char** Name)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixArrayType*, char**, int>)(lpVtbl[3]))((IDxcPixArrayType*)Unsafe.AsPointer(ref this), Name);
+    }
+
+    /// <inheritdoc cref="IDxcPixType.GetSizeInBits" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(4)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetSizeInBits([NativeTypeName("DWORD *")] uint* GetSizeInBits)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixArrayType*, uint*, int>)(lpVtbl[4]))((IDxcPixArrayType*)Unsafe.AsPointer(ref this), GetSizeInBits);
+    }
+
+    /// <inheritdoc cref="IDxcPixType.UnAlias" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(5)]
+    [return: NativeTypeName("HRESULT")]
+    public int UnAlias(IDxcPixType** ppBaseType)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixArrayType*, IDxcPixType**, int>)(lpVtbl[5]))((IDxcPixArrayType*)Unsafe.AsPointer(ref this), ppBaseType);
+    }
+
+    /// <include file='IDxcPixArrayType.xml' path='doc/member[@name="IDxcPixArrayType.GetNumElements"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(6)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetNumElements([NativeTypeName("DWORD *")] uint* ppNumElements)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixArrayType*, uint*, int>)(lpVtbl[6]))((IDxcPixArrayType*)Unsafe.AsPointer(ref this), ppNumElements);
+    }
+
+    /// <include file='IDxcPixArrayType.xml' path='doc/member[@name="IDxcPixArrayType.GetIndexedType"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(7)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetIndexedType(IDxcPixType** ppElementType)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixArrayType*, IDxcPixType**, int>)(lpVtbl[7]))((IDxcPixArrayType*)Unsafe.AsPointer(ref this), ppElementType);
+    }
+
+    /// <include file='IDxcPixArrayType.xml' path='doc/member[@name="IDxcPixArrayType.GetElementType"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(8)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetElementType(IDxcPixType** ppElementType)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixArrayType*, IDxcPixType**, int>)(lpVtbl[8]))((IDxcPixArrayType*)Unsafe.AsPointer(ref this), ppElementType);
+    }
+
+    public interface Interface : IDxcPixType.Interface
+    {
+        [VtblIndex(6)]
+        [return: NativeTypeName("HRESULT")]
+        int GetNumElements([NativeTypeName("DWORD *")] uint* ppNumElements);
+
+        [VtblIndex(7)]
+        [return: NativeTypeName("HRESULT")]
+        int GetIndexedType(IDxcPixType** ppElementType);
+
+        [VtblIndex(8)]
+        [return: NativeTypeName("HRESULT")]
+        int GetElementType(IDxcPixType** ppElementType);
+    }
+
+    public partial struct Vtbl<TSelf>
+        where TSelf : unmanaged, Interface
+    {
+        [NativeTypeName("HRESULT (const IID &, void **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, Guid*, void**, int> QueryInterface;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> AddRef;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> Release;
+
+        [NativeTypeName("HRESULT (BSTR *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, char**, int> GetName;
+
+        [NativeTypeName("HRESULT (DWORD *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint*, int> GetSizeInBits;
+
+        [NativeTypeName("HRESULT (IDxcPixType **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcPixType**, int> UnAlias;
+
+        [NativeTypeName("HRESULT (DWORD *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint*, int> GetNumElements;
+
+        [NativeTypeName("HRESULT (IDxcPixType **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcPixType**, int> GetIndexedType;
+
+        [NativeTypeName("HRESULT (IDxcPixType **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcPixType**, int> GetElementType;
+    }
+}

src/ThridParty/Ghost.DXC/Generated/IDxcPixCompilationInfo.cs

@@ -0,0 +1,156 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using static Ghost.DXC.Api;
+
+namespace Ghost.DXC;
+
+/// <include file='IDxcPixCompilationInfo.xml' path='doc/member[@name="IDxcPixCompilationInfo"]/*' />
+[Guid("61B16C95-8799-4ED8-BDB0-3B6C08A141B4")]
+[NativeTypeName("struct IDxcPixCompilationInfo : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcPixCompilationInfo : IDxcPixCompilationInfo.Interface, INativeGuid
+{
+    static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(in IID_IDxcPixCompilationInfo);
+
+    public void** lpVtbl;
+
+    /// <inheritdoc cref="IUnknown.QueryInterface" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(0)]
+    [return: NativeTypeName("HRESULT")]
+    public int QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixCompilationInfo*, Guid*, void**, int>)(lpVtbl[0]))((IDxcPixCompilationInfo*)Unsafe.AsPointer(ref this), riid, ppvObject);
+    }
+
+    /// <inheritdoc cref="IUnknown.AddRef" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(1)]
+    [return: NativeTypeName("ULONG")]
+    public uint AddRef()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixCompilationInfo*, uint>)(lpVtbl[1]))((IDxcPixCompilationInfo*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IUnknown.Release" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(2)]
+    [return: NativeTypeName("ULONG")]
+    public uint Release()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixCompilationInfo*, uint>)(lpVtbl[2]))((IDxcPixCompilationInfo*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <include file='IDxcPixCompilationInfo.xml' path='doc/member[@name="IDxcPixCompilationInfo.GetSourceFile"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(3)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetSourceFile([NativeTypeName("DWORD")] uint SourceFileOrdinal, [NativeTypeName("BSTR *")] char** pSourceName, [NativeTypeName("BSTR *")] char** pSourceContents)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixCompilationInfo*, uint, char**, char**, int>)(lpVtbl[3]))((IDxcPixCompilationInfo*)Unsafe.AsPointer(ref this), SourceFileOrdinal, pSourceName, pSourceContents);
+    }
+
+    /// <include file='IDxcPixCompilationInfo.xml' path='doc/member[@name="IDxcPixCompilationInfo.GetArguments"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(4)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetArguments([NativeTypeName("BSTR *")] char** pArguments)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixCompilationInfo*, char**, int>)(lpVtbl[4]))((IDxcPixCompilationInfo*)Unsafe.AsPointer(ref this), pArguments);
+    }
+
+    /// <include file='IDxcPixCompilationInfo.xml' path='doc/member[@name="IDxcPixCompilationInfo.GetMacroDefinitions"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(5)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetMacroDefinitions([NativeTypeName("BSTR *")] char** pMacroDefinitions)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixCompilationInfo*, char**, int>)(lpVtbl[5]))((IDxcPixCompilationInfo*)Unsafe.AsPointer(ref this), pMacroDefinitions);
+    }
+
+    /// <include file='IDxcPixCompilationInfo.xml' path='doc/member[@name="IDxcPixCompilationInfo.GetEntryPointFile"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(6)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetEntryPointFile([NativeTypeName("BSTR *")] char** pEntryPointFile)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixCompilationInfo*, char**, int>)(lpVtbl[6]))((IDxcPixCompilationInfo*)Unsafe.AsPointer(ref this), pEntryPointFile);
+    }
+
+    /// <include file='IDxcPixCompilationInfo.xml' path='doc/member[@name="IDxcPixCompilationInfo.GetHlslTarget"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(7)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetHlslTarget([NativeTypeName("BSTR *")] char** pHlslTarget)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixCompilationInfo*, char**, int>)(lpVtbl[7]))((IDxcPixCompilationInfo*)Unsafe.AsPointer(ref this), pHlslTarget);
+    }
+
+    /// <include file='IDxcPixCompilationInfo.xml' path='doc/member[@name="IDxcPixCompilationInfo.GetEntryPoint"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(8)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetEntryPoint([NativeTypeName("BSTR *")] char** pEntryPoint)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixCompilationInfo*, char**, int>)(lpVtbl[8]))((IDxcPixCompilationInfo*)Unsafe.AsPointer(ref this), pEntryPoint);
+    }
+
+    public interface Interface : IUnknown.Interface
+    {
+        [VtblIndex(3)]
+        [return: NativeTypeName("HRESULT")]
+        int GetSourceFile([NativeTypeName("DWORD")] uint SourceFileOrdinal, [NativeTypeName("BSTR *")] char** pSourceName, [NativeTypeName("BSTR *")] char** pSourceContents);
+
+        [VtblIndex(4)]
+        [return: NativeTypeName("HRESULT")]
+        int GetArguments([NativeTypeName("BSTR *")] char** pArguments);
+
+        [VtblIndex(5)]
+        [return: NativeTypeName("HRESULT")]
+        int GetMacroDefinitions([NativeTypeName("BSTR *")] char** pMacroDefinitions);
+
+        [VtblIndex(6)]
+        [return: NativeTypeName("HRESULT")]
+        int GetEntryPointFile([NativeTypeName("BSTR *")] char** pEntryPointFile);
+
+        [VtblIndex(7)]
+        [return: NativeTypeName("HRESULT")]
+        int GetHlslTarget([NativeTypeName("BSTR *")] char** pHlslTarget);
+
+        [VtblIndex(8)]
+        [return: NativeTypeName("HRESULT")]
+        int GetEntryPoint([NativeTypeName("BSTR *")] char** pEntryPoint);
+    }
+
+    public partial struct Vtbl<TSelf>
+        where TSelf : unmanaged, Interface
+    {
+        [NativeTypeName("HRESULT (const IID &, void **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, Guid*, void**, int> QueryInterface;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> AddRef;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> Release;
+
+        [NativeTypeName("HRESULT (DWORD, BSTR *, BSTR *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint, char**, char**, int> GetSourceFile;
+
+        [NativeTypeName("HRESULT (BSTR *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, char**, int> GetArguments;
+
+        [NativeTypeName("HRESULT (BSTR *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, char**, int> GetMacroDefinitions;
+
+        [NativeTypeName("HRESULT (BSTR *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, char**, int> GetEntryPointFile;
+
+        [NativeTypeName("HRESULT (BSTR *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, char**, int> GetHlslTarget;
+
+        [NativeTypeName("HRESULT (BSTR *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, char**, int> GetEntryPoint;
+    }
+}

src/ThridParty/Ghost.DXC/Generated/IDxcPixConstType.cs

@@ -0,0 +1,97 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using static Ghost.DXC.Api;
+
+namespace Ghost.DXC;
+
+/// <include file='IDxcPixConstType.xml' path='doc/member[@name="IDxcPixConstType"]/*' />
+[Guid("D9DF2C8B-2773-466D-9BC2-D848D8496BF6")]
+[NativeTypeName("struct IDxcPixConstType : IDxcPixType")]
+[NativeInheritance("IDxcPixType")]
+public unsafe partial struct IDxcPixConstType : IDxcPixConstType.Interface, INativeGuid
+{
+    static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(in IID_IDxcPixConstType);
+
+    public void** lpVtbl;
+
+    /// <inheritdoc cref="IUnknown.QueryInterface" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(0)]
+    [return: NativeTypeName("HRESULT")]
+    public int QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixConstType*, Guid*, void**, int>)(lpVtbl[0]))((IDxcPixConstType*)Unsafe.AsPointer(ref this), riid, ppvObject);
+    }
+
+    /// <inheritdoc cref="IUnknown.AddRef" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(1)]
+    [return: NativeTypeName("ULONG")]
+    public uint AddRef()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixConstType*, uint>)(lpVtbl[1]))((IDxcPixConstType*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IUnknown.Release" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(2)]
+    [return: NativeTypeName("ULONG")]
+    public uint Release()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixConstType*, uint>)(lpVtbl[2]))((IDxcPixConstType*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IDxcPixType.GetName" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(3)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetName([NativeTypeName("BSTR *")] char** Name)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixConstType*, char**, int>)(lpVtbl[3]))((IDxcPixConstType*)Unsafe.AsPointer(ref this), Name);
+    }
+
+    /// <inheritdoc cref="IDxcPixType.GetSizeInBits" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(4)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetSizeInBits([NativeTypeName("DWORD *")] uint* GetSizeInBits)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixConstType*, uint*, int>)(lpVtbl[4]))((IDxcPixConstType*)Unsafe.AsPointer(ref this), GetSizeInBits);
+    }
+
+    /// <inheritdoc cref="IDxcPixType.UnAlias" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(5)]
+    [return: NativeTypeName("HRESULT")]
+    public int UnAlias(IDxcPixType** ppBaseType)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixConstType*, IDxcPixType**, int>)(lpVtbl[5]))((IDxcPixConstType*)Unsafe.AsPointer(ref this), ppBaseType);
+    }
+
+    public interface Interface : IDxcPixType.Interface
+    {
+    }
+
+    public partial struct Vtbl<TSelf>
+        where TSelf : unmanaged, Interface
+    {
+        [NativeTypeName("HRESULT (const IID &, void **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, Guid*, void**, int> QueryInterface;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> AddRef;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> Release;
+
+        [NativeTypeName("HRESULT (BSTR *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, char**, int> GetName;
+
+        [NativeTypeName("HRESULT (DWORD *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint*, int> GetSizeInBits;
+
+        [NativeTypeName("HRESULT (IDxcPixType **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcPixType**, int> UnAlias;
+    }
+}

src/ThridParty/Ghost.DXC/Generated/IDxcPixDxilDebugInfo.cs

@@ -0,0 +1,156 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using static Ghost.DXC.Api;
+
+namespace Ghost.DXC;
+
+/// <include file='IDxcPixDxilDebugInfo.xml' path='doc/member[@name="IDxcPixDxilDebugInfo"]/*' />
+[Guid("B875638E-108A-4D90-A53A-68D63773CB38")]
+[NativeTypeName("struct IDxcPixDxilDebugInfo : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcPixDxilDebugInfo : IDxcPixDxilDebugInfo.Interface, INativeGuid
+{
+    static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(in IID_IDxcPixDxilDebugInfo);
+
+    public void** lpVtbl;
+
+    /// <inheritdoc cref="IUnknown.QueryInterface" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(0)]
+    [return: NativeTypeName("HRESULT")]
+    public int QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixDxilDebugInfo*, Guid*, void**, int>)(lpVtbl[0]))((IDxcPixDxilDebugInfo*)Unsafe.AsPointer(ref this), riid, ppvObject);
+    }
+
+    /// <inheritdoc cref="IUnknown.AddRef" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(1)]
+    [return: NativeTypeName("ULONG")]
+    public uint AddRef()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixDxilDebugInfo*, uint>)(lpVtbl[1]))((IDxcPixDxilDebugInfo*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IUnknown.Release" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(2)]
+    [return: NativeTypeName("ULONG")]
+    public uint Release()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixDxilDebugInfo*, uint>)(lpVtbl[2]))((IDxcPixDxilDebugInfo*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <include file='IDxcPixDxilDebugInfo.xml' path='doc/member[@name="IDxcPixDxilDebugInfo.GetLiveVariablesAt"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(3)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetLiveVariablesAt([NativeTypeName("DWORD")] uint InstructionOffset, IDxcPixDxilLiveVariables** ppLiveVariables)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixDxilDebugInfo*, uint, IDxcPixDxilLiveVariables**, int>)(lpVtbl[3]))((IDxcPixDxilDebugInfo*)Unsafe.AsPointer(ref this), InstructionOffset, ppLiveVariables);
+    }
+
+    /// <include file='IDxcPixDxilDebugInfo.xml' path='doc/member[@name="IDxcPixDxilDebugInfo.IsVariableInRegister"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(4)]
+    [return: NativeTypeName("HRESULT")]
+    public int IsVariableInRegister([NativeTypeName("DWORD")] uint InstructionOffset, [NativeTypeName("const wchar_t *")] char* VariableName)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixDxilDebugInfo*, uint, char*, int>)(lpVtbl[4]))((IDxcPixDxilDebugInfo*)Unsafe.AsPointer(ref this), InstructionOffset, VariableName);
+    }
+
+    /// <include file='IDxcPixDxilDebugInfo.xml' path='doc/member[@name="IDxcPixDxilDebugInfo.GetFunctionName"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(5)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetFunctionName([NativeTypeName("DWORD")] uint InstructionOffset, [NativeTypeName("BSTR *")] char** ppFunctionName)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixDxilDebugInfo*, uint, char**, int>)(lpVtbl[5]))((IDxcPixDxilDebugInfo*)Unsafe.AsPointer(ref this), InstructionOffset, ppFunctionName);
+    }
+
+    /// <include file='IDxcPixDxilDebugInfo.xml' path='doc/member[@name="IDxcPixDxilDebugInfo.GetStackDepth"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(6)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetStackDepth([NativeTypeName("DWORD")] uint InstructionOffset, [NativeTypeName("DWORD *")] uint* StackDepth)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixDxilDebugInfo*, uint, uint*, int>)(lpVtbl[6]))((IDxcPixDxilDebugInfo*)Unsafe.AsPointer(ref this), InstructionOffset, StackDepth);
+    }
+
+    /// <include file='IDxcPixDxilDebugInfo.xml' path='doc/member[@name="IDxcPixDxilDebugInfo.InstructionOffsetsFromSourceLocation"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(7)]
+    [return: NativeTypeName("HRESULT")]
+    public int InstructionOffsetsFromSourceLocation([NativeTypeName("const wchar_t *")] char* FileName, [NativeTypeName("DWORD")] uint SourceLine, [NativeTypeName("DWORD")] uint SourceColumn, IDxcPixDxilInstructionOffsets** ppOffsets)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixDxilDebugInfo*, char*, uint, uint, IDxcPixDxilInstructionOffsets**, int>)(lpVtbl[7]))((IDxcPixDxilDebugInfo*)Unsafe.AsPointer(ref this), FileName, SourceLine, SourceColumn, ppOffsets);
+    }
+
+    /// <include file='IDxcPixDxilDebugInfo.xml' path='doc/member[@name="IDxcPixDxilDebugInfo.SourceLocationsFromInstructionOffset"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(8)]
+    [return: NativeTypeName("HRESULT")]
+    public int SourceLocationsFromInstructionOffset([NativeTypeName("DWORD")] uint InstructionOffset, IDxcPixDxilSourceLocations** ppSourceLocations)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixDxilDebugInfo*, uint, IDxcPixDxilSourceLocations**, int>)(lpVtbl[8]))((IDxcPixDxilDebugInfo*)Unsafe.AsPointer(ref this), InstructionOffset, ppSourceLocations);
+    }
+
+    public interface Interface : IUnknown.Interface
+    {
+        [VtblIndex(3)]
+        [return: NativeTypeName("HRESULT")]
+        int GetLiveVariablesAt([NativeTypeName("DWORD")] uint InstructionOffset, IDxcPixDxilLiveVariables** ppLiveVariables);
+
+        [VtblIndex(4)]
+        [return: NativeTypeName("HRESULT")]
+        int IsVariableInRegister([NativeTypeName("DWORD")] uint InstructionOffset, [NativeTypeName("const wchar_t *")] char* VariableName);
+
+        [VtblIndex(5)]
+        [return: NativeTypeName("HRESULT")]
+        int GetFunctionName([NativeTypeName("DWORD")] uint InstructionOffset, [NativeTypeName("BSTR *")] char** ppFunctionName);
+
+        [VtblIndex(6)]
+        [return: NativeTypeName("HRESULT")]
+        int GetStackDepth([NativeTypeName("DWORD")] uint InstructionOffset, [NativeTypeName("DWORD *")] uint* StackDepth);
+
+        [VtblIndex(7)]
+        [return: NativeTypeName("HRESULT")]
+        int InstructionOffsetsFromSourceLocation([NativeTypeName("const wchar_t *")] char* FileName, [NativeTypeName("DWORD")] uint SourceLine, [NativeTypeName("DWORD")] uint SourceColumn, IDxcPixDxilInstructionOffsets** ppOffsets);
+
+        [VtblIndex(8)]
+        [return: NativeTypeName("HRESULT")]
+        int SourceLocationsFromInstructionOffset([NativeTypeName("DWORD")] uint InstructionOffset, IDxcPixDxilSourceLocations** ppSourceLocations);
+    }
+
+    public partial struct Vtbl<TSelf>
+        where TSelf : unmanaged, Interface
+    {
+        [NativeTypeName("HRESULT (const IID &, void **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, Guid*, void**, int> QueryInterface;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> AddRef;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> Release;
+
+        [NativeTypeName("HRESULT (DWORD, IDxcPixDxilLiveVariables **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint, IDxcPixDxilLiveVariables**, int> GetLiveVariablesAt;
+
+        [NativeTypeName("HRESULT (DWORD, const wchar_t *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint, char*, int> IsVariableInRegister;
+
+        [NativeTypeName("HRESULT (DWORD, BSTR *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint, char**, int> GetFunctionName;
+
+        [NativeTypeName("HRESULT (DWORD, DWORD *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint, uint*, int> GetStackDepth;
+
+        [NativeTypeName("HRESULT (const wchar_t *, DWORD, DWORD, IDxcPixDxilInstructionOffsets **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, char*, uint, uint, IDxcPixDxilInstructionOffsets**, int> InstructionOffsetsFromSourceLocation;
+
+        [NativeTypeName("HRESULT (DWORD, IDxcPixDxilSourceLocations **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint, IDxcPixDxilSourceLocations**, int> SourceLocationsFromInstructionOffset;
+    }
+}

src/ThridParty/Ghost.DXC/Generated/IDxcPixDxilDebugInfoFactory.cs

@@ -0,0 +1,92 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using static Ghost.DXC.Api;
+
+namespace Ghost.DXC;
+
+/// <include file='IDxcPixDxilDebugInfoFactory.xml' path='doc/member[@name="IDxcPixDxilDebugInfoFactory"]/*' />
+[Guid("9C2A040D-8068-44EC-8C68-8BFEF1B43789")]
+[NativeTypeName("struct IDxcPixDxilDebugInfoFactory : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcPixDxilDebugInfoFactory : IDxcPixDxilDebugInfoFactory.Interface, INativeGuid
+{
+    static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(in IID_IDxcPixDxilDebugInfoFactory);
+
+    public void** lpVtbl;
+
+    /// <inheritdoc cref="IUnknown.QueryInterface" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(0)]
+    [return: NativeTypeName("HRESULT")]
+    public int QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixDxilDebugInfoFactory*, Guid*, void**, int>)(lpVtbl[0]))((IDxcPixDxilDebugInfoFactory*)Unsafe.AsPointer(ref this), riid, ppvObject);
+    }
+
+    /// <inheritdoc cref="IUnknown.AddRef" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(1)]
+    [return: NativeTypeName("ULONG")]
+    public uint AddRef()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixDxilDebugInfoFactory*, uint>)(lpVtbl[1]))((IDxcPixDxilDebugInfoFactory*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IUnknown.Release" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(2)]
+    [return: NativeTypeName("ULONG")]
+    public uint Release()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixDxilDebugInfoFactory*, uint>)(lpVtbl[2]))((IDxcPixDxilDebugInfoFactory*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <include file='IDxcPixDxilDebugInfoFactory.xml' path='doc/member[@name="IDxcPixDxilDebugInfoFactory.NewDxcPixDxilDebugInfo"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(3)]
+    [return: NativeTypeName("HRESULT")]
+    public int NewDxcPixDxilDebugInfo(IDxcPixDxilDebugInfo** ppDxilDebugInfo)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixDxilDebugInfoFactory*, IDxcPixDxilDebugInfo**, int>)(lpVtbl[3]))((IDxcPixDxilDebugInfoFactory*)Unsafe.AsPointer(ref this), ppDxilDebugInfo);
+    }
+
+    /// <include file='IDxcPixDxilDebugInfoFactory.xml' path='doc/member[@name="IDxcPixDxilDebugInfoFactory.NewDxcPixCompilationInfo"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(4)]
+    [return: NativeTypeName("HRESULT")]
+    public int NewDxcPixCompilationInfo(IDxcPixCompilationInfo** ppCompilationInfo)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixDxilDebugInfoFactory*, IDxcPixCompilationInfo**, int>)(lpVtbl[4]))((IDxcPixDxilDebugInfoFactory*)Unsafe.AsPointer(ref this), ppCompilationInfo);
+    }
+
+    public interface Interface : IUnknown.Interface
+    {
+        [VtblIndex(3)]
+        [return: NativeTypeName("HRESULT")]
+        int NewDxcPixDxilDebugInfo(IDxcPixDxilDebugInfo** ppDxilDebugInfo);
+
+        [VtblIndex(4)]
+        [return: NativeTypeName("HRESULT")]
+        int NewDxcPixCompilationInfo(IDxcPixCompilationInfo** ppCompilationInfo);
+    }
+
+    public partial struct Vtbl<TSelf>
+        where TSelf : unmanaged, Interface
+    {
+        [NativeTypeName("HRESULT (const IID &, void **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, Guid*, void**, int> QueryInterface;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> AddRef;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> Release;
+
+        [NativeTypeName("HRESULT (IDxcPixDxilDebugInfo **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcPixDxilDebugInfo**, int> NewDxcPixDxilDebugInfo;
+
+        [NativeTypeName("HRESULT (IDxcPixCompilationInfo **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcPixCompilationInfo**, int> NewDxcPixCompilationInfo;
+    }
+}

src/ThridParty/Ghost.DXC/Generated/IDxcPixDxilInstructionOffsets.cs

@@ -0,0 +1,92 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using static Ghost.DXC.Api;
+
+namespace Ghost.DXC;
+
+/// <include file='IDxcPixDxilInstructionOffsets.xml' path='doc/member[@name="IDxcPixDxilInstructionOffsets"]/*' />
+[Guid("EB71F85E-8542-44B5-87DA-9D76045A1910")]
+[NativeTypeName("struct IDxcPixDxilInstructionOffsets : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcPixDxilInstructionOffsets : IDxcPixDxilInstructionOffsets.Interface, INativeGuid
+{
+    static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(in IID_IDxcPixDxilInstructionOffsets);
+
+    public void** lpVtbl;
+
+    /// <inheritdoc cref="IUnknown.QueryInterface" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(0)]
+    [return: NativeTypeName("HRESULT")]
+    public int QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixDxilInstructionOffsets*, Guid*, void**, int>)(lpVtbl[0]))((IDxcPixDxilInstructionOffsets*)Unsafe.AsPointer(ref this), riid, ppvObject);
+    }
+
+    /// <inheritdoc cref="IUnknown.AddRef" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(1)]
+    [return: NativeTypeName("ULONG")]
+    public uint AddRef()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixDxilInstructionOffsets*, uint>)(lpVtbl[1]))((IDxcPixDxilInstructionOffsets*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IUnknown.Release" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(2)]
+    [return: NativeTypeName("ULONG")]
+    public uint Release()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixDxilInstructionOffsets*, uint>)(lpVtbl[2]))((IDxcPixDxilInstructionOffsets*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <include file='IDxcPixDxilInstructionOffsets.xml' path='doc/member[@name="IDxcPixDxilInstructionOffsets.GetCount"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(3)]
+    [return: NativeTypeName("DWORD")]
+    public uint GetCount()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixDxilInstructionOffsets*, uint>)(lpVtbl[3]))((IDxcPixDxilInstructionOffsets*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <include file='IDxcPixDxilInstructionOffsets.xml' path='doc/member[@name="IDxcPixDxilInstructionOffsets.GetOffsetByIndex"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(4)]
+    [return: NativeTypeName("DWORD")]
+    public uint GetOffsetByIndex([NativeTypeName("DWORD")] uint Index)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixDxilInstructionOffsets*, uint, uint>)(lpVtbl[4]))((IDxcPixDxilInstructionOffsets*)Unsafe.AsPointer(ref this), Index);
+    }
+
+    public interface Interface : IUnknown.Interface
+    {
+        [VtblIndex(3)]
+        [return: NativeTypeName("DWORD")]
+        uint GetCount();
+
+        [VtblIndex(4)]
+        [return: NativeTypeName("DWORD")]
+        uint GetOffsetByIndex([NativeTypeName("DWORD")] uint Index);
+    }
+
+    public partial struct Vtbl<TSelf>
+        where TSelf : unmanaged, Interface
+    {
+        [NativeTypeName("HRESULT (const IID &, void **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, Guid*, void**, int> QueryInterface;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> AddRef;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> Release;
+
+        [NativeTypeName("DWORD () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> GetCount;
+
+        [NativeTypeName("DWORD (DWORD) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint, uint> GetOffsetByIndex;
+    }
+}

src/ThridParty/Ghost.DXC/Generated/IDxcPixDxilLiveVariables.cs

@@ -0,0 +1,108 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using static Ghost.DXC.Api;
+
+namespace Ghost.DXC;
+
+/// <include file='IDxcPixDxilLiveVariables.xml' path='doc/member[@name="IDxcPixDxilLiveVariables"]/*' />
+[Guid("C59D302F-34A2-4FE5-9646-32CE7A52D03F")]
+[NativeTypeName("struct IDxcPixDxilLiveVariables : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcPixDxilLiveVariables : IDxcPixDxilLiveVariables.Interface, INativeGuid
+{
+    static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(in IID_IDxcPixDxilLiveVariables);
+
+    public void** lpVtbl;
+
+    /// <inheritdoc cref="IUnknown.QueryInterface" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(0)]
+    [return: NativeTypeName("HRESULT")]
+    public int QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixDxilLiveVariables*, Guid*, void**, int>)(lpVtbl[0]))((IDxcPixDxilLiveVariables*)Unsafe.AsPointer(ref this), riid, ppvObject);
+    }
+
+    /// <inheritdoc cref="IUnknown.AddRef" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(1)]
+    [return: NativeTypeName("ULONG")]
+    public uint AddRef()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixDxilLiveVariables*, uint>)(lpVtbl[1]))((IDxcPixDxilLiveVariables*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IUnknown.Release" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(2)]
+    [return: NativeTypeName("ULONG")]
+    public uint Release()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixDxilLiveVariables*, uint>)(lpVtbl[2]))((IDxcPixDxilLiveVariables*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <include file='IDxcPixDxilLiveVariables.xml' path='doc/member[@name="IDxcPixDxilLiveVariables.GetCount"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(3)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetCount([NativeTypeName("DWORD *")] uint* dwSize)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixDxilLiveVariables*, uint*, int>)(lpVtbl[3]))((IDxcPixDxilLiveVariables*)Unsafe.AsPointer(ref this), dwSize);
+    }
+
+    /// <include file='IDxcPixDxilLiveVariables.xml' path='doc/member[@name="IDxcPixDxilLiveVariables.GetVariableByIndex"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(4)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetVariableByIndex([NativeTypeName("DWORD")] uint Index, IDxcPixVariable** ppVariable)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixDxilLiveVariables*, uint, IDxcPixVariable**, int>)(lpVtbl[4]))((IDxcPixDxilLiveVariables*)Unsafe.AsPointer(ref this), Index, ppVariable);
+    }
+
+    /// <include file='IDxcPixDxilLiveVariables.xml' path='doc/member[@name="IDxcPixDxilLiveVariables.GetVariableByName"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(5)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetVariableByName([NativeTypeName("LPCWSTR")] char* Name, IDxcPixVariable** ppVariable)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixDxilLiveVariables*, char*, IDxcPixVariable**, int>)(lpVtbl[5]))((IDxcPixDxilLiveVariables*)Unsafe.AsPointer(ref this), Name, ppVariable);
+    }
+
+    public interface Interface : IUnknown.Interface
+    {
+        [VtblIndex(3)]
+        [return: NativeTypeName("HRESULT")]
+        int GetCount([NativeTypeName("DWORD *")] uint* dwSize);
+
+        [VtblIndex(4)]
+        [return: NativeTypeName("HRESULT")]
+        int GetVariableByIndex([NativeTypeName("DWORD")] uint Index, IDxcPixVariable** ppVariable);
+
+        [VtblIndex(5)]
+        [return: NativeTypeName("HRESULT")]
+        int GetVariableByName([NativeTypeName("LPCWSTR")] char* Name, IDxcPixVariable** ppVariable);
+    }
+
+    public partial struct Vtbl<TSelf>
+        where TSelf : unmanaged, Interface
+    {
+        [NativeTypeName("HRESULT (const IID &, void **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, Guid*, void**, int> QueryInterface;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> AddRef;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> Release;
+
+        [NativeTypeName("HRESULT (DWORD *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint*, int> GetCount;
+
+        [NativeTypeName("HRESULT (DWORD, IDxcPixVariable **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint, IDxcPixVariable**, int> GetVariableByIndex;
+
+        [NativeTypeName("HRESULT (LPCWSTR, IDxcPixVariable **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, char*, IDxcPixVariable**, int> GetVariableByName;
+    }
+}

src/ThridParty/Ghost.DXC/Generated/IDxcPixDxilSourceLocations.cs

@@ -0,0 +1,124 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using static Ghost.DXC.Api;
+
+namespace Ghost.DXC;
+
+/// <include file='IDxcPixDxilSourceLocations.xml' path='doc/member[@name="IDxcPixDxilSourceLocations"]/*' />
+[Guid("761C833D-E7B8-4624-80F8-3A3FB4146342")]
+[NativeTypeName("struct IDxcPixDxilSourceLocations : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcPixDxilSourceLocations : IDxcPixDxilSourceLocations.Interface, INativeGuid
+{
+    static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(in IID_IDxcPixDxilSourceLocations);
+
+    public void** lpVtbl;
+
+    /// <inheritdoc cref="IUnknown.QueryInterface" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(0)]
+    [return: NativeTypeName("HRESULT")]
+    public int QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixDxilSourceLocations*, Guid*, void**, int>)(lpVtbl[0]))((IDxcPixDxilSourceLocations*)Unsafe.AsPointer(ref this), riid, ppvObject);
+    }
+
+    /// <inheritdoc cref="IUnknown.AddRef" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(1)]
+    [return: NativeTypeName("ULONG")]
+    public uint AddRef()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixDxilSourceLocations*, uint>)(lpVtbl[1]))((IDxcPixDxilSourceLocations*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IUnknown.Release" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(2)]
+    [return: NativeTypeName("ULONG")]
+    public uint Release()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixDxilSourceLocations*, uint>)(lpVtbl[2]))((IDxcPixDxilSourceLocations*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <include file='IDxcPixDxilSourceLocations.xml' path='doc/member[@name="IDxcPixDxilSourceLocations.GetCount"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(3)]
+    [return: NativeTypeName("DWORD")]
+    public uint GetCount()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixDxilSourceLocations*, uint>)(lpVtbl[3]))((IDxcPixDxilSourceLocations*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <include file='IDxcPixDxilSourceLocations.xml' path='doc/member[@name="IDxcPixDxilSourceLocations.GetLineNumberByIndex"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(4)]
+    [return: NativeTypeName("DWORD")]
+    public uint GetLineNumberByIndex([NativeTypeName("DWORD")] uint Index)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixDxilSourceLocations*, uint, uint>)(lpVtbl[4]))((IDxcPixDxilSourceLocations*)Unsafe.AsPointer(ref this), Index);
+    }
+
+    /// <include file='IDxcPixDxilSourceLocations.xml' path='doc/member[@name="IDxcPixDxilSourceLocations.GetColumnByIndex"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(5)]
+    [return: NativeTypeName("DWORD")]
+    public uint GetColumnByIndex([NativeTypeName("DWORD")] uint Index)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixDxilSourceLocations*, uint, uint>)(lpVtbl[5]))((IDxcPixDxilSourceLocations*)Unsafe.AsPointer(ref this), Index);
+    }
+
+    /// <include file='IDxcPixDxilSourceLocations.xml' path='doc/member[@name="IDxcPixDxilSourceLocations.GetFileNameByIndex"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(6)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetFileNameByIndex([NativeTypeName("DWORD")] uint Index, [NativeTypeName("BSTR *")] char** Name)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixDxilSourceLocations*, uint, char**, int>)(lpVtbl[6]))((IDxcPixDxilSourceLocations*)Unsafe.AsPointer(ref this), Index, Name);
+    }
+
+    public interface Interface : IUnknown.Interface
+    {
+        [VtblIndex(3)]
+        [return: NativeTypeName("DWORD")]
+        uint GetCount();
+
+        [VtblIndex(4)]
+        [return: NativeTypeName("DWORD")]
+        uint GetLineNumberByIndex([NativeTypeName("DWORD")] uint Index);
+
+        [VtblIndex(5)]
+        [return: NativeTypeName("DWORD")]
+        uint GetColumnByIndex([NativeTypeName("DWORD")] uint Index);
+
+        [VtblIndex(6)]
+        [return: NativeTypeName("HRESULT")]
+        int GetFileNameByIndex([NativeTypeName("DWORD")] uint Index, [NativeTypeName("BSTR *")] char** Name);
+    }
+
+    public partial struct Vtbl<TSelf>
+        where TSelf : unmanaged, Interface
+    {
+        [NativeTypeName("HRESULT (const IID &, void **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, Guid*, void**, int> QueryInterface;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> AddRef;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> Release;
+
+        [NativeTypeName("DWORD () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> GetCount;
+
+        [NativeTypeName("DWORD (DWORD) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint, uint> GetLineNumberByIndex;
+
+        [NativeTypeName("DWORD (DWORD) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint, uint> GetColumnByIndex;
+
+        [NativeTypeName("HRESULT (DWORD, BSTR *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint, char**, int> GetFileNameByIndex;
+    }
+}

src/ThridParty/Ghost.DXC/Generated/IDxcPixDxilStorage.cs

@@ -0,0 +1,140 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using static Ghost.DXC.Api;
+
+namespace Ghost.DXC;
+
+/// <include file='IDxcPixDxilStorage.xml' path='doc/member[@name="IDxcPixDxilStorage"]/*' />
+[Guid("74D522F5-16C4-40CB-867B-4B4149E3DB0E")]
+[NativeTypeName("struct IDxcPixDxilStorage : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcPixDxilStorage : IDxcPixDxilStorage.Interface, INativeGuid
+{
+    static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(in IID_IDxcPixDxilStorage);
+
+    public void** lpVtbl;
+
+    /// <inheritdoc cref="IUnknown.QueryInterface" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(0)]
+    [return: NativeTypeName("HRESULT")]
+    public int QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixDxilStorage*, Guid*, void**, int>)(lpVtbl[0]))((IDxcPixDxilStorage*)Unsafe.AsPointer(ref this), riid, ppvObject);
+    }
+
+    /// <inheritdoc cref="IUnknown.AddRef" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(1)]
+    [return: NativeTypeName("ULONG")]
+    public uint AddRef()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixDxilStorage*, uint>)(lpVtbl[1]))((IDxcPixDxilStorage*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IUnknown.Release" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(2)]
+    [return: NativeTypeName("ULONG")]
+    public uint Release()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixDxilStorage*, uint>)(lpVtbl[2]))((IDxcPixDxilStorage*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <include file='IDxcPixDxilStorage.xml' path='doc/member[@name="IDxcPixDxilStorage.AccessField"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(3)]
+    [return: NativeTypeName("HRESULT")]
+    public int AccessField([NativeTypeName("LPCWSTR")] char* Name, IDxcPixDxilStorage** ppResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixDxilStorage*, char*, IDxcPixDxilStorage**, int>)(lpVtbl[3]))((IDxcPixDxilStorage*)Unsafe.AsPointer(ref this), Name, ppResult);
+    }
+
+    /// <include file='IDxcPixDxilStorage.xml' path='doc/member[@name="IDxcPixDxilStorage.Index"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(4)]
+    [return: NativeTypeName("HRESULT")]
+    public int Index([NativeTypeName("DWORD")] uint Index, IDxcPixDxilStorage** ppResult)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixDxilStorage*, uint, IDxcPixDxilStorage**, int>)(lpVtbl[4]))((IDxcPixDxilStorage*)Unsafe.AsPointer(ref this), Index, ppResult);
+    }
+
+    /// <include file='IDxcPixDxilStorage.xml' path='doc/member[@name="IDxcPixDxilStorage.GetRegisterNumber"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(5)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetRegisterNumber([NativeTypeName("DWORD *")] uint* pRegNum)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixDxilStorage*, uint*, int>)(lpVtbl[5]))((IDxcPixDxilStorage*)Unsafe.AsPointer(ref this), pRegNum);
+    }
+
+    /// <include file='IDxcPixDxilStorage.xml' path='doc/member[@name="IDxcPixDxilStorage.GetIsAlive"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(6)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetIsAlive()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixDxilStorage*, int>)(lpVtbl[6]))((IDxcPixDxilStorage*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <include file='IDxcPixDxilStorage.xml' path='doc/member[@name="IDxcPixDxilStorage.GetType"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(7)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetType(IDxcPixType** ppType)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixDxilStorage*, IDxcPixType**, int>)(lpVtbl[7]))((IDxcPixDxilStorage*)Unsafe.AsPointer(ref this), ppType);
+    }
+
+    public interface Interface : IUnknown.Interface
+    {
+        [VtblIndex(3)]
+        [return: NativeTypeName("HRESULT")]
+        int AccessField([NativeTypeName("LPCWSTR")] char* Name, IDxcPixDxilStorage** ppResult);
+
+        [VtblIndex(4)]
+        [return: NativeTypeName("HRESULT")]
+        int Index([NativeTypeName("DWORD")] uint Index, IDxcPixDxilStorage** ppResult);
+
+        [VtblIndex(5)]
+        [return: NativeTypeName("HRESULT")]
+        int GetRegisterNumber([NativeTypeName("DWORD *")] uint* pRegNum);
+
+        [VtblIndex(6)]
+        [return: NativeTypeName("HRESULT")]
+        int GetIsAlive();
+
+        [VtblIndex(7)]
+        [return: NativeTypeName("HRESULT")]
+        int GetType(IDxcPixType** ppType);
+    }
+
+    public partial struct Vtbl<TSelf>
+        where TSelf : unmanaged, Interface
+    {
+        [NativeTypeName("HRESULT (const IID &, void **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, Guid*, void**, int> QueryInterface;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> AddRef;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> Release;
+
+        [NativeTypeName("HRESULT (LPCWSTR, IDxcPixDxilStorage **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, char*, IDxcPixDxilStorage**, int> AccessField;
+
+        [NativeTypeName("HRESULT (DWORD, IDxcPixDxilStorage **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint, IDxcPixDxilStorage**, int> Index;
+
+        [NativeTypeName("HRESULT (DWORD *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint*, int> GetRegisterNumber;
+
+        [NativeTypeName("HRESULT () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, int> GetIsAlive;
+
+        [NativeTypeName("HRESULT (IDxcPixType **) __attribute__((stdcall))")]
+        public new delegate* unmanaged[MemberFunction]<TSelf*, IDxcPixType**, int> GetType;
+    }
+}

src/ThridParty/Ghost.DXC/Generated/IDxcPixScalarType.cs

@@ -0,0 +1,97 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using static Ghost.DXC.Api;
+
+namespace Ghost.DXC;
+
+/// <include file='IDxcPixScalarType.xml' path='doc/member[@name="IDxcPixScalarType"]/*' />
+[Guid("246E1652-ED2A-4FFC-A949-43BF63750EE5")]
+[NativeTypeName("struct IDxcPixScalarType : IDxcPixType")]
+[NativeInheritance("IDxcPixType")]
+public unsafe partial struct IDxcPixScalarType : IDxcPixScalarType.Interface, INativeGuid
+{
+    static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(in IID_IDxcPixScalarType);
+
+    public void** lpVtbl;
+
+    /// <inheritdoc cref="IUnknown.QueryInterface" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(0)]
+    [return: NativeTypeName("HRESULT")]
+    public int QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixScalarType*, Guid*, void**, int>)(lpVtbl[0]))((IDxcPixScalarType*)Unsafe.AsPointer(ref this), riid, ppvObject);
+    }
+
+    /// <inheritdoc cref="IUnknown.AddRef" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(1)]
+    [return: NativeTypeName("ULONG")]
+    public uint AddRef()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixScalarType*, uint>)(lpVtbl[1]))((IDxcPixScalarType*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IUnknown.Release" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(2)]
+    [return: NativeTypeName("ULONG")]
+    public uint Release()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixScalarType*, uint>)(lpVtbl[2]))((IDxcPixScalarType*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IDxcPixType.GetName" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(3)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetName([NativeTypeName("BSTR *")] char** Name)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixScalarType*, char**, int>)(lpVtbl[3]))((IDxcPixScalarType*)Unsafe.AsPointer(ref this), Name);
+    }
+
+    /// <inheritdoc cref="IDxcPixType.GetSizeInBits" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(4)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetSizeInBits([NativeTypeName("DWORD *")] uint* GetSizeInBits)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixScalarType*, uint*, int>)(lpVtbl[4]))((IDxcPixScalarType*)Unsafe.AsPointer(ref this), GetSizeInBits);
+    }
+
+    /// <inheritdoc cref="IDxcPixType.UnAlias" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(5)]
+    [return: NativeTypeName("HRESULT")]
+    public int UnAlias(IDxcPixType** ppBaseType)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixScalarType*, IDxcPixType**, int>)(lpVtbl[5]))((IDxcPixScalarType*)Unsafe.AsPointer(ref this), ppBaseType);
+    }
+
+    public interface Interface : IDxcPixType.Interface
+    {
+    }
+
+    public partial struct Vtbl<TSelf>
+        where TSelf : unmanaged, Interface
+    {
+        [NativeTypeName("HRESULT (const IID &, void **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, Guid*, void**, int> QueryInterface;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> AddRef;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> Release;
+
+        [NativeTypeName("HRESULT (BSTR *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, char**, int> GetName;
+
+        [NativeTypeName("HRESULT (DWORD *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint*, int> GetSizeInBits;
+
+        [NativeTypeName("HRESULT (IDxcPixType **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, IDxcPixType**, int> UnAlias;
+    }
+}

src/ThridParty/Ghost.DXC/Generated/IDxcPixStructField.cs

@@ -0,0 +1,124 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using static Ghost.DXC.Api;
+
+namespace Ghost.DXC;
+
+/// <include file='IDxcPixStructField.xml' path='doc/member[@name="IDxcPixStructField"]/*' />
+[Guid("DE45597C-5869-4F97-A77B-D6650B9A16CF")]
+[NativeTypeName("struct IDxcPixStructField : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcPixStructField : IDxcPixStructField.Interface, INativeGuid
+{
+    static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(in IID_IDxcPixStructField);
+
+    public void** lpVtbl;
+
+    /// <inheritdoc cref="IUnknown.QueryInterface" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(0)]
+    [return: NativeTypeName("HRESULT")]
+    public int QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixStructField*, Guid*, void**, int>)(lpVtbl[0]))((IDxcPixStructField*)Unsafe.AsPointer(ref this), riid, ppvObject);
+    }
+
+    /// <inheritdoc cref="IUnknown.AddRef" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(1)]
+    [return: NativeTypeName("ULONG")]
+    public uint AddRef()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixStructField*, uint>)(lpVtbl[1]))((IDxcPixStructField*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IUnknown.Release" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(2)]
+    [return: NativeTypeName("ULONG")]
+    public uint Release()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixStructField*, uint>)(lpVtbl[2]))((IDxcPixStructField*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <include file='IDxcPixStructField.xml' path='doc/member[@name="IDxcPixStructField.GetName"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(3)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetName([NativeTypeName("BSTR *")] char** Name)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixStructField*, char**, int>)(lpVtbl[3]))((IDxcPixStructField*)Unsafe.AsPointer(ref this), Name);
+    }
+
+    /// <include file='IDxcPixStructField.xml' path='doc/member[@name="IDxcPixStructField.GetType"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(4)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetType(IDxcPixType** ppType)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixStructField*, IDxcPixType**, int>)(lpVtbl[4]))((IDxcPixStructField*)Unsafe.AsPointer(ref this), ppType);
+    }
+
+    /// <include file='IDxcPixStructField.xml' path='doc/member[@name="IDxcPixStructField.GetOffsetInBits"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(5)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetOffsetInBits([NativeTypeName("DWORD *")] uint* pOffsetInBits)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixStructField*, uint*, int>)(lpVtbl[5]))((IDxcPixStructField*)Unsafe.AsPointer(ref this), pOffsetInBits);
+    }
+
+    /// <include file='IDxcPixStructField.xml' path='doc/member[@name="IDxcPixStructField.GetFieldSizeInBits"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(6)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetFieldSizeInBits([NativeTypeName("DWORD *")] uint* pFieldSizeInBits)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixStructField*, uint*, int>)(lpVtbl[6]))((IDxcPixStructField*)Unsafe.AsPointer(ref this), pFieldSizeInBits);
+    }
+
+    public interface Interface : IUnknown.Interface
+    {
+        [VtblIndex(3)]
+        [return: NativeTypeName("HRESULT")]
+        int GetName([NativeTypeName("BSTR *")] char** Name);
+
+        [VtblIndex(4)]
+        [return: NativeTypeName("HRESULT")]
+        int GetType(IDxcPixType** ppType);
+
+        [VtblIndex(5)]
+        [return: NativeTypeName("HRESULT")]
+        int GetOffsetInBits([NativeTypeName("DWORD *")] uint* pOffsetInBits);
+
+        [VtblIndex(6)]
+        [return: NativeTypeName("HRESULT")]
+        int GetFieldSizeInBits([NativeTypeName("DWORD *")] uint* pFieldSizeInBits);
+    }
+
+    public partial struct Vtbl<TSelf>
+        where TSelf : unmanaged, Interface
+    {
+        [NativeTypeName("HRESULT (const IID &, void **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, Guid*, void**, int> QueryInterface;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> AddRef;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> Release;
+
+        [NativeTypeName("HRESULT (BSTR *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, char**, int> GetName;
+
+        [NativeTypeName("HRESULT (IDxcPixType **) __attribute__((stdcall))")]
+        public new delegate* unmanaged[MemberFunction]<TSelf*, IDxcPixType**, int> GetType;
+
+        [NativeTypeName("HRESULT (DWORD *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint*, int> GetOffsetInBits;
+
+        [NativeTypeName("HRESULT (DWORD *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint*, int> GetFieldSizeInBits;
+    }
+}

src/ThridParty/Ghost.DXC/Generated/IDxcPixStructField0.cs

@@ -0,0 +1,108 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using static Ghost.DXC.Api;
+
+namespace Ghost.DXC;
+
+/// <include file='IDxcPixStructField0.xml' path='doc/member[@name="IDxcPixStructField0"]/*' />
+[Guid("6C707D08-7995-4A84-BAE5-E6D8291F3B78")]
+[NativeTypeName("struct IDxcPixStructField0 : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IDxcPixStructField0 : IDxcPixStructField0.Interface, INativeGuid
+{
+    static Guid* INativeGuid.NativeGuid => (Guid*)Unsafe.AsPointer(in IID_IDxcPixStructField0);
+
+    public void** lpVtbl;
+
+    /// <inheritdoc cref="IUnknown.QueryInterface" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(0)]
+    [return: NativeTypeName("HRESULT")]
+    public int QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixStructField0*, Guid*, void**, int>)(lpVtbl[0]))((IDxcPixStructField0*)Unsafe.AsPointer(ref this), riid, ppvObject);
+    }
+
+    /// <inheritdoc cref="IUnknown.AddRef" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(1)]
+    [return: NativeTypeName("ULONG")]
+    public uint AddRef()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixStructField0*, uint>)(lpVtbl[1]))((IDxcPixStructField0*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IUnknown.Release" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(2)]
+    [return: NativeTypeName("ULONG")]
+    public uint Release()
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixStructField0*, uint>)(lpVtbl[2]))((IDxcPixStructField0*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <include file='IDxcPixStructField0.xml' path='doc/member[@name="IDxcPixStructField0.GetName"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(3)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetName([NativeTypeName("BSTR *")] char** Name)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixStructField0*, char**, int>)(lpVtbl[3]))((IDxcPixStructField0*)Unsafe.AsPointer(ref this), Name);
+    }
+
+    /// <include file='IDxcPixStructField0.xml' path='doc/member[@name="IDxcPixStructField0.GetType"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(4)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetType(IDxcPixType** ppType)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixStructField0*, IDxcPixType**, int>)(lpVtbl[4]))((IDxcPixStructField0*)Unsafe.AsPointer(ref this), ppType);
+    }
+
+    /// <include file='IDxcPixStructField0.xml' path='doc/member[@name="IDxcPixStructField0.GetOffsetInBits"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(5)]
+    [return: NativeTypeName("HRESULT")]
+    public int GetOffsetInBits([NativeTypeName("DWORD *")] uint* pOffsetInBits)
+    {
+        return ((delegate* unmanaged[MemberFunction]<IDxcPixStructField0*, uint*, int>)(lpVtbl[5]))((IDxcPixStructField0*)Unsafe.AsPointer(ref this), pOffsetInBits);
+    }
+
+    public interface Interface : IUnknown.Interface
+    {
+        [VtblIndex(3)]
+        [return: NativeTypeName("HRESULT")]
+        int GetName([NativeTypeName("BSTR *")] char** Name);
+
+        [VtblIndex(4)]
+        [return: NativeTypeName("HRESULT")]
+        int GetType(IDxcPixType** ppType);
+
+        [VtblIndex(5)]
+        [return: NativeTypeName("HRESULT")]
+        int GetOffsetInBits([NativeTypeName("DWORD *")] uint* pOffsetInBits);
+    }
+
+    public partial struct Vtbl<TSelf>
+        where TSelf : unmanaged, Interface
+    {
+        [NativeTypeName("HRESULT (const IID &, void **) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, Guid*, void**, int> QueryInterface;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> AddRef;
+
+        [NativeTypeName("ULONG () __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint> Release;
+
+        [NativeTypeName("HRESULT (BSTR *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, char**, int> GetName;
+
+        [NativeTypeName("HRESULT (IDxcPixType **) __attribute__((stdcall))")]
+        public new delegate* unmanaged[MemberFunction]<TSelf*, IDxcPixType**, int> GetType;
+
+        [NativeTypeName("HRESULT (DWORD *) __attribute__((stdcall))")]
+        public delegate* unmanaged[MemberFunction]<TSelf*, uint*, int> GetOffsetInBits;
+    }
+}