Initial WIC support (WIP)

src/Generator/Program.cs

@@ -21,7 +21,7 @@ public static class Program
         "Graphics.Direct3D12.json",
         "Graphics.Direct3D.Dxc.json",
         "Graphics.Direct2D.Common.json",
-        //"Graphics.Imaging.json",
+        "Graphics.Imaging.json",
         //"Graphics.DirectWrite.json",
     };
 
@@ -68,6 +68,11 @@ public static class Program
         { "System.Com.ISequentialStream", "Com.ISequentialStream" },
         { "System.Com.IStream", "Com.IStream" },
         { "System.Com.IMalloc", "Com.IMalloc" },
+        { "System.Com.IEnumUnknown", "Com.IEnumUnknown" },
+        { "System.Com.IEnumString", "Com.IEnumString" },
+        { "System.Com.StructuredStorage.PROPVARIANT", "Com.Variant" },
+        { "System.Com.StructuredStorage.PROPBAG2", "Com.PropertyBagMetadata" },
+        { "System.Com.StructuredStorage.IPropertyBag2", "Com.IPropertyBag2" },
 
         { "Graphics.Gdi.HMONITOR", "IntPtr" },
         { "Graphics.Gdi.HDC", "IntPtr" },
@@ -599,6 +604,10 @@ public static class Program
         "InvalidNumRenderTargets",
         "SetRenderTargets",
         "CreateSharedResource",
+        "ExifColorSpace",
+        "NoCache",
+        "CacheOnDemand",
+        "CacheOnLoad",
     };
 
     private static readonly HashSet<string> s_preserveCaps = new(StringComparer.OrdinalIgnoreCase)
@@ -677,6 +686,11 @@ public static class Program
 
         // Dxc
         { "DXC_OUT_KIND", "DXC_OUT" },
+
+        // WIC
+        { "WICColorContextType", "WICColorContext" },
+        { "WICBitmapCreateCacheOption", "WICBitmap" },
+        { "WICDecodeOptions", "WICDecodeMetadata" },
     };
 
     private static readonly Dictionary<string, string> s_knownEnumValueNames = new()
@@ -817,6 +831,9 @@ public static class Program
         { "IDxcValidator2::ValidateWithDebug::Flags", "DxcValidatorFlags" },
         { "IDxcVersionInfo::GetFlags::pFlags", "DxcVersionInfoFlags" },
         { "IDxcVersionInfo2::GetFlags::pFlags", "DxcVersionInfoFlags" },
+
+        // WIC
+        { "IWICImagingFactory::CreateDecoderFromFilename::dwDesiredAccess", "NativeFileAccess" },
     };
 
     private static readonly HashSet<string> s_visitedEnums = new();
@@ -851,6 +868,7 @@ public static class Program
         }
 
         // Generate docs
+        //DocGenerator.Generate(new[] { "WIC" }, Path.Combine(outputPath, "Imaging.xml"));
         //DocGenerator.Generate(new[] { "DWRITE" }, Path.Combine(outputPath, "DirectWrite.xml"));
         //DocGenerator.Generate(new[] { "D3D" }, Path.Combine(outputPath, "Direct3D.xml"));
         //DocGenerator.Generate(new[] { "DXGI" }, Path.Combine(outputPath, "Dxgi.xml"));
@@ -1119,6 +1137,15 @@ public static class Program
                 continue;
             }
 
+            // PROPVARIANT
+            //if (comType.Name == "IWICEnumMetadataItem" ||
+            //    comType.Name == "IWICMetadataReader" ||
+            //    comType.Name == "IWICMetadataBlockReader" ||
+            //    comType.Name == "IWICMetadataBlockWriter")
+            //{
+            //    continue;
+            //}
+
             if (!regionWritten)
             {
                 writer.WriteLine("#region COM Types");
@@ -1259,9 +1286,25 @@ public static class Program
 
     private static void GenerateEnum(CodeWriter writer, ApiType enumType, bool autoGenerated)
     {
-        string csTypeName = GetDataTypeName(enumType.Name, out string enumPrefix);
+        string csTypeName;
-        string baseTypeName = GetTypeName(enumType.IntegerBase);
+        string enumPrefix = string.Empty;
+
+        if (enumType.Name.StartsWith("WIC"))
+        {
+            csTypeName = enumType.Name;
+
+            if (s_knownTypesPrefixes.TryGetValue(enumType.Name, out string? knowPrefix))
+            {
+                enumPrefix = knowPrefix!;
+            }
+        }
+        else
+        {
+            csTypeName = GetDataTypeName(enumType.Name, out enumPrefix);
             AddCsMapping(writer.Api, enumType.Name, csTypeName);
+        }
+
+        string baseTypeName = GetTypeName(enumType.IntegerBase);
 
         if (!autoGenerated)
         {
@@ -1300,6 +1343,11 @@ public static class Program
             baseTypeName = "byte";
         }
 
+        if (enumType.Name == "WICColorContextType")
+        {
+
+        }
+
         using (writer.PushBlock($"public enum {csTypeName} : {baseTypeName}"))
         {
             if (isFlags &&
@@ -1360,6 +1408,11 @@ public static class Program
 
     private static string GetEnumItemName(ApiType enumType, ApiEnumValue enumItem, string enumPrefix)
     {
+        if (string.IsNullOrEmpty(enumPrefix))
+        {
+            return enumItem.Name;
+        }
+
         string enumValueName = GetPrettyFieldName(enumItem.Name, enumPrefix);
 
         // D3D11 has some enum name "issues"
@@ -1635,7 +1688,6 @@ public static class Program
         List<KeyValuePair<ApiFunction, string>> methodsToGenerate)
     {
         string csTypeName = comType.Name;
-        //AddCsMapping(writer.Api, comType.Name, csTypeName);
 
         writer.WriteLine($"/// <include file='../{writer.DocFileName}.xml' path='doc/member[@name=\"{comType.Name}\"]/*' />");
 
@@ -1719,8 +1771,14 @@ public static class Program
                 vtblIndex = 3;
             }
 
+            bool needNewLine = false;
             foreach (KeyValuePair<ApiFunction, string> methodPair in methodsToGenerate)
             {
+                if (needNewLine)
+                {
+                    writer.WriteLine();
+                }
+
                 ApiFunction method = methodPair.Key;
                 string docName = methodPair.Value;
 
@@ -1738,7 +1796,7 @@ public static class Program
                     string parameterType = string.Empty;
 
 
-                    if (method.Name == "Compile" && parameter.Name == "pArguments")
+                    if (method.Name == "GetFrame" && parameter.Name == "ppIBitmapFrame")
                     {
                     }
 
@@ -1787,6 +1845,13 @@ public static class Program
                             parameterType += "*";
                         }
                     }
+                    else if (parameter.Attrs.Any(item => item is string str && str == "RetVal"))
+                    {
+                        if (!IsPrimitive(parameter.Type))
+                        {
+                            parameterType += "*";
+                        }
+                    }
 
                     parameterName = CleanupName(parameterName);
 
@@ -1858,8 +1923,8 @@ public static class Program
                         writer.Write("return ");
                     writer.WriteLine($"((delegate* unmanaged[Stdcall]<{comType.Name}*, {argumentTypesString}>)(lpVtbl[{vtblIndex}]))(({comType.Name}*)Unsafe.AsPointer(ref this){argumentNamesString});");
                 }
-                writer.WriteLine();
 
+                needNewLine = true;
                 vtblIndex++;
             }
         }

src/Vortice.Win32/Com/IEnumString.cs

@@ -0,0 +1,94 @@
+// Copyright © Amer Koleci and Contributors.
+// Licensed under the MIT License (MIT). See LICENSE in the repository root for more information.
+
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+
+namespace Win32.Com;
+
+[Guid("00000101-0000-0000-C000-000000000046")]
+[NativeTypeName("struct IEnumString : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IEnumString
+{
+    public static ref readonly Guid IID_IEnumString
+    {
+        get
+        {
+            ReadOnlySpan<byte> data = new byte[] {
+                0x01, 0x01, 0x00, 0x00,
+                0x00, 0x00,
+                0x00, 0x00,
+                0xC0,
+                0x00,
+                0x00,
+                0x00,
+                0x00,
+                0x00,
+                0x00,
+                0x46
+            };
+
+            Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+            return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+        }
+    }
+
+    public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IEnumString));
+
+    public void** lpVtbl;
+
+    /// <inheritdoc cref="IUnknown.QueryInterface" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(0)]
+    public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+    {
+        return ((delegate* unmanaged[Stdcall]<ISequentialStream*, Guid*, void**, int>)(lpVtbl[0]))((ISequentialStream*)Unsafe.AsPointer(ref this), riid, ppvObject);
+    }
+
+    /// <inheritdoc cref="IUnknown.AddRef" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(1)]
+    [return: NativeTypeName("ULONG")]
+    public uint AddRef()
+    {
+        return ((delegate* unmanaged[Stdcall]<ISequentialStream*, uint>)(lpVtbl[1]))((ISequentialStream*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IUnknown.Release" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(2)]
+    [return: NativeTypeName("ULONG")]
+    public uint Release()
+    {
+        return ((delegate* unmanaged[Stdcall]<ISequentialStream*, uint>)(lpVtbl[2]))((ISequentialStream*)Unsafe.AsPointer(ref this));
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(3)]
+    public HResult Next([NativeTypeName("ULONG")] uint celt, [NativeTypeName("LPOLESTR *")] ushort** rgelt, [NativeTypeName("ULONG *")] uint* pceltFetched)
+    {
+        return ((delegate* unmanaged[Stdcall]<IEnumString*, uint, ushort**, uint*, int>)(lpVtbl[3]))((IEnumString*)Unsafe.AsPointer(ref this), celt, rgelt, pceltFetched);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(4)]
+    public HResult Skip([NativeTypeName("ULONG")] uint celt)
+    {
+        return ((delegate* unmanaged[Stdcall]<IEnumString*, uint, int>)(lpVtbl[4]))((IEnumString*)Unsafe.AsPointer(ref this), celt);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(5)]
+    public HResult Reset()
+    {
+        return ((delegate* unmanaged[Stdcall]<IEnumString*, int>)(lpVtbl[5]))((IEnumString*)Unsafe.AsPointer(ref this));
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(6)]
+    public HResult Clone(IEnumString** ppenum)
+    {
+        return ((delegate* unmanaged[Stdcall]<IEnumString*, IEnumString**, int>)(lpVtbl[6]))((IEnumString*)Unsafe.AsPointer(ref this), ppenum);
+    }
+}

src/Vortice.Win32/Com/IEnumUnknown.cs

@@ -0,0 +1,95 @@
+// Copyright © Amer Koleci and Contributors.
+// Licensed under the MIT License (MIT). See LICENSE in the repository root for more information.
+
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+
+namespace Win32.Com;
+
+[Guid("00000100-0000-0000-C000-000000000046")]
+[NativeTypeName("struct IEnumUnknown : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IEnumUnknown
+{
+    public static ref readonly Guid IID_IEnumUnknown
+    {
+        get
+        {
+            ReadOnlySpan<byte> data = new byte[] {
+                0x00, 0x01, 0x00, 0x00,
+                0x00, 0x00,
+                0x00, 0x00,
+                0xC0,
+                0x00,
+                0x00,
+                0x00,
+                0x00,
+                0x00,
+                0x00,
+                0x46
+            };
+
+            Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+            return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+        }
+    }
+
+
+    public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IEnumUnknown));
+
+    public void** lpVtbl;
+
+    /// <inheritdoc cref="IUnknown.QueryInterface" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(0)]
+    public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+    {
+        return ((delegate* unmanaged[Stdcall]<ISequentialStream*, Guid*, void**, int>)(lpVtbl[0]))((ISequentialStream*)Unsafe.AsPointer(ref this), riid, ppvObject);
+    }
+
+    /// <inheritdoc cref="IUnknown.AddRef" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(1)]
+    [return: NativeTypeName("ULONG")]
+    public uint AddRef()
+    {
+        return ((delegate* unmanaged[Stdcall]<ISequentialStream*, uint>)(lpVtbl[1]))((ISequentialStream*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IUnknown.Release" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(2)]
+    [return: NativeTypeName("ULONG")]
+    public uint Release()
+    {
+        return ((delegate* unmanaged[Stdcall]<ISequentialStream*, uint>)(lpVtbl[2]))((ISequentialStream*)Unsafe.AsPointer(ref this));
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(3)]
+    public HResult Next([NativeTypeName("ULONG")] uint celt, IUnknown** rgelt, [NativeTypeName("ULONG *")] uint* pceltFetched)
+    {
+        return ((delegate* unmanaged[Stdcall]<IEnumUnknown*, uint, IUnknown**, uint*, int>)(lpVtbl[3]))((IEnumUnknown*)Unsafe.AsPointer(ref this), celt, rgelt, pceltFetched);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(4)]
+    public HResult Skip([NativeTypeName("ULONG")] uint celt)
+    {
+        return ((delegate* unmanaged[Stdcall]<IEnumUnknown*, uint, int>)(lpVtbl[4]))((IEnumUnknown*)Unsafe.AsPointer(ref this), celt);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(5)]
+    public HResult Reset()
+    {
+        return ((delegate* unmanaged[Stdcall]<IEnumUnknown*, int>)(lpVtbl[5]))((IEnumUnknown*)Unsafe.AsPointer(ref this));
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(6)]
+    public HResult Clone(IEnumUnknown** ppenum)
+    {
+        return ((delegate* unmanaged[Stdcall]<IEnumUnknown*, IEnumUnknown**, int>)(lpVtbl[6]))((IEnumUnknown*)Unsafe.AsPointer(ref this), ppenum);
+    }
+}

src/Vortice.Win32/Com/IErrorLog.cs

@@ -0,0 +1,74 @@
+// Copyright © Amer Koleci and Contributors.
+// Licensed under the MIT License (MIT). See LICENSE in the repository root for more information.
+
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices.ComTypes;
+
+namespace Win32.Com;
+
+[Guid("3127CA40-446E-11CE-8135-00AA004BB851")]
+[NativeTypeName("struct IErrorLog : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IErrorLog
+{
+    public static ref readonly Guid IID_IErrorLog
+    {
+        get
+        {
+            ReadOnlySpan<byte> data = new byte[] {
+                0x40, 0xCA, 0x27, 0x31,
+                0x6E, 0x44,
+                0xCE, 0x11,
+                0x81,
+                0x35,
+                0x00,
+                0xAA,
+                0x00,
+                0x4B,
+                0xB8,
+                0x51
+            };
+
+            Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+            return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+        }
+    }
+
+    public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IErrorLog));
+
+    public void** lpVtbl;
+
+    /// <inheritdoc cref="IUnknown.QueryInterface" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(0)]
+    public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+    {
+        return ((delegate* unmanaged[Stdcall]<ISequentialStream*, Guid*, void**, int>)(lpVtbl[0]))((ISequentialStream*)Unsafe.AsPointer(ref this), riid, ppvObject);
+    }
+
+    /// <inheritdoc cref="IUnknown.AddRef" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(1)]
+    [return: NativeTypeName("ULONG")]
+    public uint AddRef()
+    {
+        return ((delegate* unmanaged[Stdcall]<ISequentialStream*, uint>)(lpVtbl[1]))((ISequentialStream*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IUnknown.Release" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(2)]
+    [return: NativeTypeName("ULONG")]
+    public uint Release()
+    {
+        return ((delegate* unmanaged[Stdcall]<ISequentialStream*, uint>)(lpVtbl[2]))((ISequentialStream*)Unsafe.AsPointer(ref this));
+    }
+
+    //[MethodImpl(MethodImplOptions.AggressiveInlining)]
+    //[VtblIndex(3)]
+    //public HResult AddError([NativeTypeName("LPCOLESTR")] ushort* pszPropName, EXCEPINFO* pExcepInfo)
+    //{
+    //    return ((delegate* unmanaged[Stdcall]<IErrorLog*, ushort*, EXCEPINFO*, int>)(lpVtbl[3]))((IErrorLog*)Unsafe.AsPointer(ref this), pszPropName, pExcepInfo);
+    //}
+}

src/Vortice.Win32/Com/IMalloc.cs

@@ -78,7 +78,6 @@ public unsafe partial struct IMalloc
         return ((delegate* unmanaged[Stdcall]<IMalloc*, void*, nuint, void*>)(lpVtbl[4]))((IMalloc*)Unsafe.AsPointer(ref this), pv, cb);
     }
 
-    /// <include file='IMalloc.xml' path='doc/member[@name="IMalloc.Free"]/*' />
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     [VtblIndex(5)]
     public void Free(void* pv)

src/Vortice.Win32/Com/IPropertyBag2.cs

@@ -0,0 +1,100 @@
+// Copyright © Amer Koleci and Contributors.
+// Licensed under the MIT License (MIT). See LICENSE in the repository root for more information.
+
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+
+namespace Win32.Com;
+
+[Guid("22F55882-280B-11D0-A8A9-00A0C90C2004")]
+[NativeTypeName("struct IPropertyBag2 : IUnknown")]
+[NativeInheritance("IUnknown")]
+public unsafe partial struct IPropertyBag2
+{
+    public static ref readonly Guid IID_IPropertyBag2
+    {
+        get
+        {
+            ReadOnlySpan<byte> data = new byte[] {
+                0x82, 0x58, 0xF5, 0x22,
+                0x0B, 0x28,
+                0xD0, 0x11,
+                0xA8,
+                0xA9,
+                0x00,
+                0xA0,
+                0xC9,
+                0x0C,
+                0x20,
+                0x04
+            };
+
+            Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
+            return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
+        }
+    }
+    public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IPropertyBag2));
+
+    public void** lpVtbl;
+
+    /// <inheritdoc cref="IUnknown.QueryInterface" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(0)]
+    public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject)
+    {
+        return ((delegate* unmanaged[Stdcall]<ISequentialStream*, Guid*, void**, int>)(lpVtbl[0]))((ISequentialStream*)Unsafe.AsPointer(ref this), riid, ppvObject);
+    }
+
+    /// <inheritdoc cref="IUnknown.AddRef" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(1)]
+    [return: NativeTypeName("ULONG")]
+    public uint AddRef()
+    {
+        return ((delegate* unmanaged[Stdcall]<ISequentialStream*, uint>)(lpVtbl[1]))((ISequentialStream*)Unsafe.AsPointer(ref this));
+    }
+
+    /// <inheritdoc cref="IUnknown.Release" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(2)]
+    [return: NativeTypeName("ULONG")]
+    public uint Release()
+    {
+        return ((delegate* unmanaged[Stdcall]<ISequentialStream*, uint>)(lpVtbl[2]))((ISequentialStream*)Unsafe.AsPointer(ref this));
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(3)]
+    public HResult Read(uint cProperties, PropertyBagMetadata* pPropBag, IErrorLog* pErrLog, Variant* pvarValue, HResult* phrError)
+    {
+        return ((delegate* unmanaged[Stdcall]<IPropertyBag2*, uint, PropertyBagMetadata*, IErrorLog*, Variant*, HResult*, int>)(lpVtbl[3]))((IPropertyBag2*)Unsafe.AsPointer(ref this), cProperties, pPropBag, pErrLog, pvarValue, phrError);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(4)]
+    public HResult Write([NativeTypeName("ULONG")] uint cProperties, PropertyBagMetadata* pPropBag, Variant* pvarValue)
+    {
+        return ((delegate* unmanaged[Stdcall]<IPropertyBag2*, uint, PropertyBagMetadata*, Variant*, int>)(lpVtbl[4]))((IPropertyBag2*)Unsafe.AsPointer(ref this), cProperties, pPropBag, pvarValue);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(5)]
+    public HResult CountProperties(uint* pcProperties)
+    {
+        return ((delegate* unmanaged[Stdcall]<IPropertyBag2*, uint*, int>)(lpVtbl[5]))((IPropertyBag2*)Unsafe.AsPointer(ref this), pcProperties);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(6)]
+    public HResult GetPropertyInfo(uint iProperty, uint cProperties, PropertyBagMetadata* pPropBag, uint* pcProperties)
+    {
+        return ((delegate* unmanaged[Stdcall]<IPropertyBag2*, uint, uint, PropertyBagMetadata*, uint*, int>)(lpVtbl[6]))((IPropertyBag2*)Unsafe.AsPointer(ref this), iProperty, cProperties, pPropBag, pcProperties);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(7)]
+    public HResult LoadObject(ushort* pstrName, uint dwHint, IUnknown* pUnkObject, IErrorLog* pErrLog)
+    {
+        return ((delegate* unmanaged[Stdcall]<IPropertyBag2*, ushort*, uint, IUnknown*, IErrorLog*, int>)(lpVtbl[7]))((IPropertyBag2*)Unsafe.AsPointer(ref this), pstrName, dwHint, pUnkObject, pErrLog);
+    }
+}

src/Vortice.Win32/Com/IStream.cs

@@ -115,21 +115,19 @@ public unsafe partial struct IStream
         return ((delegate* unmanaged[Stdcall]<IStream*, int>)(lpVtbl[9]))((IStream*)Unsafe.AsPointer(ref this));
     }
 
-    ///// <include file='IStream.xml' path='doc/member[@name="IStream.LockRegion"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    //[MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(10)]
-    //[VtblIndex(10)]
+    public HResult LockRegion(ULargeInterger libOffset, ULargeInterger cb, [NativeTypeName("DWORD")] uint dwLockType)
-    //public HRESULT LockRegion(ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, [NativeTypeName("DWORD")] uint dwLockType)
+    {
-    //{
+        return ((delegate* unmanaged[Stdcall]<IStream*, ULargeInterger, ULargeInterger, uint, int>)(lpVtbl[10]))((IStream*)Unsafe.AsPointer(ref this), libOffset, cb, dwLockType);
-    //    return ((delegate* unmanaged[Stdcall]<IStream*, ULARGE_INTEGER, ULARGE_INTEGER, uint, int>)(lpVtbl[10]))((IStream*)Unsafe.AsPointer(ref this), libOffset, cb, dwLockType);
+    }
-    //}
 
-    ///// <include file='IStream.xml' path='doc/member[@name="IStream.UnlockRegion"]/*' />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    //[MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [VtblIndex(11)]
-    //[VtblIndex(11)]
+    public HResult UnlockRegion(ULargeInterger libOffset, ULargeInterger cb, [NativeTypeName("DWORD")] uint dwLockType)
-    //public HRESULT UnlockRegion(ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, [NativeTypeName("DWORD")] uint dwLockType)
+    {
-    //{
+        return ((delegate* unmanaged[Stdcall]<IStream*, ULargeInterger, ULargeInterger, uint, int>)(lpVtbl[11]))((IStream*)Unsafe.AsPointer(ref this), libOffset, cb, dwLockType);
-    //    return ((delegate* unmanaged[Stdcall]<IStream*, ULARGE_INTEGER, ULARGE_INTEGER, uint, int>)(lpVtbl[11]))((IStream*)Unsafe.AsPointer(ref this), libOffset, cb, dwLockType);
+    }
-    //}
 
     ///// <include file='IStream.xml' path='doc/member[@name="IStream.Stat"]/*' />
     //[MethodImpl(MethodImplOptions.AggressiveInlining)]

src/Vortice.Win32/Com/PropertyBagMetadata.cs

@@ -0,0 +1,34 @@
+// Copyright © Amer Koleci and Contributors.
+// Licensed under the MIT License (MIT). See LICENSE in the repository root for more information.
+
+using static Win32.StringUtilities;
+
+namespace Win32.Com;
+
+public enum PropertyBagMetadataType
+{
+    Undefined,
+    Data,
+    Url,
+    Object,
+    Stream,
+    Storage,
+    Moniker
+}
+
+/// <unmanaged>PROPBAG2</unmanaged>
+[NativeTypeName("struct PROPBAG2")]
+public unsafe partial struct PropertyBagMetadata
+{
+    public PropertyBagMetadataType Type;
+    public VariantFullType VariantType;
+    public ushort ClipboardFormat;
+    public uint Hint;
+    public ushort* pstrName;
+    public Guid ClassId;
+
+    public readonly string? GetName()
+    {
+        return GetString(pstrName);
+    }
+}

src/Vortice.Win32/Com/Variant.cs

@@ -0,0 +1,391 @@
+// Copyright © Amer Koleci and Contributors.
+// Licensed under the MIT License (MIT). See LICENSE in the repository root for more information.
+
+using System.Globalization;
+
+namespace Win32.Com;
+
+/// <summary>
+/// Variant COM.
+/// </summary>
+/// <unmanaged>PROPVARIANT</unmanaged>
+[NativeTypeName("struct PROPVARIANT")]
+public unsafe partial struct Variant
+{
+    private VariantFullType vt;
+    private ushort reserved1;
+    private ushort reserved2;
+    private ushort reserved3;
+    private VariantValue variantValue;
+
+    /// <summary>
+    /// Gets the type of the element.
+    /// </summary>
+    /// <value>
+    /// The type of the element.
+    /// </value>
+    public VariantElementType ElementType
+    {
+        get => vt.ElementType;
+        set => vt = new(value, vt.Type);
+    }
+
+    /// <summary>
+    /// Gets the type.
+    /// </summary>
+    public VariantType Type
+    {
+        get => vt.Type;
+        set => vt = new(vt.ElementType, value);
+    }
+
+#if TODO
+    /// <summary>
+    /// Gets or sets the value.
+    /// </summary>
+    /// <value>
+    /// The value.
+    /// </value>
+    public unsafe object Value
+    {
+        get
+        {
+            switch (Type)
+            {
+                case VariantType.Default:
+                    switch (ElementType)
+                    {
+                        case VariantElementType.Empty:
+                        case VariantElementType.Null:
+                            return null;
+                        case VariantElementType.Blob:
+                            {
+                                var buffer = new byte[(int)variantValue.recordValue.RecordInfo];
+                                if (buffer.Length > 0)
+                                {
+                                    MemoryHelpers.Read<byte>(variantValue.recordValue.RecordPointer, buffer,
+                                                             buffer.Length);
+                                }
+
+                                return buffer;
+                            }
+                        case VariantElementType.Bool:
+                            return variantValue.intValue != 0;
+                        case VariantElementType.Byte:
+                            return variantValue.signedByteValue;
+                        case VariantElementType.UByte:
+                            return variantValue.byteValue;
+                        case VariantElementType.UShort:
+                            return variantValue.ushortValue;
+                        case VariantElementType.Short:
+                            return variantValue.shortValue;
+                        case VariantElementType.UInt:
+                        case VariantElementType.UInt1:
+                            return variantValue.uintValue;
+                        case VariantElementType.Int:
+                        case VariantElementType.Int1:
+                            return variantValue.intValue;
+                        case VariantElementType.ULong:
+                            return variantValue.ulongValue;
+                        case VariantElementType.Long:
+                            return variantValue.longValue;
+                        case VariantElementType.Float:
+                            return variantValue.floatValue;
+                        case VariantElementType.Double:
+                            return variantValue.doubleValue;
+                        case VariantElementType.BinaryString:
+                            throw new NotSupportedException();
+                        case VariantElementType.StringPointer:
+                            return Marshal.PtrToStringAnsi(variantValue.pointerValue);
+                        case VariantElementType.WStringPointer:
+                            return Marshal.PtrToStringUni(variantValue.pointerValue);
+                        case VariantElementType.ComUnknown:
+                        case VariantElementType.Dispatch:
+                            return new ComObject(variantValue.pointerValue);
+                        case VariantElementType.IntPointer:
+                        case VariantElementType.Pointer:
+                            return variantValue.pointerValue;
+                        case VariantElementType.FileTime:
+                            return DateTime.FromFileTime(variantValue.longValue);
+                        default:
+                            return null;
+                    }
+                case VariantType.Vector:
+                    var size = (int)variantValue.recordValue.RecordInfo;
+                    var recordValuePointer = variantValue.recordValue.RecordPointer;
+                    switch (ElementType)
+                    {
+                        case VariantElementType.Bool:
+                            {
+                                Span<Bool32> span = stackalloc Bool32[size];
+                                MemoryHelpers.Read<Bool32>(recordValuePointer, span, size);
+                                return BooleanHelpers.ConvertToBoolArray(span);
+                            }
+                        case VariantElementType.Byte:
+                            {
+                                var array = new sbyte[size];
+                                MemoryHelpers.Read<sbyte>(recordValuePointer, array, size);
+                                return array;
+                            }
+                        case VariantElementType.UByte:
+                            {
+                                var array = new byte[size];
+                                MemoryHelpers.Read<byte>(recordValuePointer, array, size);
+                                return array;
+                            }
+                        case VariantElementType.UShort:
+                            {
+                                var array = new ushort[size];
+                                MemoryHelpers.Read<ushort>(recordValuePointer, array, size);
+                                return array;
+                            }
+                        case VariantElementType.Short:
+                            {
+                                var array = new short[size];
+                                MemoryHelpers.Read<short>(recordValuePointer, array, size);
+                                return array;
+                            }
+                        case VariantElementType.UInt:
+                        case VariantElementType.UInt1:
+                            {
+                                var array = new uint[size];
+                                MemoryHelpers.Read<uint>(recordValuePointer, array, size);
+                                return array;
+                            }
+                        case VariantElementType.Int:
+                        case VariantElementType.Int1:
+                            {
+                                var array = new int[size];
+                                MemoryHelpers.Read<int>(recordValuePointer, array, size);
+                                return array;
+                            }
+                        case VariantElementType.ULong:
+                            {
+                                var array = new ulong[size];
+                                MemoryHelpers.Read<ulong>(recordValuePointer, array, size);
+                                return array;
+                            }
+                        case VariantElementType.Long:
+                            {
+                                var array = new long[size];
+                                MemoryHelpers.Read<long>(recordValuePointer, array, size);
+                                return array;
+                            }
+                        case VariantElementType.Float:
+                            {
+                                var array = new float[size];
+                                MemoryHelpers.Read<float>(recordValuePointer, array, size);
+                                return array;
+                            }
+                        case VariantElementType.Double:
+                            {
+                                var array = new double[size];
+                                MemoryHelpers.Read<double>(recordValuePointer, array, size);
+                                return array;
+                            }
+                        case VariantElementType.BinaryString:
+                            {
+                                throw new NotSupportedException();
+                            }
+                        case VariantElementType.StringPointer:
+                            {
+                                var array = new string[size];
+                                for (var i = 0; i < size; i++)
+                                    array[i] = Marshal.PtrToStringAnsi(
+                                        ((IntPtr*)recordValuePointer)[i]
+                                    );
+                                return array;
+                            }
+                        case VariantElementType.WStringPointer:
+                            {
+                                var array = new string[size];
+                                for (var i = 0; i < size; i++)
+                                    array[i] = Marshal.PtrToStringUni(
+                                        ((IntPtr*)recordValuePointer)[i]
+                                    );
+                                return array;
+                            }
+                        case VariantElementType.ComUnknown:
+                        case VariantElementType.Dispatch:
+                            {
+                                var comArray = new ComObject[size];
+                                for (var i = 0; i < size; i++)
+                                    comArray[i] = new ComObject(((IntPtr*)recordValuePointer)[i]);
+                                return comArray;
+                            }
+                        case VariantElementType.IntPointer:
+                        case VariantElementType.Pointer:
+                            {
+                                var array = new IntPtr[size];
+                                MemoryHelpers.Read<IntPtr>(recordValuePointer, array, size);
+                                return array;
+                            }
+                        case VariantElementType.FileTime:
+                            {
+                                var fileTimeArray = new DateTime[size];
+                                for (var i = 0; i < size; i++)
+                                    fileTimeArray[i] =
+                                        DateTime.FromFileTime(((long*)recordValuePointer)[i]);
+                                return fileTimeArray;
+                            }
+                        default:
+                            return null;
+                    }
+            }
+
+            return null;
+        }
+        set
+        {
+            if (value == null)
+            {
+                Type = VariantType.Default;
+                ElementType = VariantElementType.Null;
+                return;
+            }
+
+            var type = value.GetType();
+
+            Type = VariantType.Default;
+            if (type.GetType().IsPrimitive)
+            {
+                if (type == typeof(byte))
+                {
+                    ElementType = VariantElementType.UByte;
+                    variantValue.byteValue = (byte)value;
+                    return;
+                }
+
+                if (type == typeof(sbyte))
+                {
+                    ElementType = VariantElementType.Byte;
+                    variantValue.signedByteValue = (sbyte)value;
+                    return;
+                }
+
+                if (type == typeof(int))
+                {
+                    ElementType = VariantElementType.Int;
+                    variantValue.intValue = (int)value;
+                    return;
+                }
+
+                if (type == typeof(uint))
+                {
+                    ElementType = VariantElementType.UInt;
+                    variantValue.uintValue = (uint)value;
+                    return;
+                }
+
+                if (type == typeof(long))
+                {
+                    ElementType = VariantElementType.Long;
+                    variantValue.longValue = (long)value;
+                    return;
+                }
+
+                if (type == typeof(ulong))
+                {
+                    ElementType = VariantElementType.ULong;
+                    variantValue.ulongValue = (ulong)value;
+                    return;
+                }
+
+                if (type == typeof(short))
+                {
+                    ElementType = VariantElementType.Short;
+                    variantValue.shortValue = (short)value;
+                    return;
+                }
+
+                if (type == typeof(ushort))
+                {
+                    ElementType = VariantElementType.UShort;
+                    variantValue.ushortValue = (ushort)value;
+                    return;
+                }
+
+                if (type == typeof(float))
+                {
+                    ElementType = VariantElementType.Float;
+                    variantValue.floatValue = (float)value;
+                    return;
+                }
+
+                if (type == typeof(double))
+                {
+                    ElementType = VariantElementType.Double;
+                    variantValue.doubleValue = (double)value;
+                    return;
+                }
+            }
+            else
+            {
+                switch (value)
+                {
+                    case ComObject obj:
+                        ElementType = VariantElementType.ComUnknown;
+                        variantValue.pointerValue = obj.NativePointer;
+                        return;
+                    case DateTime dateTime:
+                        ElementType = VariantElementType.FileTime;
+                        variantValue.longValue = dateTime.ToFileTime();
+                        return;
+                    case string str:
+                        ElementType = VariantElementType.WStringPointer;
+                        variantValue.pointerValue = Marshal.StringToCoTaskMemUni(str);
+                        return;
+                }
+            }
+
+            throw new ArgumentException(
+                string.Format(CultureInfo.InvariantCulture, "Type [{0}] is not handled", type.Name)
+            );
+        }
+    } 
+#endif
+
+    [StructLayout(LayoutKind.Explicit)]
+    private struct VariantValue
+    {
+        [FieldOffset(0)] public sbyte signedByteValue;
+        [FieldOffset(0)] public byte byteValue;
+        [FieldOffset(0)] public short shortValue;
+        [FieldOffset(0)] public ushort ushortValue;
+        [FieldOffset(0)] public int intValue;
+        [FieldOffset(0)] public uint uintValue;
+        [FieldOffset(0)] public long longValue;
+        [FieldOffset(0)] public ulong ulongValue;
+        [FieldOffset(0)] public LargeInterger largeIntergerValue;
+        [FieldOffset(0)] public ULargeInterger ulargeIntergerValue;
+        [FieldOffset(0)] public float floatValue;
+        [FieldOffset(0)] public double doubleValue;
+        [FieldOffset(0)] public short boolValue;
+        [FieldOffset(0)] public IntPtr pointerValue;
+        [FieldOffset(0)] public IUnknown* unkownValue;
+        [FieldOffset(0)] public IStream* pStream;
+        [FieldOffset(0)] public CurrencyValue currencyValue;
+        [FieldOffset(0)] public RecordValue recordValue;
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct CurrencyLowHigh
+        {
+            public uint LowValue;
+            public int HighValue;
+        }
+
+        [StructLayout(LayoutKind.Explicit)]
+        public struct CurrencyValue
+        {
+            [FieldOffset(0)] public CurrencyLowHigh LowHigh;
+            [FieldOffset(0)] public long longValue;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct RecordValue
+        {
+            public IntPtr RecordInfo;
+            public IntPtr RecordPointer;
+        }
+    }
+}

src/Vortice.Win32/Com/VariantElementType.cs

@@ -0,0 +1,56 @@
+// Copyright © Amer Koleci and Contributors.
+// Licensed under the MIT License (MIT). See LICENSE in the repository root for more information.
+
+namespace Win32.Com;
+
+/// <summary>
+/// Type of a simple variant value.
+/// </summary>
+public enum VariantElementType : ushort
+{
+    Empty = 0,
+    Null = 1,
+    Short = 2,
+    Int = 3,
+    Float = 4,
+    Double = 5,
+    Currency = 6,
+    Date = 7,
+    BinaryString = 8,
+    Dispatch = 9,
+    Error = 10,
+    Bool = 11,
+    Variant = 12,
+    ComUnknown = 13,
+    Decimal = 14,
+    Byte = 16,
+    UByte = 17,
+    UShort = 18,
+    UInt = 19,
+    Long = 20,
+    ULong = 21,
+    Int1 = 22,
+    UInt1 = 23,
+    Void = 24,
+    Result = 25,
+    Pointer = 26,
+    SafeArray = 27,
+    ConstantArray = 28,
+    UserDefined = 29,
+    StringPointer = 30,
+    WStringPointer = 31,
+    Recor = 36,
+    IntPointer = 37,
+    UIntPointer = 38,
+    FileTime = 64,
+    Blob = 65,
+    Stream = 66,
+    Storage = 67,
+    StreamedObject = 68,
+    StoredObject = 69,
+    BlobObject = 70,
+    ClipData = 71,
+    Clsid = 72,
+    VersionedStream = 73,
+    BinaryStringBlob = 0xfff,
+}

src/Vortice.Win32/Com/VariantFullType.cs

@@ -0,0 +1,40 @@
+// Copyright © Amer Koleci and Contributors.
+// Licensed under the MIT License (MIT). See LICENSE in the repository root for more information.
+
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+
+namespace Win32.Com;
+
+/// <summary>
+/// Type of a variant
+/// </summary>
+[StructLayout(LayoutKind.Sequential)]
+public readonly struct VariantFullType : IEquatable<VariantFullType>
+{
+    private readonly ushort vt;
+
+    public VariantElementType ElementType => (VariantElementType)(vt & 0x0fff);
+    public VariantType Type => (VariantType)(vt & 0xf000);
+
+    public VariantFullType(short value) => vt = unchecked((ushort)value);
+    public VariantFullType(ushort value) => vt = value;
+
+    public static implicit operator short(VariantFullType value) => unchecked((short)value.vt);
+    public static implicit operator ushort(VariantFullType value) => value.vt;
+    public static implicit operator VariantFullType(short value) => new(value);
+    public static implicit operator VariantFullType(ushort value) => new(value);
+
+    public VariantFullType(VariantElementType elementType, VariantType type)
+    {
+        vt = (ushort)((ushort)type | (ushort)elementType);
+    }
+
+    public bool Equals(VariantFullType other) => vt == other.vt;
+    public override bool Equals(object obj) => obj is VariantFullType other && Equals(other);
+    public override int GetHashCode() => vt.GetHashCode();
+    public static bool operator ==(VariantFullType left, VariantFullType right) => left.Equals(right);
+    public static bool operator !=(VariantFullType left, VariantFullType right) => !left.Equals(right);
+
+    public override string ToString() => $"{ElementType} {Type}";
+}

src/Vortice.Win32/Com/VariantType.cs

@@ -0,0 +1,36 @@
+// Copyright © Amer Koleci and Contributors.
+// Licensed under the MIT License (MIT). See LICENSE in the repository root for more information.
+
+namespace Win32.Com;
+
+/// <summary>
+/// Type of a variant
+/// </summary>
+[Flags]
+public enum VariantType : ushort
+{
+    /// <summary>
+    /// Simple value
+    /// </summary>
+    Default = 0x0000,
+
+    /// <summary>
+    /// Vector value.
+    /// </summary>
+    Vector = 0x1000,
+
+    /// <summary>
+    /// Array value.
+    /// </summary>
+    Array = 0x2000,
+
+    /// <summary>
+    /// By reference.
+    /// </summary>
+    ByRef = 0x4000,
+
+    /// <summary>
+    /// Reserved value.
+    /// </summary>
+    Reserved = 0x8000,
+}

src/Vortice.Win32/Generated/Graphics/Direct2D.Common.cs

@@ -478,7 +478,6 @@ public unsafe partial struct ID2D1SimplifiedGeometrySink
 	{
 		return ((delegate* unmanaged[Stdcall]<ID2D1SimplifiedGeometrySink*, int>)(lpVtbl[9]))((ID2D1SimplifiedGeometrySink*)Unsafe.AsPointer(ref this));
 	}
-
 }
 
 #endregion Com Types

src/Vortice.Win32/Generated/Graphics/Direct3D.Dxc.cs

@@ -511,7 +511,6 @@ public unsafe partial struct IDxcBlob
 	{
 		return ((delegate* unmanaged[Stdcall]<IDxcBlob*, nuint>)(lpVtbl[4]))((IDxcBlob*)Unsafe.AsPointer(ref this));
 	}
-
 }
 
 /// <include file='../Direct3D.xml' path='doc/member[@name="IDxcBlobEncoding"]/*' />
@@ -598,7 +597,6 @@ public unsafe partial struct IDxcBlobEncoding
 	{
 		return ((delegate* unmanaged[Stdcall]<IDxcBlobEncoding*, Bool32*, DxcCp*, int>)(lpVtbl[5]))((IDxcBlobEncoding*)Unsafe.AsPointer(ref this), pKnown, pCodePage);
 	}
-
 }
 
 /// <include file='../Direct3D.xml' path='doc/member[@name="IDxcBlobUtf16"]/*' />
@@ -701,7 +699,6 @@ public unsafe partial struct IDxcBlobUtf16
 	{
 		return ((delegate* unmanaged[Stdcall]<IDxcBlobUtf16*, nuint>)(lpVtbl[7]))((IDxcBlobUtf16*)Unsafe.AsPointer(ref this));
 	}
-
 }
 
 /// <include file='../Direct3D.xml' path='doc/member[@name="IDxcBlobUtf8"]/*' />
@@ -804,7 +801,6 @@ public unsafe partial struct IDxcBlobUtf8
 	{
 		return ((delegate* unmanaged[Stdcall]<IDxcBlobUtf8*, nuint>)(lpVtbl[7]))((IDxcBlobUtf8*)Unsafe.AsPointer(ref this));
 	}
-
 }
 
 /// <include file='../Direct3D.xml' path='doc/member[@name="IDxcIncludeHandler"]/*' />
@@ -875,7 +871,6 @@ public unsafe partial struct IDxcIncludeHandler
 	{
 		return ((delegate* unmanaged[Stdcall]<IDxcIncludeHandler*, ushort*, IDxcBlob**, int>)(lpVtbl[3]))((IDxcIncludeHandler*)Unsafe.AsPointer(ref this), pFilename, ppIncludeSource);
 	}
-
 }
 
 /// <include file='../Direct3D.xml' path='doc/member[@name="IDxcCompilerArgs"]/*' />
@@ -978,7 +973,6 @@ public unsafe partial struct IDxcCompilerArgs
 	{
 		return ((delegate* unmanaged[Stdcall]<IDxcCompilerArgs*, DxcDefine*, uint, int>)(lpVtbl[7]))((IDxcCompilerArgs*)Unsafe.AsPointer(ref this), pDefines, defineCount);
 	}
-
 }
 
 /// <include file='../Direct3D.xml' path='doc/member[@name="IDxcLibrary"]/*' />
@@ -1121,7 +1115,6 @@ public unsafe partial struct IDxcLibrary
 	{
 		return ((delegate* unmanaged[Stdcall]<IDxcLibrary*, IDxcBlob*, IDxcBlobEncoding**, int>)(lpVtbl[12]))((IDxcLibrary*)Unsafe.AsPointer(ref this), pBlob, pBlobEncoding);
 	}
-
 }
 
 /// <include file='../Direct3D.xml' path='doc/member[@name="IDxcOperationResult"]/*' />
@@ -1208,7 +1201,6 @@ public unsafe partial struct IDxcOperationResult
 	{
 		return ((delegate* unmanaged[Stdcall]<IDxcOperationResult*, IDxcBlobEncoding**, int>)(lpVtbl[5]))((IDxcOperationResult*)Unsafe.AsPointer(ref this), ppErrors);
 	}
-
 }
 
 /// <include file='../Direct3D.xml' path='doc/member[@name="IDxcCompiler"]/*' />
@@ -1295,7 +1287,6 @@ public unsafe partial struct IDxcCompiler
 	{
 		return ((delegate* unmanaged[Stdcall]<IDxcCompiler*, IDxcBlob*, IDxcBlobEncoding**, int>)(lpVtbl[5]))((IDxcCompiler*)Unsafe.AsPointer(ref this), pSource, ppDisassembly);
 	}
-
 }
 
 /// <include file='../Direct3D.xml' path='doc/member[@name="IDxcCompiler2"]/*' />
@@ -1390,7 +1381,6 @@ public unsafe partial struct IDxcCompiler2
 	{
 		return ((delegate* unmanaged[Stdcall]<IDxcCompiler2*, IDxcBlob*, ushort*, ushort*, ushort*, ushort**, uint, DxcDefine*, uint, IDxcIncludeHandler*, IDxcOperationResult**, ushort**, IDxcBlob**, int>)(lpVtbl[6]))((IDxcCompiler2*)Unsafe.AsPointer(ref this), pSource, pSourceName, pEntryPoint, pTargetProfile, pArguments, argCount, pDefines, defineCount, pIncludeHandler, ppResult, ppDebugBlobName, ppDebugBlob);
 	}
-
 }
 
 /// <include file='../Direct3D.xml' path='doc/member[@name="IDxcLinker"]/*' />
@@ -1469,7 +1459,6 @@ public unsafe partial struct IDxcLinker
 	{
 		return ((delegate* unmanaged[Stdcall]<IDxcLinker*, ushort*, ushort*, ushort**, uint, ushort**, uint, IDxcOperationResult**, int>)(lpVtbl[4]))((IDxcLinker*)Unsafe.AsPointer(ref this), pEntryName, pTargetProfile, pLibNames, libCount, pArguments, argCount, ppResult);
 	}
-
 }
 
 /// <include file='../Direct3D.xml' path='doc/member[@name="IDxcUtils"]/*' />
@@ -1636,7 +1625,6 @@ public unsafe partial struct IDxcUtils
 	{
 		return ((delegate* unmanaged[Stdcall]<IDxcUtils*, IDxcBlob*, IDxcBlob**, IDxcBlob**, int>)(lpVtbl[15]))((IDxcUtils*)Unsafe.AsPointer(ref this), pPDBBlob, ppHash, ppContainer);
 	}
-
 }
 
 /// <include file='../Direct3D.xml' path='doc/member[@name="IDxcResult"]/*' />
@@ -1763,7 +1751,6 @@ public unsafe partial struct IDxcResult
 	{
 		return ((delegate* unmanaged[Stdcall]<IDxcResult*, Graphics.Direct3D.Dxc.DxcOutKind>)(lpVtbl[10]))((IDxcResult*)Unsafe.AsPointer(ref this));
 	}
-
 }
 
 /// <include file='../Direct3D.xml' path='doc/member[@name="IDxcExtraOutputs"]/*' />
@@ -1842,7 +1829,6 @@ public unsafe partial struct IDxcExtraOutputs
 	{
 		return ((delegate* unmanaged[Stdcall]<IDxcExtraOutputs*, uint, Guid*, void**, IDxcBlobUtf16**, IDxcBlobUtf16**, int>)(lpVtbl[4]))((IDxcExtraOutputs*)Unsafe.AsPointer(ref this), uIndex, iid, ppvObject, ppOutputType, ppOutputName);
 	}
-
 }
 
 /// <include file='../Direct3D.xml' path='doc/member[@name="IDxcCompiler3"]/*' />
@@ -1921,7 +1907,6 @@ public unsafe partial struct IDxcCompiler3
 	{
 		return ((delegate* unmanaged[Stdcall]<IDxcCompiler3*, DxcBuffer*, Guid*, void**, int>)(lpVtbl[4]))((IDxcCompiler3*)Unsafe.AsPointer(ref this), pObject, riid, ppResult);
 	}
-
 }
 
 /// <include file='../Direct3D.xml' path='doc/member[@name="IDxcValidator"]/*' />
@@ -1992,7 +1977,6 @@ public unsafe partial struct IDxcValidator
 	{
 		return ((delegate* unmanaged[Stdcall]<IDxcValidator*, IDxcBlob*, DxcValidatorFlags, IDxcOperationResult**, int>)(lpVtbl[3]))((IDxcValidator*)Unsafe.AsPointer(ref this), pShader, Flags, ppResult);
 	}
-
 }
 
 /// <include file='../Direct3D.xml' path='doc/member[@name="IDxcValidator2"]/*' />
@@ -2071,7 +2055,6 @@ public unsafe partial struct IDxcValidator2
 	{
 		return ((delegate* unmanaged[Stdcall]<IDxcValidator2*, IDxcBlob*, DxcValidatorFlags, DxcBuffer*, IDxcOperationResult**, int>)(lpVtbl[4]))((IDxcValidator2*)Unsafe.AsPointer(ref this), pShader, Flags, pOptDebugBitcode, ppResult);
 	}
-
 }
 
 /// <include file='../Direct3D.xml' path='doc/member[@name="IDxcContainerBuilder"]/*' />
@@ -2166,7 +2149,6 @@ public unsafe partial struct IDxcContainerBuilder
 	{
 		return ((delegate* unmanaged[Stdcall]<IDxcContainerBuilder*, IDxcOperationResult*, int>)(lpVtbl[6]))((IDxcContainerBuilder*)Unsafe.AsPointer(ref this), ppResult);
 	}
-
 }
 
 /// <include file='../Direct3D.xml' path='doc/member[@name="IDxcAssembler"]/*' />
@@ -2237,7 +2219,6 @@ public unsafe partial struct IDxcAssembler
 	{
 		return ((delegate* unmanaged[Stdcall]<IDxcAssembler*, IDxcBlob*, IDxcOperationResult**, int>)(lpVtbl[3]))((IDxcAssembler*)Unsafe.AsPointer(ref this), pShader, ppResult);
 	}
-
 }
 
 /// <include file='../Direct3D.xml' path='doc/member[@name="IDxcContainerReflection"]/*' />
@@ -2348,7 +2329,6 @@ public unsafe partial struct IDxcContainerReflection
 	{
 		return ((delegate* unmanaged[Stdcall]<IDxcContainerReflection*, uint, Guid*, void**, int>)(lpVtbl[8]))((IDxcContainerReflection*)Unsafe.AsPointer(ref this), idx, iid, ppvObject);
 	}
-
 }
 
 /// <include file='../Direct3D.xml' path='doc/member[@name="IDxcOptimizerPass"]/*' />
@@ -2451,7 +2431,6 @@ public unsafe partial struct IDxcOptimizerPass
 	{
 		return ((delegate* unmanaged[Stdcall]<IDxcOptimizerPass*, uint, ushort**, int>)(lpVtbl[7]))((IDxcOptimizerPass*)Unsafe.AsPointer(ref this), argIndex, ppResult);
 	}
-
 }
 
 /// <include file='../Direct3D.xml' path='doc/member[@name="IDxcOptimizer"]/*' />
@@ -2538,7 +2517,6 @@ public unsafe partial struct IDxcOptimizer
 	{
 		return ((delegate* unmanaged[Stdcall]<IDxcOptimizer*, IDxcBlob*, ushort**, uint, IDxcBlob**, IDxcBlobEncoding**, int>)(lpVtbl[5]))((IDxcOptimizer*)Unsafe.AsPointer(ref this), pBlob, ppOptions, optionCount, pOutputModule, ppOutputText);
 	}
-
 }
 
 /// <include file='../Direct3D.xml' path='doc/member[@name="IDxcVersionInfo"]/*' />
@@ -2617,7 +2595,6 @@ public unsafe partial struct IDxcVersionInfo
 	{
 		return ((delegate* unmanaged[Stdcall]<IDxcVersionInfo*, DxcVersionInfoFlags*, int>)(lpVtbl[4]))((IDxcVersionInfo*)Unsafe.AsPointer(ref this), pFlags);
 	}
-
 }
 
 /// <include file='../Direct3D.xml' path='doc/member[@name="IDxcVersionInfo2"]/*' />
@@ -2704,7 +2681,6 @@ public unsafe partial struct IDxcVersionInfo2
 	{
 		return ((delegate* unmanaged[Stdcall]<IDxcVersionInfo2*, uint*, sbyte**, int>)(lpVtbl[5]))((IDxcVersionInfo2*)Unsafe.AsPointer(ref this), pCommitCount, pCommitHash);
 	}
-
 }
 
 /// <include file='../Direct3D.xml' path='doc/member[@name="IDxcVersionInfo3"]/*' />
@@ -2775,7 +2751,6 @@ public unsafe partial struct IDxcVersionInfo3
 	{
 		return ((delegate* unmanaged[Stdcall]<IDxcVersionInfo3*, sbyte**, int>)(lpVtbl[3]))((IDxcVersionInfo3*)Unsafe.AsPointer(ref this), pVersionString);
 	}
-
 }
 
 /// <include file='../Direct3D.xml' path='doc/member[@name="IDxcPdbUtils"]/*' />
@@ -3030,7 +3005,6 @@ public unsafe partial struct IDxcPdbUtils
 	{
 		return ((delegate* unmanaged[Stdcall]<IDxcPdbUtils*, ushort*, int>)(lpVtbl[26]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), pRootSignature);
 	}
-
 }
 
 #endregion Com Types

src/Vortice.Win32/Generated/Graphics/Direct3D.cs

@@ -1296,7 +1296,6 @@ public unsafe partial struct ID3DBlob
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3DBlob*, nuint>)(lpVtbl[4]))((ID3DBlob*)Unsafe.AsPointer(ref this));
 	}
-
 }
 
 /// <include file='../Direct3D.xml' path='doc/member[@name="ID3DDestructionNotifier"]/*' />
@@ -1375,7 +1374,6 @@ public unsafe partial struct ID3DDestructionNotifier
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3DDestructionNotifier*, uint, int>)(lpVtbl[4]))((ID3DDestructionNotifier*)Unsafe.AsPointer(ref this), callbackID);
 	}
-
 }
 
 /// <include file='../Direct3D.xml' path='doc/member[@name="ID3DInclude"]/*' />
@@ -1399,7 +1397,6 @@ public unsafe partial struct ID3DInclude
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3DInclude*, void*, int>)(lpVtbl[1]))((ID3DInclude*)Unsafe.AsPointer(ref this), pData);
 	}
-
 }
 
 #endregion Com Types

src/Vortice.Win32/Generated/Graphics/Direct3D11.cs

@@ -13492,7 +13492,6 @@ public unsafe partial struct ID3D11DeviceChild
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D11DeviceChild*, Guid*, IUnknown*, int>)(lpVtbl[6]))((ID3D11DeviceChild*)Unsafe.AsPointer(ref this), guid, pData);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11DepthStencilState"]/*' />
@@ -13595,7 +13594,6 @@ public unsafe partial struct ID3D11DepthStencilState
 	{
 		((delegate* unmanaged[Stdcall]<ID3D11DepthStencilState*, DepthStencilDescription*, void>)(lpVtbl[7]))((ID3D11DepthStencilState*)Unsafe.AsPointer(ref this), pDesc);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11BlendState"]/*' />
@@ -13698,7 +13696,6 @@ public unsafe partial struct ID3D11BlendState
 	{
 		((delegate* unmanaged[Stdcall]<ID3D11BlendState*, BlendDescription*, void>)(lpVtbl[7]))((ID3D11BlendState*)Unsafe.AsPointer(ref this), pDesc);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11RasterizerState"]/*' />
@@ -13801,7 +13798,6 @@ public unsafe partial struct ID3D11RasterizerState
 	{
 		((delegate* unmanaged[Stdcall]<ID3D11RasterizerState*, RasterizerDescription*, void>)(lpVtbl[7]))((ID3D11RasterizerState*)Unsafe.AsPointer(ref this), pDesc);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11Resource"]/*' />
@@ -13920,7 +13916,6 @@ public unsafe partial struct ID3D11Resource
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D11Resource*, uint>)(lpVtbl[9]))((ID3D11Resource*)Unsafe.AsPointer(ref this));
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11Buffer"]/*' />
@@ -14047,7 +14042,6 @@ public unsafe partial struct ID3D11Buffer
 	{
 		((delegate* unmanaged[Stdcall]<ID3D11Buffer*, BufferDescription*, void>)(lpVtbl[10]))((ID3D11Buffer*)Unsafe.AsPointer(ref this), pDesc);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11Texture1D"]/*' />
@@ -14174,7 +14168,6 @@ public unsafe partial struct ID3D11Texture1D
 	{
 		((delegate* unmanaged[Stdcall]<ID3D11Texture1D*, Texture1DDescription*, void>)(lpVtbl[10]))((ID3D11Texture1D*)Unsafe.AsPointer(ref this), pDesc);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11Texture2D"]/*' />
@@ -14301,7 +14294,6 @@ public unsafe partial struct ID3D11Texture2D
 	{
 		((delegate* unmanaged[Stdcall]<ID3D11Texture2D*, Texture2DDescription*, void>)(lpVtbl[10]))((ID3D11Texture2D*)Unsafe.AsPointer(ref this), pDesc);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11Texture3D"]/*' />
@@ -14428,7 +14420,6 @@ public unsafe partial struct ID3D11Texture3D
 	{
 		((delegate* unmanaged[Stdcall]<ID3D11Texture3D*, Texture3DDescription*, void>)(lpVtbl[10]))((ID3D11Texture3D*)Unsafe.AsPointer(ref this), pDesc);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11View"]/*' />
@@ -14531,7 +14522,6 @@ public unsafe partial struct ID3D11View
 	{
 		((delegate* unmanaged[Stdcall]<ID3D11View*, ID3D11Resource*, void>)(lpVtbl[7]))((ID3D11View*)Unsafe.AsPointer(ref this), ppResource);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11ShaderResourceView"]/*' />
@@ -14642,7 +14632,6 @@ public unsafe partial struct ID3D11ShaderResourceView
 	{
 		((delegate* unmanaged[Stdcall]<ID3D11ShaderResourceView*, ShaderResourceViewDescription*, void>)(lpVtbl[8]))((ID3D11ShaderResourceView*)Unsafe.AsPointer(ref this), pDesc);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11RenderTargetView"]/*' />
@@ -14753,7 +14742,6 @@ public unsafe partial struct ID3D11RenderTargetView
 	{
 		((delegate* unmanaged[Stdcall]<ID3D11RenderTargetView*, RenderTargetViewDescription*, void>)(lpVtbl[8]))((ID3D11RenderTargetView*)Unsafe.AsPointer(ref this), pDesc);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11DepthStencilView"]/*' />
@@ -14864,7 +14852,6 @@ public unsafe partial struct ID3D11DepthStencilView
 	{
 		((delegate* unmanaged[Stdcall]<ID3D11DepthStencilView*, DepthStencilViewDescription*, void>)(lpVtbl[8]))((ID3D11DepthStencilView*)Unsafe.AsPointer(ref this), pDesc);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11UnorderedAccessView"]/*' />
@@ -14975,7 +14962,6 @@ public unsafe partial struct ID3D11UnorderedAccessView
 	{
 		((delegate* unmanaged[Stdcall]<ID3D11UnorderedAccessView*, UnorderedAccessViewDescription*, void>)(lpVtbl[8]))((ID3D11UnorderedAccessView*)Unsafe.AsPointer(ref this), pDesc);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11VertexShader"]/*' />
@@ -15070,7 +15056,6 @@ public unsafe partial struct ID3D11VertexShader
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D11VertexShader*, Guid*, IUnknown*, int>)(lpVtbl[6]))((ID3D11VertexShader*)Unsafe.AsPointer(ref this), guid, pData);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11HullShader"]/*' />
@@ -15165,7 +15150,6 @@ public unsafe partial struct ID3D11HullShader
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D11HullShader*, Guid*, IUnknown*, int>)(lpVtbl[6]))((ID3D11HullShader*)Unsafe.AsPointer(ref this), guid, pData);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11DomainShader"]/*' />
@@ -15260,7 +15244,6 @@ public unsafe partial struct ID3D11DomainShader
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D11DomainShader*, Guid*, IUnknown*, int>)(lpVtbl[6]))((ID3D11DomainShader*)Unsafe.AsPointer(ref this), guid, pData);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11GeometryShader"]/*' />
@@ -15355,7 +15338,6 @@ public unsafe partial struct ID3D11GeometryShader
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D11GeometryShader*, Guid*, IUnknown*, int>)(lpVtbl[6]))((ID3D11GeometryShader*)Unsafe.AsPointer(ref this), guid, pData);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11PixelShader"]/*' />
@@ -15450,7 +15432,6 @@ public unsafe partial struct ID3D11PixelShader
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D11PixelShader*, Guid*, IUnknown*, int>)(lpVtbl[6]))((ID3D11PixelShader*)Unsafe.AsPointer(ref this), guid, pData);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11ComputeShader"]/*' />
@@ -15545,7 +15526,6 @@ public unsafe partial struct ID3D11ComputeShader
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D11ComputeShader*, Guid*, IUnknown*, int>)(lpVtbl[6]))((ID3D11ComputeShader*)Unsafe.AsPointer(ref this), guid, pData);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11InputLayout"]/*' />
@@ -15640,7 +15620,6 @@ public unsafe partial struct ID3D11InputLayout
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D11InputLayout*, Guid*, IUnknown*, int>)(lpVtbl[6]))((ID3D11InputLayout*)Unsafe.AsPointer(ref this), guid, pData);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11SamplerState"]/*' />
@@ -15743,7 +15722,6 @@ public unsafe partial struct ID3D11SamplerState
 	{
 		((delegate* unmanaged[Stdcall]<ID3D11SamplerState*, SamplerDescription*, void>)(lpVtbl[7]))((ID3D11SamplerState*)Unsafe.AsPointer(ref this), pDesc);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11Asynchronous"]/*' />
@@ -15846,7 +15824,6 @@ public unsafe partial struct ID3D11Asynchronous
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D11Asynchronous*, uint>)(lpVtbl[7]))((ID3D11Asynchronous*)Unsafe.AsPointer(ref this));
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11Query"]/*' />
@@ -15957,7 +15934,6 @@ public unsafe partial struct ID3D11Query
 	{
 		((delegate* unmanaged[Stdcall]<ID3D11Query*, QueryDescription*, void>)(lpVtbl[8]))((ID3D11Query*)Unsafe.AsPointer(ref this), pDesc);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11Predicate"]/*' />
@@ -16068,7 +16044,6 @@ public unsafe partial struct ID3D11Predicate
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D11Predicate*, Guid*, IUnknown*, int>)(lpVtbl[8]))((ID3D11Predicate*)Unsafe.AsPointer(ref this), guid, pData);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11Counter"]/*' />
@@ -16179,7 +16154,6 @@ public unsafe partial struct ID3D11Counter
 	{
 		((delegate* unmanaged[Stdcall]<ID3D11Counter*, CounterDescription*, void>)(lpVtbl[8]))((ID3D11Counter*)Unsafe.AsPointer(ref this), pDesc);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11ClassInstance"]/*' />
@@ -16306,7 +16280,6 @@ public unsafe partial struct ID3D11ClassInstance
 	{
 		((delegate* unmanaged[Stdcall]<ID3D11ClassInstance*, byte*, nuint*, void>)(lpVtbl[10]))((ID3D11ClassInstance*)Unsafe.AsPointer(ref this), pTypeName, pBufferLength);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11ClassLinkage"]/*' />
@@ -16417,7 +16390,6 @@ public unsafe partial struct ID3D11ClassLinkage
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D11ClassLinkage*, sbyte*, uint, uint, uint, uint, ID3D11ClassInstance**, int>)(lpVtbl[8]))((ID3D11ClassLinkage*)Unsafe.AsPointer(ref this), pClassTypeName, ConstantBufferOffset, ConstantVectorOffset, TextureOffset, SamplerOffset, ppInstance);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11CommandList"]/*' />
@@ -16520,7 +16492,6 @@ public unsafe partial struct ID3D11CommandList
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D11CommandList*, uint>)(lpVtbl[7]))((ID3D11CommandList*)Unsafe.AsPointer(ref this));
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11DeviceContext"]/*' />
@@ -17479,7 +17450,6 @@ public unsafe partial struct ID3D11DeviceContext
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D11DeviceContext*, Bool32, ID3D11CommandList**, int>)(lpVtbl[114]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), RestoreDeferredContextState, ppCommandList);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11VideoDecoder"]/*' />
@@ -17590,7 +17560,6 @@ public unsafe partial struct ID3D11VideoDecoder
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D11VideoDecoder*, IntPtr*, int>)(lpVtbl[8]))((ID3D11VideoDecoder*)Unsafe.AsPointer(ref this), pDriverHandle);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11VideoProcessorEnumerator"]/*' />
@@ -17733,7 +17702,6 @@ public unsafe partial struct ID3D11VideoProcessorEnumerator
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D11VideoProcessorEnumerator*, VideoProcessorFilter, VideoProcessorFilterRange*, int>)(lpVtbl[12]))((ID3D11VideoProcessorEnumerator*)Unsafe.AsPointer(ref this), Filter, pRange);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11VideoProcessor"]/*' />
@@ -17844,7 +17812,6 @@ public unsafe partial struct ID3D11VideoProcessor
 	{
 		((delegate* unmanaged[Stdcall]<ID3D11VideoProcessor*, VideoProcessorRateConversionCaps*, void>)(lpVtbl[8]))((ID3D11VideoProcessor*)Unsafe.AsPointer(ref this), pCaps);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11AuthenticatedChannel"]/*' />
@@ -17963,7 +17930,6 @@ public unsafe partial struct ID3D11AuthenticatedChannel
 	{
 		((delegate* unmanaged[Stdcall]<ID3D11AuthenticatedChannel*, IntPtr*, void>)(lpVtbl[9]))((ID3D11AuthenticatedChannel*)Unsafe.AsPointer(ref this), pChannelHandle);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11CryptoSession"]/*' />
@@ -18098,7 +18064,6 @@ public unsafe partial struct ID3D11CryptoSession
 	{
 		((delegate* unmanaged[Stdcall]<ID3D11CryptoSession*, IntPtr*, void>)(lpVtbl[11]))((ID3D11CryptoSession*)Unsafe.AsPointer(ref this), pCryptoSessionHandle);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11VideoDecoderOutputView"]/*' />
@@ -18209,7 +18174,6 @@ public unsafe partial struct ID3D11VideoDecoderOutputView
 	{
 		((delegate* unmanaged[Stdcall]<ID3D11VideoDecoderOutputView*, VideoDecoderOutputViewDescription*, void>)(lpVtbl[8]))((ID3D11VideoDecoderOutputView*)Unsafe.AsPointer(ref this), pDesc);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11VideoProcessorInputView"]/*' />
@@ -18320,7 +18284,6 @@ public unsafe partial struct ID3D11VideoProcessorInputView
 	{
 		((delegate* unmanaged[Stdcall]<ID3D11VideoProcessorInputView*, VideoProcessorInputViewDescription*, void>)(lpVtbl[8]))((ID3D11VideoProcessorInputView*)Unsafe.AsPointer(ref this), pDesc);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11VideoProcessorOutputView"]/*' />
@@ -18431,7 +18394,6 @@ public unsafe partial struct ID3D11VideoProcessorOutputView
 	{
 		((delegate* unmanaged[Stdcall]<ID3D11VideoProcessorOutputView*, VideoProcessorOutputViewDescription*, void>)(lpVtbl[8]))((ID3D11VideoProcessorOutputView*)Unsafe.AsPointer(ref this), pDesc);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11VideoContext"]/*' />
@@ -18990,7 +18952,6 @@ public unsafe partial struct ID3D11VideoContext
 	{
 		((delegate* unmanaged[Stdcall]<ID3D11VideoContext*, ID3D11VideoProcessor*, uint, Bool32*, VideoProcessorRotation*, void>)(lpVtbl[64]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnable, pRotation);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11VideoDevice"]/*' />
@@ -19189,7 +19150,6 @@ public unsafe partial struct ID3D11VideoDevice
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D11VideoDevice*, Guid*, IUnknown*, int>)(lpVtbl[19]))((ID3D11VideoDevice*)Unsafe.AsPointer(ref this), guid, pData);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11Device"]/*' />
@@ -19572,7 +19532,6 @@ public unsafe partial struct ID3D11Device
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D11Device*, uint>)(lpVtbl[42]))((ID3D11Device*)Unsafe.AsPointer(ref this));
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11Debug"]/*' />
@@ -19707,7 +19666,6 @@ public unsafe partial struct ID3D11Debug
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D11Debug*, ID3D11DeviceContext*, int>)(lpVtbl[11]))((ID3D11Debug*)Unsafe.AsPointer(ref this), pContext);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11SwitchToRef"]/*' />
@@ -19786,7 +19744,6 @@ public unsafe partial struct ID3D11SwitchToRef
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D11SwitchToRef*, Bool32>)(lpVtbl[4]))((ID3D11SwitchToRef*)Unsafe.AsPointer(ref this));
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11TracingDevice"]/*' />
@@ -19865,7 +19822,6 @@ public unsafe partial struct ID3D11TracingDevice
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D11TracingDevice*, IUnknown*, uint, int>)(lpVtbl[4]))((ID3D11TracingDevice*)Unsafe.AsPointer(ref this), pShader, Options);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11RefTrackingOptions"]/*' />
@@ -19936,7 +19892,6 @@ public unsafe partial struct ID3D11RefTrackingOptions
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D11RefTrackingOptions*, uint, int>)(lpVtbl[3]))((ID3D11RefTrackingOptions*)Unsafe.AsPointer(ref this), uOptions);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11RefDefaultTrackingOptions"]/*' />
@@ -20007,7 +19962,6 @@ public unsafe partial struct ID3D11RefDefaultTrackingOptions
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D11RefDefaultTrackingOptions*, uint, uint, int>)(lpVtbl[3]))((ID3D11RefDefaultTrackingOptions*)Unsafe.AsPointer(ref this), ResourceTypeFlags, Options);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11InfoQueue"]/*' />
@@ -20350,7 +20304,6 @@ public unsafe partial struct ID3D11InfoQueue
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D11InfoQueue*, Bool32>)(lpVtbl[37]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this));
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11BlendState1"]/*' />
@@ -20461,7 +20414,6 @@ public unsafe partial struct ID3D11BlendState1
 	{
 		((delegate* unmanaged[Stdcall]<ID3D11BlendState1*, BlendDescription1*, void>)(lpVtbl[8]))((ID3D11BlendState1*)Unsafe.AsPointer(ref this), pDesc);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11RasterizerState1"]/*' />
@@ -20572,7 +20524,6 @@ public unsafe partial struct ID3D11RasterizerState1
 	{
 		((delegate* unmanaged[Stdcall]<ID3D11RasterizerState1*, RasterizerDescription1*, void>)(lpVtbl[8]))((ID3D11RasterizerState1*)Unsafe.AsPointer(ref this), pDesc);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3DDeviceContextState"]/*' />
@@ -20667,7 +20618,6 @@ public unsafe partial struct ID3DDeviceContextState
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3DDeviceContextState*, Guid*, IUnknown*, int>)(lpVtbl[6]))((ID3DDeviceContextState*)Unsafe.AsPointer(ref this), guid, pData);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11DeviceContext1"]/*' />
@@ -21778,7 +21728,6 @@ public unsafe partial struct ID3D11DeviceContext1
 	{
 		((delegate* unmanaged[Stdcall]<ID3D11DeviceContext1*, ID3D11View*, RawRect*, uint, void>)(lpVtbl[133]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pResourceView, pRects, NumRects);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11VideoContext1"]/*' />
@@ -22449,7 +22398,6 @@ public unsafe partial struct ID3D11VideoContext1
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D11VideoContext1*, ID3D11VideoProcessor*, uint, uint, Graphics.Dxgi.Common.Format, uint, VideoProcessorStreamBehaviorHint*, uint*, int>)(lpVtbl[78]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, OutputWidth, OutputHeight, OutputFormat, StreamCount, pStreams, pBehaviorHints);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11VideoDevice1"]/*' />
@@ -22680,7 +22628,6 @@ public unsafe partial struct ID3D11VideoDevice1
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D11VideoDevice1*, VideoDecoderDescription*, Graphics.Dxgi.Common.ColorSpaceType, VideoDecoderConfig*, Graphics.Dxgi.Common.Rational*, VideoSampleDescription*, int>)(lpVtbl[23]))((ID3D11VideoDevice1*)Unsafe.AsPointer(ref this), pInputDesc, InputColorSpace, pInputConfig, pFrameRate, pRecommendedOutputDesc);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11VideoProcessorEnumerator1"]/*' />
@@ -22831,7 +22778,6 @@ public unsafe partial struct ID3D11VideoProcessorEnumerator1
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D11VideoProcessorEnumerator1*, Graphics.Dxgi.Common.Format, Graphics.Dxgi.Common.ColorSpaceType, Graphics.Dxgi.Common.Format, Graphics.Dxgi.Common.ColorSpaceType, Bool32*, int>)(lpVtbl[13]))((ID3D11VideoProcessorEnumerator1*)Unsafe.AsPointer(ref this), InputFormat, InputColorSpace, OutputFormat, OutputColorSpace, pSupported);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11Device1"]/*' />
@@ -23270,7 +23216,6 @@ public unsafe partial struct ID3D11Device1
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D11Device1*, ushort*, uint, Guid*, void**, int>)(lpVtbl[49]))((ID3D11Device1*)Unsafe.AsPointer(ref this), lpName, dwDesiredAccess, returnedInterface, ppResource);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3DUserDefinedAnnotation"]/*' />
@@ -23365,7 +23310,6 @@ public unsafe partial struct ID3DUserDefinedAnnotation
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3DUserDefinedAnnotation*, Bool32>)(lpVtbl[6]))((ID3DUserDefinedAnnotation*)Unsafe.AsPointer(ref this));
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11DeviceContext2"]/*' />
@@ -24556,7 +24500,6 @@ public unsafe partial struct ID3D11DeviceContext2
 	{
 		((delegate* unmanaged[Stdcall]<ID3D11DeviceContext2*, void>)(lpVtbl[143]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this));
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11Device2"]/*' />
@@ -25027,7 +24970,6 @@ public unsafe partial struct ID3D11Device2
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D11Device2*, Graphics.Dxgi.Common.Format, uint, uint, uint*, int>)(lpVtbl[53]))((ID3D11Device2*)Unsafe.AsPointer(ref this), Format, SampleCount, Flags, pNumQualityLevels);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11Texture2D1"]/*' />
@@ -25162,7 +25104,6 @@ public unsafe partial struct ID3D11Texture2D1
 	{
 		((delegate* unmanaged[Stdcall]<ID3D11Texture2D1*, Texture2DDescription1*, void>)(lpVtbl[11]))((ID3D11Texture2D1*)Unsafe.AsPointer(ref this), pDesc);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11Texture3D1"]/*' />
@@ -25297,7 +25238,6 @@ public unsafe partial struct ID3D11Texture3D1
 	{
 		((delegate* unmanaged[Stdcall]<ID3D11Texture3D1*, Texture3DDescription1*, void>)(lpVtbl[11]))((ID3D11Texture3D1*)Unsafe.AsPointer(ref this), pDesc);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11RasterizerState2"]/*' />
@@ -25416,7 +25356,6 @@ public unsafe partial struct ID3D11RasterizerState2
 	{
 		((delegate* unmanaged[Stdcall]<ID3D11RasterizerState2*, RasterizerDescription2*, void>)(lpVtbl[9]))((ID3D11RasterizerState2*)Unsafe.AsPointer(ref this), pDesc);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11ShaderResourceView1"]/*' />
@@ -25535,7 +25474,6 @@ public unsafe partial struct ID3D11ShaderResourceView1
 	{
 		((delegate* unmanaged[Stdcall]<ID3D11ShaderResourceView1*, ShaderResourceViewDescription1*, void>)(lpVtbl[9]))((ID3D11ShaderResourceView1*)Unsafe.AsPointer(ref this), pDesc1);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11RenderTargetView1"]/*' />
@@ -25654,7 +25592,6 @@ public unsafe partial struct ID3D11RenderTargetView1
 	{
 		((delegate* unmanaged[Stdcall]<ID3D11RenderTargetView1*, RenderTargetViewDescription1*, void>)(lpVtbl[9]))((ID3D11RenderTargetView1*)Unsafe.AsPointer(ref this), pDesc1);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11UnorderedAccessView1"]/*' />
@@ -25773,7 +25710,6 @@ public unsafe partial struct ID3D11UnorderedAccessView1
 	{
 		((delegate* unmanaged[Stdcall]<ID3D11UnorderedAccessView1*, UnorderedAccessViewDescription1*, void>)(lpVtbl[9]))((ID3D11UnorderedAccessView1*)Unsafe.AsPointer(ref this), pDesc1);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11Query1"]/*' />
@@ -25892,7 +25828,6 @@ public unsafe partial struct ID3D11Query1
 	{
 		((delegate* unmanaged[Stdcall]<ID3D11Query1*, QueryDescription1*, void>)(lpVtbl[9]))((ID3D11Query1*)Unsafe.AsPointer(ref this), pDesc1);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11DeviceContext3"]/*' />
@@ -27107,7 +27042,6 @@ public unsafe partial struct ID3D11DeviceContext3
 	{
 		((delegate* unmanaged[Stdcall]<ID3D11DeviceContext3*, Bool32*, void>)(lpVtbl[146]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pHwProtectionEnable);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11Fence"]/*' />
@@ -27226,7 +27160,6 @@ public unsafe partial struct ID3D11Fence
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D11Fence*, ulong, IntPtr, int>)(lpVtbl[9]))((ID3D11Fence*)Unsafe.AsPointer(ref this), Value, hEvent);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11DeviceContext4"]/*' />
@@ -28457,7 +28390,6 @@ public unsafe partial struct ID3D11DeviceContext4
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D11DeviceContext4*, ID3D11Fence*, ulong, int>)(lpVtbl[148]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pFence, Value);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11Device3"]/*' />
@@ -29016,7 +28948,6 @@ public unsafe partial struct ID3D11Device3
 	{
 		((delegate* unmanaged[Stdcall]<ID3D11Device3*, void*, uint, uint, ID3D11Resource*, uint, Box*, void>)(lpVtbl[64]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pDstData, DstRowPitch, DstDepthPitch, pSrcResource, SrcSubresource, pSrcBox);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11Device4"]/*' />
@@ -29591,7 +29522,6 @@ public unsafe partial struct ID3D11Device4
 	{
 		((delegate* unmanaged[Stdcall]<ID3D11Device4*, uint, void>)(lpVtbl[66]))((ID3D11Device4*)Unsafe.AsPointer(ref this), dwCookie);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11Device5"]/*' />
@@ -30182,7 +30112,6 @@ public unsafe partial struct ID3D11Device5
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D11Device5*, ulong, FenceFlags, Guid*, void**, int>)(lpVtbl[68]))((ID3D11Device5*)Unsafe.AsPointer(ref this), InitialValue, Flags, ReturnedInterface, ppFence);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11Multithread"]/*' />
@@ -30277,7 +30206,6 @@ public unsafe partial struct ID3D11Multithread
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D11Multithread*, Bool32>)(lpVtbl[6]))((ID3D11Multithread*)Unsafe.AsPointer(ref this));
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11VideoContext2"]/*' />
@@ -30980,7 +30908,6 @@ public unsafe partial struct ID3D11VideoContext2
 	{
 		((delegate* unmanaged[Stdcall]<ID3D11VideoContext2*, ID3D11VideoProcessor*, uint, Graphics.Dxgi.HdrMetadataType*, uint, void*, void>)(lpVtbl[82]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pType, Size, pMetaData);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11VideoDevice2"]/*' />
@@ -31227,7 +31154,6 @@ public unsafe partial struct ID3D11VideoDevice2
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D11VideoDevice2*, ID3D11CryptoSession*, CryptoSessionKeyExchangeFlags, uint, void*, int>)(lpVtbl[25]))((ID3D11VideoDevice2*)Unsafe.AsPointer(ref this), pCryptoSession, flags, DataSize, pData);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11VideoContext3"]/*' />
@@ -31946,7 +31872,6 @@ public unsafe partial struct ID3D11VideoContext3
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D11VideoContext3*, ID3D11VideoDecoder*, uint, VideoDecoderBufferDescription2*, int>)(lpVtbl[84]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pDecoder, NumBuffers, pBufferDesc);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11ShaderReflectionType"]/*' />
@@ -32069,7 +31994,6 @@ public unsafe partial struct ID3D11ShaderReflectionType
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D11ShaderReflectionType*, ID3D11ShaderReflectionType*, int>)(lpVtbl[10]))((ID3D11ShaderReflectionType*)Unsafe.AsPointer(ref this), pBase);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11ShaderReflectionVariable"]/*' />
@@ -32136,7 +32060,6 @@ public unsafe partial struct ID3D11ShaderReflectionVariable
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D11ShaderReflectionVariable*, uint, uint>)(lpVtbl[3]))((ID3D11ShaderReflectionVariable*)Unsafe.AsPointer(ref this), uArrayIndex);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11ShaderReflectionConstantBuffer"]/*' />
@@ -32195,7 +32118,6 @@ public unsafe partial struct ID3D11ShaderReflectionConstantBuffer
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D11ShaderReflectionConstantBuffer*, sbyte*, Graphics.Direct3D11.ID3D11ShaderReflectionVariable>)(lpVtbl[2]))((ID3D11ShaderReflectionConstantBuffer*)Unsafe.AsPointer(ref this), Name);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11ShaderReflection"]/*' />
@@ -32410,7 +32332,6 @@ public unsafe partial struct ID3D11ShaderReflection
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D11ShaderReflection*, ulong>)(lpVtbl[21]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this));
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11LibraryReflection"]/*' />
@@ -32489,7 +32410,6 @@ public unsafe partial struct ID3D11LibraryReflection
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D11LibraryReflection*, int, Graphics.Direct3D11.ID3D11FunctionReflection>)(lpVtbl[4]))((ID3D11LibraryReflection*)Unsafe.AsPointer(ref this), FunctionIndex);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11FunctionReflection"]/*' />
@@ -32580,7 +32500,6 @@ public unsafe partial struct ID3D11FunctionReflection
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D11FunctionReflection*, int, Graphics.Direct3D11.ID3D11FunctionParameterReflection>)(lpVtbl[6]))((ID3D11FunctionReflection*)Unsafe.AsPointer(ref this), ParameterIndex);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11FunctionParameterReflection"]/*' />
@@ -32623,7 +32542,6 @@ public unsafe partial struct ID3D11FunctionParameterReflection
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D11FunctionParameterReflection*, ParameterDescription*, int>)(lpVtbl[0]))((ID3D11FunctionParameterReflection*)Unsafe.AsPointer(ref this), pDesc);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11ModuleInstance"]/*' />
@@ -32766,7 +32684,6 @@ public unsafe partial struct ID3D11ModuleInstance
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D11ModuleInstance*, sbyte*, uint, uint, int>)(lpVtbl[12]))((ID3D11ModuleInstance*)Unsafe.AsPointer(ref this), pSrvName, uDstUavSlot, uCount);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11Module"]/*' />
@@ -32837,7 +32754,6 @@ public unsafe partial struct ID3D11Module
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D11Module*, sbyte*, ID3D11ModuleInstance**, int>)(lpVtbl[3]))((ID3D11Module*)Unsafe.AsPointer(ref this), pNamespace, ppModuleInstance);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11Linker"]/*' />
@@ -32924,7 +32840,6 @@ public unsafe partial struct ID3D11Linker
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D11Linker*, uint, uint, int>)(lpVtbl[5]))((ID3D11Linker*)Unsafe.AsPointer(ref this), uCBufferSlot, uCBufferEntry);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11LinkingNode"]/*' />
@@ -33114,7 +33029,6 @@ public unsafe partial struct ID3D11FunctionLinkingGraph
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D11FunctionLinkingGraph*, uint, Graphics.Direct3D.ID3DBlob**, int>)(lpVtbl[10]))((ID3D11FunctionLinkingGraph*)Unsafe.AsPointer(ref this), uFlags, ppBuffer);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11ShaderTrace"]/*' />
@@ -33241,7 +33155,6 @@ public unsafe partial struct ID3D11ShaderTrace
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D11ShaderTrace*, uint, uint, TraceRegister*, TraceValue*, int>)(lpVtbl[10]))((ID3D11ShaderTrace*)Unsafe.AsPointer(ref this), stepIndex, readRegisterIndex, pRegister, pValue);
 	}
-
 }
 
 /// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11ShaderTraceFactory"]/*' />
@@ -33312,7 +33225,6 @@ public unsafe partial struct ID3D11ShaderTraceFactory
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D11ShaderTraceFactory*, IUnknown*, ShaderTraceDescription*, ID3D11ShaderTrace**, int>)(lpVtbl[3]))((ID3D11ShaderTraceFactory*)Unsafe.AsPointer(ref this), pShader, pTraceDesc, ppShaderTrace);
 	}
-
 }
 
 #endregion Com Types

src/Vortice.Win32/Generated/Graphics/Direct3D12.cs

@@ -12171,7 +12171,6 @@ public unsafe partial struct ID3D12Object
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12Object*, ushort*, int>)(lpVtbl[6]))((ID3D12Object*)Unsafe.AsPointer(ref this), Name);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12DeviceChild"]/*' />
@@ -12274,7 +12273,6 @@ public unsafe partial struct ID3D12DeviceChild
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12DeviceChild*, Guid*, void**, int>)(lpVtbl[7]))((ID3D12DeviceChild*)Unsafe.AsPointer(ref this), riid, ppvDevice);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12RootSignature"]/*' />
@@ -12377,7 +12375,6 @@ public unsafe partial struct ID3D12RootSignature
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12RootSignature*, ushort*, int>)(lpVtbl[7]))((ID3D12RootSignature*)Unsafe.AsPointer(ref this), Name);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12RootSignatureDeserializer"]/*' />
@@ -12448,7 +12445,6 @@ public unsafe partial struct ID3D12RootSignatureDeserializer
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12RootSignatureDeserializer*, Graphics.Direct3D12.RootSignatureDescription*>)(lpVtbl[3]))((ID3D12RootSignatureDeserializer*)Unsafe.AsPointer(ref this));
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12VersionedRootSignatureDeserializer"]/*' />
@@ -12527,7 +12523,6 @@ public unsafe partial struct ID3D12VersionedRootSignatureDeserializer
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12VersionedRootSignatureDeserializer*, Graphics.Direct3D12.VersionedRootSignatureDescription*>)(lpVtbl[4]))((ID3D12VersionedRootSignatureDeserializer*)Unsafe.AsPointer(ref this));
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12Pageable"]/*' />
@@ -12630,7 +12625,6 @@ public unsafe partial struct ID3D12Pageable
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12Pageable*, ushort*, int>)(lpVtbl[7]))((ID3D12Pageable*)Unsafe.AsPointer(ref this), Name);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12Heap"]/*' />
@@ -12741,7 +12735,6 @@ public unsafe partial struct ID3D12Heap
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12Heap*, Graphics.Direct3D12.HeapDescription>)(lpVtbl[8]))((ID3D12Heap*)Unsafe.AsPointer(ref this));
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12Resource"]/*' />
@@ -12900,7 +12893,6 @@ public unsafe partial struct ID3D12Resource
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12Resource*, HeapProperties*, HeapFlags*, int>)(lpVtbl[14]))((ID3D12Resource*)Unsafe.AsPointer(ref this), pHeapProperties, pHeapFlags);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12CommandAllocator"]/*' />
@@ -13011,7 +13003,6 @@ public unsafe partial struct ID3D12CommandAllocator
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12CommandAllocator*, int>)(lpVtbl[8]))((ID3D12CommandAllocator*)Unsafe.AsPointer(ref this));
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12Fence"]/*' />
@@ -13138,7 +13129,6 @@ public unsafe partial struct ID3D12Fence
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12Fence*, ulong, int>)(lpVtbl[10]))((ID3D12Fence*)Unsafe.AsPointer(ref this), Value);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12Fence1"]/*' />
@@ -13273,7 +13263,6 @@ public unsafe partial struct ID3D12Fence1
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12Fence1*, Graphics.Direct3D12.FenceFlags>)(lpVtbl[11]))((ID3D12Fence1*)Unsafe.AsPointer(ref this));
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12PipelineState"]/*' />
@@ -13384,7 +13373,6 @@ public unsafe partial struct ID3D12PipelineState
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12PipelineState*, Graphics.Direct3D.ID3DBlob**, int>)(lpVtbl[8]))((ID3D12PipelineState*)Unsafe.AsPointer(ref this), ppBlob);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12DescriptorHeap"]/*' />
@@ -13511,7 +13499,6 @@ public unsafe partial struct ID3D12DescriptorHeap
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12DescriptorHeap*, Graphics.Direct3D12.GpuDescriptorHandle>)(lpVtbl[10]))((ID3D12DescriptorHeap*)Unsafe.AsPointer(ref this));
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12QueryHeap"]/*' />
@@ -13614,7 +13601,6 @@ public unsafe partial struct ID3D12QueryHeap
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12QueryHeap*, ushort*, int>)(lpVtbl[7]))((ID3D12QueryHeap*)Unsafe.AsPointer(ref this), Name);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12CommandSignature"]/*' />
@@ -13717,7 +13703,6 @@ public unsafe partial struct ID3D12CommandSignature
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12CommandSignature*, ushort*, int>)(lpVtbl[7]))((ID3D12CommandSignature*)Unsafe.AsPointer(ref this), Name);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12CommandList"]/*' />
@@ -13828,7 +13813,6 @@ public unsafe partial struct ID3D12CommandList
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12CommandList*, Graphics.Direct3D12.CommandListType>)(lpVtbl[8]))((ID3D12CommandList*)Unsafe.AsPointer(ref this));
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12GraphicsCommandList"]/*' />
@@ -14347,7 +14331,6 @@ public unsafe partial struct ID3D12GraphicsCommandList
 	{
 		((delegate* unmanaged[Stdcall]<ID3D12GraphicsCommandList*, ID3D12CommandSignature*, uint, ID3D12Resource*, ulong, ID3D12Resource*, ulong, void>)(lpVtbl[59]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), pCommandSignature, MaxCommandCount, pArgumentBuffer, ArgumentBufferOffset, pCountBuffer, CountBufferOffset);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12GraphicsCommandList1"]/*' />
@@ -14914,7 +14897,6 @@ public unsafe partial struct ID3D12GraphicsCommandList1
 	{
 		((delegate* unmanaged[Stdcall]<ID3D12GraphicsCommandList1*, uint, void>)(lpVtbl[65]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), Mask);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12GraphicsCommandList2"]/*' />
@@ -15489,7 +15471,6 @@ public unsafe partial struct ID3D12GraphicsCommandList2
 	{
 		((delegate* unmanaged[Stdcall]<ID3D12GraphicsCommandList2*, uint, WriteBufferImmediateParameter*, WriteBufferImmediateMode*, void>)(lpVtbl[66]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), Count, pParams, pModes);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12CommandQueue"]/*' />
@@ -15680,7 +15661,6 @@ public unsafe partial struct ID3D12CommandQueue
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12CommandQueue*, Graphics.Direct3D12.CommandQueueDescription>)(lpVtbl[18]))((ID3D12CommandQueue*)Unsafe.AsPointer(ref this));
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12Device"]/*' />
@@ -16071,7 +16051,6 @@ public unsafe partial struct ID3D12Device
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12Device*, Luid>)(lpVtbl[43]))((ID3D12Device*)Unsafe.AsPointer(ref this));
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12PipelineLibrary"]/*' />
@@ -16214,7 +16193,6 @@ public unsafe partial struct ID3D12PipelineLibrary
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12PipelineLibrary*, void*, nuint, int>)(lpVtbl[12]))((ID3D12PipelineLibrary*)Unsafe.AsPointer(ref this), pData, DataSizeInBytes);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12PipelineLibrary1"]/*' />
@@ -16365,7 +16343,6 @@ public unsafe partial struct ID3D12PipelineLibrary1
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12PipelineLibrary1*, ushort*, PipelineStateStreamDescription*, Guid*, void**, int>)(lpVtbl[13]))((ID3D12PipelineLibrary1*)Unsafe.AsPointer(ref this), pName, pDesc, riid, ppPipelineState);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12Device1"]/*' />
@@ -16780,7 +16757,6 @@ public unsafe partial struct ID3D12Device1
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12Device1*, uint, ID3D12Pageable**, ResidencyPriority*, int>)(lpVtbl[46]))((ID3D12Device1*)Unsafe.AsPointer(ref this), NumObjects, ppObjects, pPriorities);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12Device2"]/*' />
@@ -17203,7 +17179,6 @@ public unsafe partial struct ID3D12Device2
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12Device2*, PipelineStateStreamDescription*, Guid*, void**, int>)(lpVtbl[47]))((ID3D12Device2*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12Device3"]/*' />
@@ -17650,7 +17625,6 @@ public unsafe partial struct ID3D12Device3
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12Device3*, ResidencyFlags, uint, ID3D12Pageable**, ID3D12Fence*, ulong, int>)(lpVtbl[50]))((ID3D12Device3*)Unsafe.AsPointer(ref this), Flags, NumObjects, ppObjects, pFenceToSignal, FenceValueToSignal);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12ProtectedSession"]/*' />
@@ -17769,7 +17743,6 @@ public unsafe partial struct ID3D12ProtectedSession
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12ProtectedSession*, Graphics.Direct3D12.ProtectedSessionStatus>)(lpVtbl[9]))((ID3D12ProtectedSession*)Unsafe.AsPointer(ref this));
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12ProtectedResourceSession"]/*' />
@@ -17896,7 +17869,6 @@ public unsafe partial struct ID3D12ProtectedResourceSession
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12ProtectedResourceSession*, Graphics.Direct3D12.ProtectedResourceSessionDescription>)(lpVtbl[10]))((ID3D12ProtectedResourceSession*)Unsafe.AsPointer(ref this));
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12Device4"]/*' />
@@ -18391,7 +18363,6 @@ public unsafe partial struct ID3D12Device4
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12Device4*, uint, uint, ResourceDescription*, ResourceAllocationInfo1*, Graphics.Direct3D12.ResourceAllocationInfo>)(lpVtbl[56]))((ID3D12Device4*)Unsafe.AsPointer(ref this), visibleMask, numResourceDescs, pResourceDescs, pResourceAllocationInfo1);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12LifetimeOwner"]/*' />
@@ -18462,7 +18433,6 @@ public unsafe partial struct ID3D12LifetimeOwner
 	{
 		((delegate* unmanaged[Stdcall]<ID3D12LifetimeOwner*, LifetimeState, void>)(lpVtbl[3]))((ID3D12LifetimeOwner*)Unsafe.AsPointer(ref this), NewState);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12SwapChainAssistant"]/*' />
@@ -18557,7 +18527,6 @@ public unsafe partial struct ID3D12SwapChainAssistant
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12SwapChainAssistant*, int>)(lpVtbl[6]))((ID3D12SwapChainAssistant*)Unsafe.AsPointer(ref this));
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12LifetimeTracker"]/*' />
@@ -18668,7 +18637,6 @@ public unsafe partial struct ID3D12LifetimeTracker
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12LifetimeTracker*, ID3D12DeviceChild*, int>)(lpVtbl[8]))((ID3D12LifetimeTracker*)Unsafe.AsPointer(ref this), pObject);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12StateObject"]/*' />
@@ -18771,7 +18739,6 @@ public unsafe partial struct ID3D12StateObject
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12StateObject*, ushort*, int>)(lpVtbl[7]))((ID3D12StateObject*)Unsafe.AsPointer(ref this), Name);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12StateObjectProperties"]/*' />
@@ -18866,7 +18833,6 @@ public unsafe partial struct ID3D12StateObjectProperties
 	{
 		((delegate* unmanaged[Stdcall]<ID3D12StateObjectProperties*, ulong, void>)(lpVtbl[6]))((ID3D12StateObjectProperties*)Unsafe.AsPointer(ref this), PipelineStackSizeInBytes);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12Device5"]/*' />
@@ -19425,7 +19391,6 @@ public unsafe partial struct ID3D12Device5
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12Device5*, SerializedDataType, SerializedDataDriverMatchingIdentifier*, Graphics.Direct3D12.DriverMatchingIdentifierStatus>)(lpVtbl[64]))((ID3D12Device5*)Unsafe.AsPointer(ref this), SerializedDataType, pIdentifierToCheck);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12DeviceRemovedExtendedDataSettings"]/*' />
@@ -19512,7 +19477,6 @@ public unsafe partial struct ID3D12DeviceRemovedExtendedDataSettings
 	{
 		((delegate* unmanaged[Stdcall]<ID3D12DeviceRemovedExtendedDataSettings*, DredEnablement, void>)(lpVtbl[5]))((ID3D12DeviceRemovedExtendedDataSettings*)Unsafe.AsPointer(ref this), Enablement);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12DeviceRemovedExtendedDataSettings1"]/*' />
@@ -19607,7 +19571,6 @@ public unsafe partial struct ID3D12DeviceRemovedExtendedDataSettings1
 	{
 		((delegate* unmanaged[Stdcall]<ID3D12DeviceRemovedExtendedDataSettings1*, DredEnablement, void>)(lpVtbl[6]))((ID3D12DeviceRemovedExtendedDataSettings1*)Unsafe.AsPointer(ref this), Enablement);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12DeviceRemovedExtendedData"]/*' />
@@ -19686,7 +19649,6 @@ public unsafe partial struct ID3D12DeviceRemovedExtendedData
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12DeviceRemovedExtendedData*, DredPageFaultOutput*, int>)(lpVtbl[4]))((ID3D12DeviceRemovedExtendedData*)Unsafe.AsPointer(ref this), pOutput);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12DeviceRemovedExtendedData1"]/*' />
@@ -19781,7 +19743,6 @@ public unsafe partial struct ID3D12DeviceRemovedExtendedData1
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12DeviceRemovedExtendedData1*, DredPageFaultOutput1*, int>)(lpVtbl[6]))((ID3D12DeviceRemovedExtendedData1*)Unsafe.AsPointer(ref this), pOutput);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12DeviceRemovedExtendedData2"]/*' />
@@ -19892,7 +19853,6 @@ public unsafe partial struct ID3D12DeviceRemovedExtendedData2
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12DeviceRemovedExtendedData2*, Graphics.Direct3D12.DredDeviceState>)(lpVtbl[8]))((ID3D12DeviceRemovedExtendedData2*)Unsafe.AsPointer(ref this));
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12Device6"]/*' />
@@ -20459,7 +20419,6 @@ public unsafe partial struct ID3D12Device6
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12Device6*, BackgroundProcessingMode, MeasurementsAction, IntPtr, Bool32*, int>)(lpVtbl[65]))((ID3D12Device6*)Unsafe.AsPointer(ref this), Mode, MeasurementsAction, hEventToSignalUponCompletion, pbFurtherMeasurementsDesired);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12ProtectedResourceSession1"]/*' />
@@ -20594,7 +20553,6 @@ public unsafe partial struct ID3D12ProtectedResourceSession1
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12ProtectedResourceSession1*, Graphics.Direct3D12.ProtectedResourceSessionDescription1>)(lpVtbl[11]))((ID3D12ProtectedResourceSession1*)Unsafe.AsPointer(ref this));
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12Device7"]/*' />
@@ -21177,7 +21135,6 @@ public unsafe partial struct ID3D12Device7
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12Device7*, ProtectedResourceSessionDescription1*, Guid*, void**, int>)(lpVtbl[67]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pDesc, riid, ppSession);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12Device8"]/*' />
@@ -21800,7 +21757,6 @@ public unsafe partial struct ID3D12Device8
 	{
 		((delegate* unmanaged[Stdcall]<ID3D12Device8*, ResourceDescription1*, uint, uint, ulong, PlacedSubresourceFootprint*, uint*, ulong*, ulong*, void>)(lpVtbl[72]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pResourceDesc, FirstSubresource, NumSubresources, BaseOffset, pLayouts, pNumRows, pRowSizeInBytes, pTotalBytes);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12Resource1"]/*' />
@@ -21967,7 +21923,6 @@ public unsafe partial struct ID3D12Resource1
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12Resource1*, Guid*, void**, int>)(lpVtbl[15]))((ID3D12Resource1*)Unsafe.AsPointer(ref this), riid, ppProtectedSession);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12Resource2"]/*' />
@@ -22142,7 +22097,6 @@ public unsafe partial struct ID3D12Resource2
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12Resource2*, Graphics.Direct3D12.ResourceDescription1>)(lpVtbl[16]))((ID3D12Resource2*)Unsafe.AsPointer(ref this));
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12Heap1"]/*' />
@@ -22261,7 +22215,6 @@ public unsafe partial struct ID3D12Heap1
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12Heap1*, Guid*, void**, int>)(lpVtbl[9]))((ID3D12Heap1*)Unsafe.AsPointer(ref this), riid, ppProtectedSession);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12GraphicsCommandList3"]/*' />
@@ -22844,7 +22797,6 @@ public unsafe partial struct ID3D12GraphicsCommandList3
 	{
 		((delegate* unmanaged[Stdcall]<ID3D12GraphicsCommandList3*, ID3D12ProtectedResourceSession*, void>)(lpVtbl[67]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), pProtectedResourceSession);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12MetaCommand"]/*' />
@@ -22955,7 +22907,6 @@ public unsafe partial struct ID3D12MetaCommand
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12MetaCommand*, MetaCommandParameterStage, uint, ulong>)(lpVtbl[8]))((ID3D12MetaCommand*)Unsafe.AsPointer(ref this), Stage, ParameterIndex);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12GraphicsCommandList4"]/*' />
@@ -23610,7 +23561,6 @@ public unsafe partial struct ID3D12GraphicsCommandList4
 	{
 		((delegate* unmanaged[Stdcall]<ID3D12GraphicsCommandList4*, DispatchRaysDescription*, void>)(lpVtbl[76]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pDesc);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12ShaderCacheSession"]/*' />
@@ -23745,7 +23695,6 @@ public unsafe partial struct ID3D12ShaderCacheSession
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12ShaderCacheSession*, Graphics.Direct3D12.ShaderCacheSessionDescription>)(lpVtbl[11]))((ID3D12ShaderCacheSession*)Unsafe.AsPointer(ref this));
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12Device9"]/*' />
@@ -24392,7 +24341,6 @@ public unsafe partial struct ID3D12Device9
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12Device9*, CommandQueueDescription*, Guid*, Guid*, void**, int>)(lpVtbl[75]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pDesc, CreatorID, riid, ppCommandQueue);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12Tools"]/*' />
@@ -24471,7 +24419,6 @@ public unsafe partial struct ID3D12Tools
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12Tools*, Bool32>)(lpVtbl[4]))((ID3D12Tools*)Unsafe.AsPointer(ref this));
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12Debug"]/*' />
@@ -24542,7 +24489,6 @@ public unsafe partial struct ID3D12Debug
 	{
 		((delegate* unmanaged[Stdcall]<ID3D12Debug*, void>)(lpVtbl[3]))((ID3D12Debug*)Unsafe.AsPointer(ref this));
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12Debug1"]/*' />
@@ -24629,7 +24575,6 @@ public unsafe partial struct ID3D12Debug1
 	{
 		((delegate* unmanaged[Stdcall]<ID3D12Debug1*, Bool32, void>)(lpVtbl[5]))((ID3D12Debug1*)Unsafe.AsPointer(ref this), Enable);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12Debug2"]/*' />
@@ -24700,7 +24645,6 @@ public unsafe partial struct ID3D12Debug2
 	{
 		((delegate* unmanaged[Stdcall]<ID3D12Debug2*, GpuBasedValidationFlags, void>)(lpVtbl[3]))((ID3D12Debug2*)Unsafe.AsPointer(ref this), Flags);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12Debug3"]/*' />
@@ -24795,7 +24739,6 @@ public unsafe partial struct ID3D12Debug3
 	{
 		((delegate* unmanaged[Stdcall]<ID3D12Debug3*, GpuBasedValidationFlags, void>)(lpVtbl[6]))((ID3D12Debug3*)Unsafe.AsPointer(ref this), Flags);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12Debug4"]/*' />
@@ -24898,7 +24841,6 @@ public unsafe partial struct ID3D12Debug4
 	{
 		((delegate* unmanaged[Stdcall]<ID3D12Debug4*, void>)(lpVtbl[7]))((ID3D12Debug4*)Unsafe.AsPointer(ref this));
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12Debug5"]/*' />
@@ -25009,7 +24951,6 @@ public unsafe partial struct ID3D12Debug5
 	{
 		((delegate* unmanaged[Stdcall]<ID3D12Debug5*, Bool32, void>)(lpVtbl[8]))((ID3D12Debug5*)Unsafe.AsPointer(ref this), Enable);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12DebugDevice1"]/*' />
@@ -25096,7 +25037,6 @@ public unsafe partial struct ID3D12DebugDevice1
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12DebugDevice1*, ReportLiveDeviceObjectFlags, int>)(lpVtbl[5]))((ID3D12DebugDevice1*)Unsafe.AsPointer(ref this), Flags);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12DebugDevice"]/*' />
@@ -25183,7 +25123,6 @@ public unsafe partial struct ID3D12DebugDevice
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12DebugDevice*, ReportLiveDeviceObjectFlags, int>)(lpVtbl[5]))((ID3D12DebugDevice*)Unsafe.AsPointer(ref this), Flags);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12DebugDevice2"]/*' />
@@ -25286,7 +25225,6 @@ public unsafe partial struct ID3D12DebugDevice2
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12DebugDevice2*, DebugDeviceParameterType, void*, uint, int>)(lpVtbl[7]))((ID3D12DebugDevice2*)Unsafe.AsPointer(ref this), Type, pData, DataSize);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12DebugCommandQueue"]/*' />
@@ -25357,7 +25295,6 @@ public unsafe partial struct ID3D12DebugCommandQueue
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12DebugCommandQueue*, ID3D12Resource*, uint, uint, Bool32>)(lpVtbl[3]))((ID3D12DebugCommandQueue*)Unsafe.AsPointer(ref this), pResource, Subresource, State);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12DebugCommandList1"]/*' />
@@ -25444,7 +25381,6 @@ public unsafe partial struct ID3D12DebugCommandList1
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12DebugCommandList1*, DebugCommandListParameterType, void*, uint, int>)(lpVtbl[5]))((ID3D12DebugCommandList1*)Unsafe.AsPointer(ref this), Type, pData, DataSize);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12DebugCommandList"]/*' />
@@ -25531,7 +25467,6 @@ public unsafe partial struct ID3D12DebugCommandList
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12DebugCommandList*, Graphics.Direct3D12.DebugFeature>)(lpVtbl[5]))((ID3D12DebugCommandList*)Unsafe.AsPointer(ref this));
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12DebugCommandList2"]/*' />
@@ -25634,7 +25569,6 @@ public unsafe partial struct ID3D12DebugCommandList2
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12DebugCommandList2*, DebugCommandListParameterType, void*, uint, int>)(lpVtbl[7]))((ID3D12DebugCommandList2*)Unsafe.AsPointer(ref this), Type, pData, DataSize);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12SharingContract"]/*' />
@@ -25729,7 +25663,6 @@ public unsafe partial struct ID3D12SharingContract
 	{
 		((delegate* unmanaged[Stdcall]<ID3D12SharingContract*, Guid*, void>)(lpVtbl[6]))((ID3D12SharingContract*)Unsafe.AsPointer(ref this), guid);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12InfoQueue"]/*' />
@@ -26072,7 +26005,6 @@ public unsafe partial struct ID3D12InfoQueue
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12InfoQueue*, Bool32>)(lpVtbl[37]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this));
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12InfoQueue1"]/*' />
@@ -26431,7 +26363,6 @@ public unsafe partial struct ID3D12InfoQueue1
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12InfoQueue1*, uint, int>)(lpVtbl[39]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this), CallbackCookie);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12SDKConfiguration"]/*' />
@@ -26502,7 +26433,6 @@ public unsafe partial struct ID3D12SDKConfiguration
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12SDKConfiguration*, uint, sbyte*, int>)(lpVtbl[3]))((ID3D12SDKConfiguration*)Unsafe.AsPointer(ref this), SDKVersion, SDKPath);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12GraphicsCommandList5"]/*' />
@@ -27173,7 +27103,6 @@ public unsafe partial struct ID3D12GraphicsCommandList5
 	{
 		((delegate* unmanaged[Stdcall]<ID3D12GraphicsCommandList5*, ID3D12Resource*, void>)(lpVtbl[78]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), shadingRateImage);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12GraphicsCommandList6"]/*' />
@@ -27852,7 +27781,6 @@ public unsafe partial struct ID3D12GraphicsCommandList6
 	{
 		((delegate* unmanaged[Stdcall]<ID3D12GraphicsCommandList6*, uint, uint, uint, void>)(lpVtbl[79]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), ThreadGroupCountX, ThreadGroupCountY, ThreadGroupCountZ);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12ShaderReflectionType"]/*' />
@@ -27975,7 +27903,6 @@ public unsafe partial struct ID3D12ShaderReflectionType
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12ShaderReflectionType*, ID3D12ShaderReflectionType*, int>)(lpVtbl[10]))((ID3D12ShaderReflectionType*)Unsafe.AsPointer(ref this), pBase);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12ShaderReflectionVariable"]/*' />
@@ -28042,7 +27969,6 @@ public unsafe partial struct ID3D12ShaderReflectionVariable
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12ShaderReflectionVariable*, uint, uint>)(lpVtbl[3]))((ID3D12ShaderReflectionVariable*)Unsafe.AsPointer(ref this), uArrayIndex);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12ShaderReflectionConstantBuffer"]/*' />
@@ -28101,7 +28027,6 @@ public unsafe partial struct ID3D12ShaderReflectionConstantBuffer
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12ShaderReflectionConstantBuffer*, sbyte*, Graphics.Direct3D12.ID3D12ShaderReflectionVariable>)(lpVtbl[2]))((ID3D12ShaderReflectionConstantBuffer*)Unsafe.AsPointer(ref this), Name);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12ShaderReflection"]/*' />
@@ -28316,7 +28241,6 @@ public unsafe partial struct ID3D12ShaderReflection
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12ShaderReflection*, ulong>)(lpVtbl[21]))((ID3D12ShaderReflection*)Unsafe.AsPointer(ref this));
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12LibraryReflection"]/*' />
@@ -28395,7 +28319,6 @@ public unsafe partial struct ID3D12LibraryReflection
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12LibraryReflection*, int, Graphics.Direct3D12.ID3D12FunctionReflection>)(lpVtbl[4]))((ID3D12LibraryReflection*)Unsafe.AsPointer(ref this), FunctionIndex);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12FunctionReflection"]/*' />
@@ -28486,7 +28409,6 @@ public unsafe partial struct ID3D12FunctionReflection
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12FunctionReflection*, int, Graphics.Direct3D12.ID3D12FunctionParameterReflection>)(lpVtbl[6]))((ID3D12FunctionReflection*)Unsafe.AsPointer(ref this), ParameterIndex);
 	}
-
 }
 
 /// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12FunctionParameterReflection"]/*' />
@@ -28529,7 +28451,6 @@ public unsafe partial struct ID3D12FunctionParameterReflection
 	{
 		return ((delegate* unmanaged[Stdcall]<ID3D12FunctionParameterReflection*, ParameterDescription*, int>)(lpVtbl[0]))((ID3D12FunctionParameterReflection*)Unsafe.AsPointer(ref this), pDesc);
 	}
-
 }
 
 #endregion Com Types

src/Vortice.Win32/Generated/Graphics/Dxgi.cs

@@ -2518,7 +2518,6 @@ public unsafe partial struct IDXGIObject
 	{
 		return ((delegate* unmanaged[Stdcall]<IDXGIObject*, Guid*, void**, int>)(lpVtbl[6]))((IDXGIObject*)Unsafe.AsPointer(ref this), riid, ppParent);
 	}
-
 }
 
 /// <include file='../Dxgi.xml' path='doc/member[@name="IDXGIDeviceSubObject"]/*' />
@@ -2621,7 +2620,6 @@ public unsafe partial struct IDXGIDeviceSubObject
 	{
 		return ((delegate* unmanaged[Stdcall]<IDXGIDeviceSubObject*, Guid*, void**, int>)(lpVtbl[7]))((IDXGIDeviceSubObject*)Unsafe.AsPointer(ref this), riid, ppDevice);
 	}
-
 }
 
 /// <include file='../Dxgi.xml' path='doc/member[@name="IDXGIResource"]/*' />
@@ -2756,7 +2754,6 @@ public unsafe partial struct IDXGIResource
 	{
 		return ((delegate* unmanaged[Stdcall]<IDXGIResource*, uint*, int>)(lpVtbl[11]))((IDXGIResource*)Unsafe.AsPointer(ref this), pEvictionPriority);
 	}
-
 }
 
 /// <include file='../Dxgi.xml' path='doc/member[@name="IDXGIKeyedMutex"]/*' />
@@ -2875,7 +2872,6 @@ public unsafe partial struct IDXGIKeyedMutex
 	{
 		return ((delegate* unmanaged[Stdcall]<IDXGIKeyedMutex*, ulong, int>)(lpVtbl[9]))((IDXGIKeyedMutex*)Unsafe.AsPointer(ref this), Key);
 	}
-
 }
 
 /// <include file='../Dxgi.xml' path='doc/member[@name="IDXGISurface"]/*' />
@@ -3002,7 +2998,6 @@ public unsafe partial struct IDXGISurface
 	{
 		return ((delegate* unmanaged[Stdcall]<IDXGISurface*, int>)(lpVtbl[10]))((IDXGISurface*)Unsafe.AsPointer(ref this));
 	}
-
 }
 
 /// <include file='../Dxgi.xml' path='doc/member[@name="IDXGISurface1"]/*' />
@@ -3145,7 +3140,6 @@ public unsafe partial struct IDXGISurface1
 	{
 		return ((delegate* unmanaged[Stdcall]<IDXGISurface1*, RawRect*, int>)(lpVtbl[12]))((IDXGISurface1*)Unsafe.AsPointer(ref this), pDirtyRect);
 	}
-
 }
 
 /// <include file='../Dxgi.xml' path='doc/member[@name="IDXGIAdapter"]/*' />
@@ -3264,7 +3258,6 @@ public unsafe partial struct IDXGIAdapter
 	{
 		return ((delegate* unmanaged[Stdcall]<IDXGIAdapter*, Guid*, LargeInterger*, int>)(lpVtbl[9]))((IDXGIAdapter*)Unsafe.AsPointer(ref this), InterfaceName, pUMDVersion);
 	}
-
 }
 
 /// <include file='../Dxgi.xml' path='doc/member[@name="IDXGIOutput"]/*' />
@@ -3455,7 +3448,6 @@ public unsafe partial struct IDXGIOutput
 	{
 		return ((delegate* unmanaged[Stdcall]<IDXGIOutput*, FrameStatistics*, int>)(lpVtbl[18]))((IDXGIOutput*)Unsafe.AsPointer(ref this), pStats);
 	}
-
 }
 
 /// <include file='../Dxgi.xml' path='doc/member[@name="IDXGISwapChain"]/*' />
@@ -3638,7 +3630,6 @@ public unsafe partial struct IDXGISwapChain
 	{
 		return ((delegate* unmanaged[Stdcall]<IDXGISwapChain*, uint*, int>)(lpVtbl[17]))((IDXGISwapChain*)Unsafe.AsPointer(ref this), pLastPresentCount);
 	}
-
 }
 
 /// <include file='../Dxgi.xml' path='doc/member[@name="IDXGIFactory"]/*' />
@@ -3773,7 +3764,6 @@ public unsafe partial struct IDXGIFactory
 	{
 		return ((delegate* unmanaged[Stdcall]<IDXGIFactory*, IntPtr, IDXGIAdapter**, int>)(lpVtbl[11]))((IDXGIFactory*)Unsafe.AsPointer(ref this), Module, ppAdapter);
 	}
-
 }
 
 /// <include file='../Dxgi.xml' path='doc/member[@name="IDXGIDevice"]/*' />
@@ -3908,7 +3898,6 @@ public unsafe partial struct IDXGIDevice
 	{
 		return ((delegate* unmanaged[Stdcall]<IDXGIDevice*, int*, int>)(lpVtbl[11]))((IDXGIDevice*)Unsafe.AsPointer(ref this), pPriority);
 	}
-
 }
 
 /// <include file='../Dxgi.xml' path='doc/member[@name="IDXGIFactory1"]/*' />
@@ -4059,7 +4048,6 @@ public unsafe partial struct IDXGIFactory1
 	{
 		return ((delegate* unmanaged[Stdcall]<IDXGIFactory1*, Bool32>)(lpVtbl[13]))((IDXGIFactory1*)Unsafe.AsPointer(ref this));
 	}
-
 }
 
 /// <include file='../Dxgi.xml' path='doc/member[@name="IDXGIAdapter1"]/*' />
@@ -4186,7 +4174,6 @@ public unsafe partial struct IDXGIAdapter1
 	{
 		return ((delegate* unmanaged[Stdcall]<IDXGIAdapter1*, AdapterDescription1*, int>)(lpVtbl[10]))((IDXGIAdapter1*)Unsafe.AsPointer(ref this), pDesc);
 	}
-
 }
 
 /// <include file='../Dxgi.xml' path='doc/member[@name="IDXGIDevice1"]/*' />
@@ -4337,7 +4324,6 @@ public unsafe partial struct IDXGIDevice1
 	{
 		return ((delegate* unmanaged[Stdcall]<IDXGIDevice1*, uint*, int>)(lpVtbl[13]))((IDXGIDevice1*)Unsafe.AsPointer(ref this), pMaxLatency);
 	}
-
 }
 
 /// <include file='../Dxgi.xml' path='doc/member[@name="IDXGIDisplayControl"]/*' />
@@ -4416,7 +4402,6 @@ public unsafe partial struct IDXGIDisplayControl
 	{
 		((delegate* unmanaged[Stdcall]<IDXGIDisplayControl*, Bool32, void>)(lpVtbl[4]))((IDXGIDisplayControl*)Unsafe.AsPointer(ref this), enabled);
 	}
-
 }
 
 /// <include file='../Dxgi.xml' path='doc/member[@name="IDXGIOutputDuplication"]/*' />
@@ -4575,7 +4560,6 @@ public unsafe partial struct IDXGIOutputDuplication
 	{
 		return ((delegate* unmanaged[Stdcall]<IDXGIOutputDuplication*, int>)(lpVtbl[14]))((IDXGIOutputDuplication*)Unsafe.AsPointer(ref this));
 	}
-
 }
 
 /// <include file='../Dxgi.xml' path='doc/member[@name="IDXGISurface2"]/*' />
@@ -4726,7 +4710,6 @@ public unsafe partial struct IDXGISurface2
 	{
 		return ((delegate* unmanaged[Stdcall]<IDXGISurface2*, Guid*, void**, uint*, int>)(lpVtbl[13]))((IDXGISurface2*)Unsafe.AsPointer(ref this), riid, ppParentResource, pSubresourceIndex);
 	}
-
 }
 
 /// <include file='../Dxgi.xml' path='doc/member[@name="IDXGIResource1"]/*' />
@@ -4877,7 +4860,6 @@ public unsafe partial struct IDXGIResource1
 	{
 		return ((delegate* unmanaged[Stdcall]<IDXGIResource1*, Security.SECURITY_ATTRIBUTES*, uint, ushort*, IntPtr*, int>)(lpVtbl[13]))((IDXGIResource1*)Unsafe.AsPointer(ref this), pAttributes, dwAccess, lpName, pHandle);
 	}
-
 }
 
 /// <include file='../Dxgi.xml' path='doc/member[@name="IDXGIDevice2"]/*' />
@@ -5052,7 +5034,6 @@ public unsafe partial struct IDXGIDevice2
 	{
 		return ((delegate* unmanaged[Stdcall]<IDXGIDevice2*, IntPtr, int>)(lpVtbl[16]))((IDXGIDevice2*)Unsafe.AsPointer(ref this), hEvent);
 	}
-
 }
 
 /// <include file='../Dxgi.xml' path='doc/member[@name="IDXGISwapChain1"]/*' />
@@ -5323,7 +5304,6 @@ public unsafe partial struct IDXGISwapChain1
 	{
 		return ((delegate* unmanaged[Stdcall]<IDXGISwapChain1*, Common.ModeRotation*, int>)(lpVtbl[28]))((IDXGISwapChain1*)Unsafe.AsPointer(ref this), pRotation);
 	}
-
 }
 
 /// <include file='../Dxgi.xml' path='doc/member[@name="IDXGIFactory2"]/*' />
@@ -5562,7 +5542,6 @@ public unsafe partial struct IDXGIFactory2
 	{
 		return ((delegate* unmanaged[Stdcall]<IDXGIFactory2*, IUnknown*, SwapChainDescription1*, IDXGIOutput*, IDXGISwapChain1**, int>)(lpVtbl[24]))((IDXGIFactory2*)Unsafe.AsPointer(ref this), pDevice, pDesc, pRestrictToOutput, ppSwapChain);
 	}
-
 }
 
 /// <include file='../Dxgi.xml' path='doc/member[@name="IDXGIAdapter2"]/*' />
@@ -5697,7 +5676,6 @@ public unsafe partial struct IDXGIAdapter2
 	{
 		return ((delegate* unmanaged[Stdcall]<IDXGIAdapter2*, AdapterDescription2*, int>)(lpVtbl[11]))((IDXGIAdapter2*)Unsafe.AsPointer(ref this), pDesc);
 	}
-
 }
 
 /// <include file='../Dxgi.xml' path='doc/member[@name="IDXGIOutput1"]/*' />
@@ -5920,7 +5898,6 @@ public unsafe partial struct IDXGIOutput1
 	{
 		return ((delegate* unmanaged[Stdcall]<IDXGIOutput1*, IUnknown*, IDXGIOutputDuplication**, int>)(lpVtbl[22]))((IDXGIOutput1*)Unsafe.AsPointer(ref this), pDevice, ppOutputDuplication);
 	}
-
 }
 
 /// <include file='../Dxgi.xml' path='doc/member[@name="IDXGIDevice3"]/*' />
@@ -6103,7 +6080,6 @@ public unsafe partial struct IDXGIDevice3
 	{
 		((delegate* unmanaged[Stdcall]<IDXGIDevice3*, void>)(lpVtbl[17]))((IDXGIDevice3*)Unsafe.AsPointer(ref this));
 	}
-
 }
 
 /// <include file='../Dxgi.xml' path='doc/member[@name="IDXGISwapChain2"]/*' />
@@ -6430,7 +6406,6 @@ public unsafe partial struct IDXGISwapChain2
 	{
 		return ((delegate* unmanaged[Stdcall]<IDXGISwapChain2*, Matrix3x2F*, int>)(lpVtbl[35]))((IDXGISwapChain2*)Unsafe.AsPointer(ref this), pMatrix);
 	}
-
 }
 
 /// <include file='../Dxgi.xml' path='doc/member[@name="IDXGIOutput2"]/*' />
@@ -6661,7 +6636,6 @@ public unsafe partial struct IDXGIOutput2
 	{
 		return ((delegate* unmanaged[Stdcall]<IDXGIOutput2*, Bool32>)(lpVtbl[23]))((IDXGIOutput2*)Unsafe.AsPointer(ref this));
 	}
-
 }
 
 /// <include file='../Dxgi.xml' path='doc/member[@name="IDXGIFactory3"]/*' />
@@ -6908,7 +6882,6 @@ public unsafe partial struct IDXGIFactory3
 	{
 		return ((delegate* unmanaged[Stdcall]<IDXGIFactory3*, uint>)(lpVtbl[25]))((IDXGIFactory3*)Unsafe.AsPointer(ref this));
 	}
-
 }
 
 /// <include file='../Dxgi.xml' path='doc/member[@name="IDXGIDecodeSwapChain"]/*' />
@@ -7043,7 +7016,6 @@ public unsafe partial struct IDXGIDecodeSwapChain
 	{
 		return ((delegate* unmanaged[Stdcall]<IDXGIDecodeSwapChain*, Graphics.Dxgi.MultiplaneOverlayYcbcrFlags>)(lpVtbl[11]))((IDXGIDecodeSwapChain*)Unsafe.AsPointer(ref this));
 	}
-
 }
 
 /// <include file='../Dxgi.xml' path='doc/member[@name="IDXGIFactoryMedia"]/*' />
@@ -7122,7 +7094,6 @@ public unsafe partial struct IDXGIFactoryMedia
 	{
 		return ((delegate* unmanaged[Stdcall]<IDXGIFactoryMedia*, IUnknown*, IntPtr, DecodeSwapChainDescription*, IDXGIResource*, IDXGIOutput*, IDXGIDecodeSwapChain**, int>)(lpVtbl[4]))((IDXGIFactoryMedia*)Unsafe.AsPointer(ref this), pDevice, hSurface, pDesc, pYuvDecodeBuffers, pRestrictToOutput, ppSwapChain);
 	}
-
 }
 
 /// <include file='../Dxgi.xml' path='doc/member[@name="IDXGISwapChainMedia"]/*' />
@@ -7209,7 +7180,6 @@ public unsafe partial struct IDXGISwapChainMedia
 	{
 		return ((delegate* unmanaged[Stdcall]<IDXGISwapChainMedia*, uint, uint*, uint*, int>)(lpVtbl[5]))((IDXGISwapChainMedia*)Unsafe.AsPointer(ref this), DesiredPresentDuration, pClosestSmallerPresentDuration, pClosestLargerPresentDuration);
 	}
-
 }
 
 /// <include file='../Dxgi.xml' path='doc/member[@name="IDXGIOutput3"]/*' />
@@ -7448,7 +7418,6 @@ public unsafe partial struct IDXGIOutput3
 	{
 		return ((delegate* unmanaged[Stdcall]<IDXGIOutput3*, Common.Format, IUnknown*, uint*, int>)(lpVtbl[24]))((IDXGIOutput3*)Unsafe.AsPointer(ref this), EnumFormat, pConcernedDevice, pFlags);
 	}
-
 }
 
 /// <include file='../Dxgi.xml' path='doc/member[@name="IDXGISwapChain3"]/*' />
@@ -7807,7 +7776,6 @@ public unsafe partial struct IDXGISwapChain3
 	{
 		return ((delegate* unmanaged[Stdcall]<IDXGISwapChain3*, uint, uint, uint, Common.Format, uint, uint*, IUnknown**, int>)(lpVtbl[39]))((IDXGISwapChain3*)Unsafe.AsPointer(ref this), BufferCount, Width, Height, Format, SwapChainFlags, pCreationNodeMask, ppPresentQueue);
 	}
-
 }
 
 /// <include file='../Dxgi.xml' path='doc/member[@name="IDXGIOutput4"]/*' />
@@ -8054,7 +8022,6 @@ public unsafe partial struct IDXGIOutput4
 	{
 		return ((delegate* unmanaged[Stdcall]<IDXGIOutput4*, Common.Format, Common.ColorSpaceType, IUnknown*, uint*, int>)(lpVtbl[25]))((IDXGIOutput4*)Unsafe.AsPointer(ref this), Format, ColorSpace, pConcernedDevice, pFlags);
 	}
-
 }
 
 /// <include file='../Dxgi.xml' path='doc/member[@name="IDXGIFactory4"]/*' />
@@ -8317,7 +8284,6 @@ public unsafe partial struct IDXGIFactory4
 	{
 		return ((delegate* unmanaged[Stdcall]<IDXGIFactory4*, Guid*, void**, int>)(lpVtbl[27]))((IDXGIFactory4*)Unsafe.AsPointer(ref this), riid, ppvAdapter);
 	}
-
 }
 
 /// <include file='../Dxgi.xml' path='doc/member[@name="IDXGIAdapter3"]/*' />
@@ -8500,7 +8466,6 @@ public unsafe partial struct IDXGIAdapter3
 	{
 		((delegate* unmanaged[Stdcall]<IDXGIAdapter3*, uint, void>)(lpVtbl[17]))((IDXGIAdapter3*)Unsafe.AsPointer(ref this), dwCookie);
 	}
-
 }
 
 /// <include file='../Dxgi.xml' path='doc/member[@name="IDXGIOutput5"]/*' />
@@ -8755,7 +8720,6 @@ public unsafe partial struct IDXGIOutput5
 	{
 		return ((delegate* unmanaged[Stdcall]<IDXGIOutput5*, IUnknown*, uint, uint, Common.Format*, IDXGIOutputDuplication**, int>)(lpVtbl[26]))((IDXGIOutput5*)Unsafe.AsPointer(ref this), pDevice, Flags, SupportedFormatsCount, pSupportedFormats, ppOutputDuplication);
 	}
-
 }
 
 /// <include file='../Dxgi.xml' path='doc/member[@name="IDXGISwapChain4"]/*' />
@@ -9122,7 +9086,6 @@ public unsafe partial struct IDXGISwapChain4
 	{
 		return ((delegate* unmanaged[Stdcall]<IDXGISwapChain4*, HdrMetadataType, uint, void*, int>)(lpVtbl[40]))((IDXGISwapChain4*)Unsafe.AsPointer(ref this), Type, Size, pMetaData);
 	}
-
 }
 
 /// <include file='../Dxgi.xml' path='doc/member[@name="IDXGIDevice4"]/*' />
@@ -9321,7 +9284,6 @@ public unsafe partial struct IDXGIDevice4
 	{
 		return ((delegate* unmanaged[Stdcall]<IDXGIDevice4*, uint, IDXGIResource**, ReclaimResourceResults*, int>)(lpVtbl[19]))((IDXGIDevice4*)Unsafe.AsPointer(ref this), NumResources, ppResources, pResults);
 	}
-
 }
 
 /// <include file='../Dxgi.xml' path='doc/member[@name="IDXGIFactory5"]/*' />
@@ -9592,7 +9554,6 @@ public unsafe partial struct IDXGIFactory5
 	{
 		return ((delegate* unmanaged[Stdcall]<IDXGIFactory5*, Feature, void*, uint, int>)(lpVtbl[28]))((IDXGIFactory5*)Unsafe.AsPointer(ref this), Feature, pFeatureSupportData, FeatureSupportDataSize);
 	}
-
 }
 
 /// <include file='../Dxgi.xml' path='doc/member[@name="IDXGIAdapter4"]/*' />
@@ -9783,7 +9744,6 @@ public unsafe partial struct IDXGIAdapter4
 	{
 		return ((delegate* unmanaged[Stdcall]<IDXGIAdapter4*, AdapterDescription3*, int>)(lpVtbl[18]))((IDXGIAdapter4*)Unsafe.AsPointer(ref this), pDesc);
 	}
-
 }
 
 /// <include file='../Dxgi.xml' path='doc/member[@name="IDXGIOutput6"]/*' />
@@ -10054,7 +10014,6 @@ public unsafe partial struct IDXGIOutput6
 	{
 		return ((delegate* unmanaged[Stdcall]<IDXGIOutput6*, uint*, int>)(lpVtbl[28]))((IDXGIOutput6*)Unsafe.AsPointer(ref this), pFlags);
 	}
-
 }
 
 /// <include file='../Dxgi.xml' path='doc/member[@name="IDXGIFactory6"]/*' />
@@ -10333,7 +10292,6 @@ public unsafe partial struct IDXGIFactory6
 	{
 		return ((delegate* unmanaged[Stdcall]<IDXGIFactory6*, uint, GpuPreference, Guid*, void**, int>)(lpVtbl[29]))((IDXGIFactory6*)Unsafe.AsPointer(ref this), Adapter, GpuPreference, riid, ppvAdapter);
 	}
-
 }
 
 /// <include file='../Dxgi.xml' path='doc/member[@name="IDXGIFactory7"]/*' />
@@ -10628,7 +10586,6 @@ public unsafe partial struct IDXGIFactory7
 	{
 		return ((delegate* unmanaged[Stdcall]<IDXGIFactory7*, uint, int>)(lpVtbl[31]))((IDXGIFactory7*)Unsafe.AsPointer(ref this), dwCookie);
 	}
-
 }
 
 /// <include file='../Dxgi.xml' path='doc/member[@name="IDXGIInfoQueue"]/*' />
@@ -10987,7 +10944,6 @@ public unsafe partial struct IDXGIInfoQueue
 	{
 		return ((delegate* unmanaged[Stdcall]<IDXGIInfoQueue*, Guid, Bool32>)(lpVtbl[39]))((IDXGIInfoQueue*)Unsafe.AsPointer(ref this), Producer);
 	}
-
 }
 
 /// <include file='../Dxgi.xml' path='doc/member[@name="IDXGIDebug"]/*' />
@@ -11058,7 +11014,6 @@ public unsafe partial struct IDXGIDebug
 	{
 		return ((delegate* unmanaged[Stdcall]<IDXGIDebug*, Guid, DebugRloFlags, int>)(lpVtbl[3]))((IDXGIDebug*)Unsafe.AsPointer(ref this), apiid, flags);
 	}
-
 }
 
 /// <include file='../Dxgi.xml' path='doc/member[@name="IDXGIDebug1"]/*' />
@@ -11153,7 +11108,6 @@ public unsafe partial struct IDXGIDebug1
 	{
 		return ((delegate* unmanaged[Stdcall]<IDXGIDebug1*, Bool32>)(lpVtbl[6]))((IDXGIDebug1*)Unsafe.AsPointer(ref this));
 	}
-
 }
 
 /// <include file='../Dxgi.xml' path='doc/member[@name="IDXGraphicsAnalysis"]/*' />
@@ -11232,7 +11186,6 @@ public unsafe partial struct IDXGraphicsAnalysis
 	{
 		((delegate* unmanaged[Stdcall]<IDXGraphicsAnalysis*, void>)(lpVtbl[4]))((IDXGraphicsAnalysis*)Unsafe.AsPointer(ref this));
 	}
-
 }
 
 #endregion Com Types

src/Vortice.Win32/Graphics/Direct2D/Matrix4x3.cs

@@ -73,7 +73,7 @@ public readonly struct Matrix4x3 : IEquatable<Matrix4x3>, IFormattable
     public readonly float M43;
 
     /// <summary>
-    /// Initializes a new instance of the <see cref="Matrix3x3"/> struct.
+    /// Initializes a new instance of the <see cref="Matrix4x3"/> struct.
     /// </summary>
     /// <param name="value">The value that will be assigned to all components.</param>
     public Matrix4x3(float value)

src/Vortice.Win32/Graphics/Direct3D11/UnorderedAccessViewDescription.cs

@@ -16,7 +16,7 @@ public unsafe partial struct UnorderedAccessViewDescription
     /// <param name="mipSlice">The index of the mipmap level to use mip slice or FirstElement for BUFFER.</param>
     /// <param name="firstArraySlice">The index of the first texture to use in an array of textures or NumElements for BUFFER or FirstWSlice for TEXTURE3D.</param>
     /// <param name="arraySize">Number of textures in the array or WSize for TEXTURE3D.</param>
-    /// <param name="flags"><see cref="BufferUnorderedAccessViewFlags"/> options flags for the resource.</param>
+    /// <param name="flags"><see cref="BufferUavFlags"/> options flags for the resource.</param>
     public UnorderedAccessViewDescription(
         UavDimension viewDimension,
         Format format = Format.Unknown,
@@ -67,7 +67,7 @@ public unsafe partial struct UnorderedAccessViewDescription
     /// <param name="format"></param>
     /// <param name="firstElement"></param>
     /// <param name="numElements"></param>
-    /// <param name="flags"><see cref="BufferUnorderedAccessViewFlags"/> options flags for the resource.</param>
+    /// <param name="flags"><see cref="BufferUavFlags"/> options flags for the resource.</param>
     public UnorderedAccessViewDescription(
         ID3D11Buffer* buffer,
         Format format,

src/Vortice.Win32/Graphics/Imaging/Apis.cs

@@ -0,0 +1,20 @@
+// Copyright © Amer Koleci and Contributors.
+// Licensed under the MIT License (MIT). See LICENSE in the repository root for more information.
+
+using System.Runtime.CompilerServices;
+using static Win32.Apis;
+
+namespace Win32.Graphics.Imaging;
+
+public static unsafe partial class Apis
+{
+    public static HResult CreateWICImagingFactory(IWICImagingFactory** factory)
+    {
+        return CoCreateInstance(
+            (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in CLSID_WICImagingFactory)),
+            null,
+            CLSCTX_INPROC_SERVER,
+            __uuidof<IWICImagingFactory>(),
+            (void**)factory);
+    }
+}

src/Vortice.Win32/Graphics/Imaging/IWICImagingFactoryExtensions.cs

@@ -0,0 +1,42 @@
+// Copyright © Amer Koleci and Contributors.
+// Licensed under the MIT License (MIT). See LICENSE in the repository root for more information.
+
+namespace Win32.Graphics.Imaging;
+
+/// <summary>
+/// A <see langword="class"/> with extensions for the <see cref="IWICImagingFactory"/> type.
+/// </summary>
+public static unsafe class IWICImagingFactoryExtensions
+{
+    public static ComPtr<IWICBitmapDecoder> CreateDecoderFromFilename(
+        this ref IWICImagingFactory factory,
+        string filename,
+        FileAccess desiredAccess = FileAccess.Read,
+        WICDecodeOptions metadataOptions = WICDecodeOptions.CacheOnDemand)
+    {
+        return CreateDecoderFromFilename(ref factory, filename.AsSpan(), desiredAccess, metadataOptions);
+    }
+
+    public static ComPtr<IWICBitmapDecoder> CreateDecoderFromFilename(
+        this ref IWICImagingFactory factory,
+        ReadOnlySpan<char> filename,
+        FileAccess desiredAccess = FileAccess.Read,
+        WICDecodeOptions metadataOptions = WICDecodeOptions.CacheOnDemand)
+    {
+        NativeFileAccess nativeAccess = desiredAccess.ToNative();
+
+        using ComPtr<IWICBitmapDecoder> decoder = default;
+
+        fixed (char* filenamePtr = filename)
+        {
+            factory.CreateDecoderFromFilename(
+                (ushort*)filenamePtr,
+                null,
+                nativeAccess,
+                metadataOptions,
+                decoder.GetAddressOf()).ThrowIfFailed();
+
+            return decoder.Move();
+        }
+    }
+}

src/Vortice.Win32/NativeFileAccess.cs

@@ -0,0 +1,34 @@
+// Copyright © Amer Koleci and Contributors.
+// Licensed under the MIT License (MIT). See LICENSE in the repository root for more information.
+
+namespace Win32;
+
+[Flags]
+public enum NativeFileAccess : uint
+{
+    None = 0,
+    [NativeTypeName("#define GENERIC_READ (0x80000000L)")]
+    GenericRead = 0x80000000u,
+    [NativeTypeName("#define GENERIC_WRITE (0x40000000L)")]
+    GenericWrite = 0x40000000u,
+}
+
+public static class NativeFileAccessExtensions
+{
+    public static NativeFileAccess ToNative(this FileAccess access)
+    {
+        switch (access)
+        {
+            case FileAccess.Read:
+                return NativeFileAccess.GenericRead;
+
+            case FileAccess.Write:
+                return NativeFileAccess.GenericWrite;
+
+            case FileAccess.ReadWrite:
+                return NativeFileAccess.GenericRead | NativeFileAccess.GenericWrite;
+            default:
+                return NativeFileAccess.None;
+        }
+    }
+}

src/Vortice.Win32/Win32.cs

@@ -3,10 +3,7 @@
 
 
 using System.ComponentModel;
-using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices.ComTypes;
 
 namespace Win32;
 
@@ -87,6 +84,13 @@ public static unsafe partial class Apis
         }
     }
 
+    public const int CLSCTX_INPROC_SERVER = 0x1;
+    public const int CLSCTX_INPROC_HANDLER = 0x2;
+    public const int CLSCTX_LOCAL_SERVER = 0x4;
+    public const int CLSCTX_INPROC_SERVER16 = 0x8;
+    public const int CLSCTX_REMOTE_SERVER = 0x10;
+    public const int CLSCTX_INPROC_HANDLER16 = 0x20;
+
     [DllImport("ole32", ExactSpelling = true)]
-    public static extern HResult CoCreateInstance([NativeTypeName("const IID &")] Guid* rclsid, [NativeTypeName("LPUNKNOWN")] IUnknown* pUnkOuter, [NativeTypeName("DWORD")] uint dwClsContext, [NativeTypeName("const IID &")] Guid* riid, [NativeTypeName("LPVOID *")] void** ppv);
+    public static extern HResult CoCreateInstance(Guid* rclsid, IUnknown* pUnkOuter, uint dwClsContext, Guid* riid, void** ppv);
 }

src/samples/01-ClearScreen/01-ClearScreen.csproj

@@ -1,12 +1,18 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFrameworks>net461;net6.0</TargetFrameworks>
+    <TargetFrameworks>net6.0</TargetFrameworks>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <IsPackable>false</IsPackable>
     <RootNamespace>ClearScreen</RootNamespace>
   </PropertyGroup>
+  
   <ItemGroup>
     <ProjectReference Include="..\..\Vortice.Win32\Vortice.Win32.csproj" />
   </ItemGroup>
+
+  <ItemGroup>
+    <Content Include="Assets\**" CopyToOutputDirectory="PreserveNewest" />
+  </ItemGroup>
+  
 </Project>

src/samples/01-ClearScreen/Program.cs

@@ -14,6 +14,10 @@ using Win32.Graphics.Dxgi.Common;
 using System.Numerics;
 using Win32.Graphics.Direct3D.Dxc;
 using static Win32.Graphics.Direct3D.Dxc.Apis;
+using System.Runtime.CompilerServices;
+using System.Security.Claims;
+using Win32.Graphics.Imaging;
+using static Win32.Graphics.Imaging.Apis;
 
 namespace ClearScreen;
 
@@ -45,9 +49,27 @@ public static unsafe class Program
         DxcCreateInstance(CLSID_DxcCompiler, __uuidof<IDxcCompiler3>(), compiler.GetVoidAddressOf());
     }
 
+    private static void TestWic()
+    {
+        string assetsPath = Path.Combine(AppContext.BaseDirectory, "Assets", "Textures");
+        string textureFile = Path.Combine(assetsPath, "10points.png");
+
+        using ComPtr<IWICImagingFactory> wicImagingFactory = default;
+
+        CreateWICImagingFactory(wicImagingFactory.GetAddressOf()).ThrowIfFailed();
+
+        using ComPtr<IWICBitmapDecoder> decoder = wicImagingFactory.Get()->CreateDecoderFromFilename(textureFile);
+
+        using ComPtr<IWICBitmapFrameDecode> wicBitmapFrameDecode = default;
+
+        // Get the first frame of the loaded image (if more are present, they will be ignored)
+        decoder.Get()->GetFrame(0, wicBitmapFrameDecode.GetAddressOf()).ThrowIfFailed();
+    }
+
     public static void Main()
     {
         TestDxc();
+        TestWic();
 
         using ComPtr<IDXGIFactory2> factory = default;
         uint factoryFlags = 0;